Java集合01：

一、集合框架的概述

一方面，面向对象语言对事物的体现都是以对象的形式，为了方便对多个对象的操作，就要对对象进行存储。另一方面，使用Array存储对象具有一些弊端，而Java集合就像一种容器，可以动态地把多个对象的引用放入容器中。

1. 集合和数组存储数组概述

集合、数组都是对多个数据进行存储操作的结构，简称Java容器。
说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储（.txt，.jpg，.avi，数据库中等）。

2.1 数组在存储多个数据方面的特点

一旦初始化之后，其长度就确定了。
数组一旦定义好，其元素的类型也就确定了，我们只能操作指定类型的数据。例如：String[ ] arr1; int[ ] arr2; Object[ ] arr2;

2.2 数组在存储多个数据方面的缺点

一旦初始化以后，其长度就不可修改，不便于扩展。
数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高。
获取数组中实际元素的个数的需求，数组没有已有的属性或方法可用。
数组存储数据的特点是有序的、可重复的。对于无序的、不可重复的需求无法满足。

二、集合框架

Java集合可分为Collection和Map两种体系。

1. Collection接口：单列数据，定义了存储一组对象的方法的集合。（用来存储一个一个的对象）
   1.1 List：存储有序的、可重复的数据。（“动态”数组）
       - ArrayList、 LinkedList、Vector
   1.2 Set：存储无序的、不可重复的数据。（高中讲的“集合”）
       - HashSet、LinkedHashSet、TreeSet
2. Map接口：双列数据，保存具有映射关系"key-value对"的集合。（用来存储一对一对的数据）（函数：y = f(x)）
       - HashMap、LinkedHashMap、TreeMap、Hashtable、Properties

三、Collection接口中的方法的使用

1.add(Object e)：将元素e添加到集合coll中
2.size()：获取添加的元素的个数
3.addAll(Collection coll1)：将coll1集合中的元素添加到当前的集合中
4.isempty()：判断当前集合是否为空
5.clear()：清空集合元素
6.contains(Object obj)：判断当前集合中是否包含obj
7.containsAll(Collection coll1)：判断形参coll1中的所有元素是否都存在于当前集合中
8.remove(Object obj)：从当前集合中移除obj元素
9.removeAll(Collection coll1)：从当前集合中移除coll1中所有的元素 差集（删除一样的，保留不一样的）
10.retainAll(Collection coll1)：获取当前集合和coll1集合的交集，并返回给当前集合 交集（删除不一样的，保留一样的）
11.equals(Object obj)：判断当前集合和形参obj的所有元素是否都相同
12.hashCode()：返回当前对象的哈希值
13.toArray()：集合 --> 数组 拓展：数组 --> 集合：调用Arrays类的静态方法asList()
14.iterator()：返回Iterator接口的实例，用于遍历集合元素。放在IteratorTest.java中测试。
注意：向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals()方法。

public class CollectionTest {
    @Test
    public void test1() {
        Collection coll = new ArrayList();

        //1.add(Object e)：将元素e添加到集合coll中
        coll.add("AA");
        coll.add("BB");
        coll.add(123); //自动装箱
        coll.add(new Date());

        //2.size()：获取添加的元素的个数
        System.out.println(coll.size()); //4

        //3.addAll(Collection coll1)：将coll1集合中的元素添加到当前的集合中
        Collection coll1= new ArrayList();
        coll1.add(456);
        coll1.add("CC");
        coll.addAll(coll1);
        System.out.println(coll); //[AA, BB, 123, Tue Jul 26 20:45:19 KST 2022, 456, CC]

        //4.isempty()：判断当前集合是否为空
        System.out.println(coll.isEmpty()); //false

        //5.clear()：清空集合元素
        coll.clear();
        System.out.println(coll.isEmpty()); //true
    }

    @Test
    public void test2() {
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry", 20));
        coll.add(new String("Tom"));
        coll.add(false);

        //6.contains(Object obj)：判断当前集合中是否包含obj
        //在判断时，我们会调用obj对象所在类的equals()方法。
        //向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals()方法。
        boolean contains = coll.contains(123);
        System.out.println(contains); //true
        System.out.println(coll.contains(new String("Tom"))); //true
        System.out.println(coll.contains(new Person("Jerry", 20))); //true  没有重写equals方法之前结果为false
        //因为Persom类中没有重写equals()方法，所以调用的是Object类的equals()方法，本质上是用"=="比较的，所以结果为false。

        //7.containsAll(Collection coll1)：判断形参coll1中的所有元素是否都存在于当前集合中
        Collection coll1 = Arrays.asList(123,456);
        System.out.println(coll.containsAll(coll1)); //true

        //8.remove(Object obj)：从当前集合中移除obj元素
        coll.remove(123);
        System.out.println(coll); //[456, Tom, false, Person{name='Jerry', age=20}]
        coll.remove(new Person("Jerry", 20));
        System.out.println(coll); //[456, Tom, false]

        //9.removeAll(Collection coll1)：从当前集合中移除coll1中所有的元素  差集（删除一样的，保留不一样的）
        Collection coll2 = Arrays.asList(123, false);
        coll.removeAll(coll2);
        System.out.println(coll); //[456, Tom]

        //10.retainAll(Collection coll1)：获取当前集合和coll1集合的交集，并返回给当前集合  交集（删除不一样的，保留一样的）
        Collection coll3 = Arrays.asList(123, 456, 789);
        coll.retainAll(coll3);
        System.out.println(coll); //[456]
    }

    @Test
    public void test3() {
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry", 20));
        coll.add(new String("Tom"));
        coll.add(false);

        //11.equals(Object obj)：判断当前集合和形参obj的所有元素是否都相同
        Collection coll1 = new ArrayList();
        coll1.add(123);
        coll1.add(456);
        coll1.add(new Person("Jerry", 20));
        coll1.add(new String("Tom"));
        coll1.add(false);
        System.out.println(coll.equals(coll1)); //true

        //12.hashCode()：返回当前对象的哈希值
        System.out.println(coll.hashCode()); //-1201413621

        //13.toArray()：集合 --> 数组
        Object[] arr = coll.toArray();
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

        //拓展：数组 --> 集合：调用Arrays类的静态方法asList()
        List<String> list = Arrays.asList(new String[]{"AA", "BB", "CC"});
        System.out.println(list); //[AA, BB, CC]

        List<int[]> list1 = Arrays.asList(new int[]{123, 456});
        System.out.println(list1); //[[I@32a1bec0]  将int[]识别为了一个元素

        List list2 = Arrays.asList(123, 456);
        System.out.println(list2); //[123, 456]  或使用new Integer[] {123, 456}

        //14.iterator()：返回Iterator接口的实例，用于遍历集合元素。放在IteratorTest.java中测试。
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

四、Iterator迭代器接口

Iterator对象称为迭代器（设计模式的一种），主要用于遍历Collection集合中的元素。
GOF给迭代器模式的定义为：提供一种方法访问一个容器（container）对象中各个元素，而又不需暴露该对象的内部细节。迭代器模式，就是为容器而生。 类似于"公交车上的售票员"、“火车上的乘务员”、“空姐”。
Collection接口继承了java.lang.Iterable接口，该接口有一个iterator()方法，那么所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了Iterator接口的对象。
Iterator仅用于遍历集合，Iterator本身并不提供承装对象的能力。如果需要创建Iterator对象，则必须有一个被迭代的集合。
集合对象每次调用iterator()方法都会得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。
内部定义了remove()方法，可以在遍历的时候，删除集合中的元素。此方法不同于集合直接调用remove()。
注意：如果还未调用next()方法或在上一次调用next()方法之后已经调用了remove()方法，再调用remove()都会报异常IllegalStateException
Iterator遍历集合的方法：
while (iterator2.hasNext()) {
  System.out.println(iterator2.next());
}

• hasNext()：判断是否还有下一个元素。
• next()：①指针下移； ②将下移之后集合位置上的元素返回
• remove()：在遍历的时候，删除当前指针指向的元素。

public class IteratorTest {

    @Test
    public void test1() {
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry", 20));
        coll.add(new String("Tom"));
        coll.add(false);

        //方式一：
        Iterator iterator = coll.iterator();
        System.out.println(iterator.next()); //123
        System.out.println(iterator.next()); //456
        System.out.println(iterator.next()); //Person{name='Jerry', age=20}
        System.out.println(iterator.next()); //Tom
        System.out.println(iterator.next()); //false
        //System.out.println(iterator.next()); //报异常：NoSuchElementException  没有这个元素

        //方式二：
        Iterator iterator1 = coll.iterator();
        for (int i = 0; i < coll.size(); i++) {
            System.out.println(iterator1.next());
        }

        //方式三：开发中通常使用这种方式遍历集合的元素
        Iterator iterator2 = coll.iterator();
        while (iterator2.hasNext()) {
            System.out.println(iterator2.next());
        }
    }

    @Test
    public void test2() {
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry", 20));
        coll.add(new String("Tom"));
        coll.add(false);

        //删除集合中的"Tom"
        Iterator iterator = coll.iterator();
        while (iterator.hasNext()) {
            Object obj = iterator.next();
            if ("Tom".equals(obj)) {
                iterator.remove();
            }
        }

        System.out.println(coll); //[123, 456, Person{name='Jerry', age=20}, false]
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

五、For-each循环

jdk5.0新增了For-each循环，用于遍历集合、数组

public class ForeachTest {
    @Test
    public void test() {
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry", 20));
        coll.add(new String("Tom"));
        coll.add(false);

        //for(集合元素的类型  局部变量 : 集合对象){}
        //内部仍然调用了迭代器
        for (Object obj: coll) {
            System.out.println(obj);
        }
    }

    @Test
    public void test2() {
        int[] arr = new int[] {1, 2, 3, 4, 5, 6};
        //for(数组元素的类型  局部变量 : 数组对象){}
        for (int i : arr) {
            System.out.println(i);
        }
    }

    @Test
    //练习
    public void test3() {
        String[] arr = new String[] {"MM", "MM", "MM"};
        //方式一：普通for循环赋值
        for (int i = 0; i < arr.length; i++) {
            arr[i] = "GG";
        }

        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

        String[] arr1 = new String[] {"MM", "MM", "MM"};
        //方式二：增强for循环
        for (String s : arr1) {
            s = "GG"; //将arr1中的元素赋值给s，然后修改s的值。所以不会改变原有数组中的元素。
        }

        for(int i = 0; i < arr1.length; i++) {
            System.out.println(arr1[i]);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52