JAVASE之集合

ゝ一纸荒年。 2022-07-16 06:28 216阅读 0赞

集合：

## List和Set ##

![这里写图片描述][20161009143305991]

**List可重复，Set可重复**

**重不重复就是用equals比较的结果**

查看集合中是否包含给定的元素

没重写equals还是判断是否是同一个对象，用的双等于

**c.contanins(元素); 判断集合中是否包含某元素**

包含取决于集合中的元素是否有与给定元素equals比较为true的  
但是没有放进集合也有可能不包含。

给定的元素与集合中的每一个元素equals比较。

集合的其他方法

public static void main(String[] args) {
    
            Collection c = new ArrayList();
            int s1 = c.size();
            System.out.println("size:"+s1);
            /* * boolean isEmpry() * 查看集合中是否不含有任何元素 * 就是是空的吗？ */
            boolean e1 = c.isEmpty();
            System.out.println(e1);
            //增加元素
            c.add("111");
            c.add(123);
    
            int s2 = c.size();
            System.out.println("size:"+s2);
            boolean e2 = c.isEmpty();
            System.out.println(e2);
    
            c.clear();
            boolean e3 = c.isEmpty();
            System.out.println(e3);
        }

![这里写图片描述][20161009143348789]

## addAll、containsAll ##

![这里写图片描述][20161009143425564]

**一般也在集合中放同一类的元素**

## addALL方法 ##

public static void main(String[] args) {
    
            Collection conn1 = new ArrayList();
            conn1.add("java");
            conn1.add(".net");
            conn1.add("c#");
            conn1.add("php");
    
            System.out.println(conn1);
    
            Collection conn2 = new ArrayList();
            conn2.add("android");
            conn2.add("ios");
            //addALL就是把另一个List中的元素放入这个List中
            conn1.addAll(conn2);
            System.out.println(conn1);
        }

![这里写图片描述][20161009143511142]

Collection conn3 = new ArrayList();
            conn3.add("java");
            conn3.add("ios");
            //查看当前集合中是否保护给定集合中的所有元素，
            //也是根据元素的equals来判断的。
            boolean b = conn1.containsAll(conn3);
    
            System.out.println("全包含:"+b);
        }

![这里写图片描述][20161009143541416]

## 删除 remove ##

**传入参数： 要删除什么传入什么，然后比较用的是equals**

boolean remove(object o)

从当前集合中删除给定元素  
删除元素是根据元素的equals的结果判断

**remove只删除第一个遇到的元素**

## 使用迭代器遍历List中元素： ##

public class CollectionIterator {
    
        public static void main(String[] args) {
            Collection c = new ArrayList();
            c.add("a");
            c.add("b");
            c.add("c");
            c.add("d");
            c.add("e");
            /* * Iteartor是一个接口 * java希望我们使用统一的方式遍历所有集合 * 使用迭代器遍历集合必须遵循以下过程 * 问，取，删（删除不是必须操作） * */
            Iterator it =c.iterator();
            /* * boolean hashNext（） * 询问迭代器，遍历的集合是否还有元素可以取出 * 用while循环判断，有就继续取出，在list中都认为是object，什么都能取出来 * 然后用object 接受 取出的，然后在给他强制转换为字符串 */
            while (it.hasNext()){
                Object obj = it.next();
                String str = (String)obj;
                System.out.println(str);
    //可以直接： String str = (String)it.next();
            }
        }

!!!  
**尽量使用字面量.equals(变量)**  
这样可以避免空指针异常的产生  
**如果在迭代器中 it.remove();要在前面it.next()才行，然后remove删除当前next出来的元素**

。。。。。  
另一种遍历集合的方法(java5.0后)  
比迭代器更方便：

public static void main(String[] args) {
    
            Collection c = new ArrayList();
            c.add("one");
            c.add("two");
            c.add("three");
            c.add("four");
            //新循环
            for(Object a:c){
                String str = (String)a;
                System.out.println(str);
    
            }

**当然也可以用新循环遍历数组**

## 泛型机制： ##

![这里写图片描述][20161009143723325]

在类后面加个尖括号 ，一般一个字母，这个类型叫T，也可以叫别的。声明了T这么一个类型。  
于是可以 在定义属性时 返回值可以定义为 T这个类型  
在用的时候给真实类型  
如：  
在写一个类，

public class TypeDemo<T>{
        private int x;
        public TypeDemo(int x){
            this.x =x;
        }
        public String toString(){
    
            return x+"";
        }

然后在实例化时给到底是什么类型的

TypeDemo<String> t = new TypeDemo<String>(“qw”);

在类中的get，set方法中也要设置返回值为T

！！！！！  
尖括号中只能写引用类型不能是基本类型也就是说要是用int就要：写 Integer  
不能写基本类型，先不告诉他什么类型，后面用的时候告诉他

## 在集合中的泛型 ##

public static void main(String[] args) {
            //所有的集合都支持泛型，那么一般一个集合的类型一样的话，可以直接用泛型指定为什么类型
            Collection<String> c = new ArrayList();
            c.add("one");
            c.add("two");
            c.add("three");
            c.add("four");
            //因为泛型定义了是String，那么直接就可以赋值输出了
            for(String o:c){
                System.out.println(o);
    
            }
    
        }
    
    迭代器也可以用泛型
    Iterator<String>

## List ##

分为：  
ArrayList和LinkList

![这里写图片描述][20161009143906253]

ArrayList 内部是数组实现的 适用查找  
LinkList内部是用于链表实现的 适用增删

List除了继承Coleection定义的方法外，还根据其线性表的数据结构定义了一系列方法，其中最长远的就是基于下标的get和set方法：  
get(int index)  
获取集合中指定下标对应的元素，下标从0开始  
set(int index ,E element)  
将给定的元素存入给定位置，并将原位置的元素返回。  
相当于给替换了，然后把集合中的元素取出来。

List<String> c = new ArrayList();
            c.add("one");
            c.add("two");
            c.add("three");
            c.add("four");
        System.out.println(c.get(1));
        System.out.println(c.set(1, "five"));
        System.out.println(c.get(1));
        }

## List集合的插入和删除 ##

**插入指定位置**

![这里写图片描述][20161009144004488]

List<String> list = new ArrayList();
    
            list.add("one");
            list.add("two");
            list.add("three");
            /* * void add(int index ,T t) * 将给定的元素添加到给定的位置上 * 原位置以及后续的元素顺序向后移动 * 插入操作 */
            System.out.println(list);
            list.add(1,"123");
            System.out.println(list);

**同样，remove是删除指定下标的元素，然后返回值是删除的元素。**

## List获取子集的方法： ##

public class ListDemo3 {
        public static void main(String[] args) {
            List<Integer> list = new ArrayList();
            for (int i=0;i<10;i++){
                list.add(i);    
            }
            System.out.println(list);
            /* * List subList(int start, int end) * 获取当前集合的子集 */
            List<Integer> list1 = list.subList(3, 8);
            System.out.println(list1);
        }

![这里写图片描述][20161009144108660]

！！！！！！！  
**修改子集元素会影响原集合**  
！！！！！！

## List转换为数组： ##

![这里写图片描述][20161009144144769]

集合转成数组容易，但是数组只能转为List

public static void main(String[] args) {
            Collection<String> c = new ArrayList<String>();
            c.add("one");
            c.add("two");
            c.add("thiree");
            //直接用toArray的话返回的是Object
            //Object[] array =c.toArray();
            //但是向方法里面传个数组就直接可以定义它的类型
            String [] array=c.toArray(new String[c.size()]);
            //如果传入的数组不够长，他会自己创建个同类型的数组
            //长度够就用
        }

## 数组转为List ##

public static void main(String[] args) {
            String [] array = {
       "1","2","3","4","5"};
            List<String> list = Arrays.asList(array);
            //但是转换为List后，不能在增加了。是只读的
        }

可以增加的话就在自己创建个List

public static void main(String[] args) {
            String [] array = {
       "1","2","3","4","5"};
            List<String> list = Arrays.asList(array);
            //但是转换为List后，不能在增加了。是只读的’
            //要想添加就要复制个,可以直接把另一个List在创建List时直接传入，就相当于复制了一哈
            List<String> list2 = new ArrayList(list);
            list2.add("6");
            System.out.println(list2);
        }

![这里写图片描述][20161009144254552]

## 集合的排序： ##

public static void main(String[] args) {
            List<Integer> c = new ArrayList();
    
            Random random = new Random();
    
            for(int i=0;i<10;i++){
                c.add(random.nextInt(100));
            }
            System.out.println(c);
            //通过Collections这个集合的工具类
            //我们可以对List集合进行孜然排序
            Collections.sort(c);
            System.out.println(c);      
        }

![这里写图片描述][20161009144328662]

如果List中的是对象的话，不能用Collections.sort排序，如果用的话要是可以排序的  
使用Colletions的sort方法进行排序的集合，要求元素必须实现Comparable接口，只有实现了该接口才认为是可比较的元素

**那么就可以让那个对象被实例的类实现接口 Comparable**  
**即：**

类 implements Comparable<类（就是这个类，说明和自己比）>{
    
    }

**这个是比较大小的方法**

返回值不关注具体的值，只关注取值范围
    返回值<0： 当前对象比给定的对象小 返回值=0： 两个对象相等 返回值>0： 当前对象比给定的对象大
    在下面就实现方法 compare(类 o){
    在这里可以自己定义比较规划，定义比较什么，规定什么大，什么小。
    
    return 两个值的差
    }

就是用泛型说明比较的就是自己这个类，然后下面传入的参数也就变成了这个类

**实现了接口就可以比较对象的大小了~~~**

对于字符串排序的话，按首字母排序，相同看第二个~~

对于汉字的排序的话，按照 Unicode排序的。

如果要让他按我想的排序，就是按字符串长短排序

不能重写~

## 比较器： ##

写个类，然后实现接口 Comparator\{

public int compare(String o1, String o2){
    return o1.length()-o2.length()；
    }
    }

**然后在比较之前创建一个比较器，实例化这个类**

Comparator com = new 那个类();

然后把创建的比较器和list一起传入Collection，调用sort排序方法进行比较，就按自己定义的排序方式来比较  
Collections.sort(list,com);

## 何时使用匿名内部类 ##

当我们需要用到一个实例，而该实例所属的类需要实现一个接口或者继承一个类，并且该实例仅在这里用一次，不会再其他地方使用时，我们就应当选取使用匿名内部类的形式创建实例

例如：  
**使用比较器**

Comparator com = new Comparator(){
    public int compare(Object o1,Object o2){
    return 0;
    }
    };

**还是可以使用泛型**

Comparator com = new Comparator<类名>(){
    public int compare(类名 o1,类名 o2){
    return o1.属性-o2.属性;
    }
    };
    
    然后Collections.sort(list,com);

[20161009143305991]: /images/20220716/e631958a01c147648f9308c103744951.png
[20161009143348789]: /images/20220716/e3a34412600842acb6c300895c5a3f16.png
[20161009143425564]: /images/20220716/04938be4d9fa402ab22e7004ed6f2d9c.png
[20161009143511142]: /images/20220716/4a99446240fd453baab3e3c5c3bfa326.png
[20161009143541416]: /images/20220716/74734240b3d54d069376a0a907667e2d.png
[20161009143723325]: /images/20220716/a055607316564619b6b1af26061d1629.png
[20161009143906253]: /images/20220716/d23c9e4505b04d2a9a5dc1b2c2c53a50.png
[20161009144004488]: /images/20220716/7fb66ccf24a643c3a172642ed83d0094.png
[20161009144108660]: /images/20220716/983dc912d61a410a8e5c69c0632d077d.png
[20161009144144769]: /images/20220716/907d41bfc65840bdbf30cbeea5e92a35.png
[20161009144254552]: /images/20220716/fead8a2aa7f1498ea4f70dff70053fa8.png
[20161009144328662]: /images/20220716/8ced1d42660f4ac0b04723478acba842.png