73-Java的Collection集合：概述、体系特点、常用API、遍历方式、存储自定义类型的对象

一、集合概述

• 集合和数组都是容器。

---

1、数组

• 特点： 数组 定义完成并启动后，类型确定、长度固定。
• 劣势： 在进行增删数据操作的时候，数组是不太合适的，增删数据都需要放弃原有数组或者移位。
• 使用场景： 当业务数据的个数是固定的，且都是同一批数据类型的时候，可以采取定义数组存储。

---

2、集合

• 集合 是Java中存储对象数据的一种容器。
• 特点： 集合的大小不固定，启动后可以动态变化，类型也可以选择不固定。集合更像是一个气球。
• 优势： 非常适合做增删数据的操作。
• 使用场景： 当业务数据的个数不固定，且需要进行增删数据的时候。可以采取定义集合存储。
• 注意：集合中只能存储引用类型数据，如果要存储基本类型数据可以选用基本类型对应的包装类。

---

总结

1、数组和集合的元素存储的个数问题？

• 数组定义后类型确定，长度固定；
• 集合类型可以不固定，大小可变。

2、数组和集合存储元素的类型问题？

• 数组可以存储基本类型和引用类型的数据；
• 集合只能存储引用类型的数据，如果想要存储基本类型的数据，可以选用基本类型对应的包装类。

3、数组和集合适合的场景？

• 当业务数据的个数确定、类型确定的时候，可以采取定义数组存储；
• 当业务数据的个数不固定，且需要对数据进行增删操作的时候，可以采取定义集合存储。

---

---

二、Collection集合的体系特点

1、集合类体系结构

• Collection 单列集合，每个元素（数据）只包含一个值。

• Map 双列集合，每个元素包含两个值（键值对）。

• 注意：前期先掌握Collection集合体系的使用。

---

---

2、Collection集合体系

---

• 在API文档的搜索框输入：Collection之后，回车

---

• 点进List接口看看：
  

  ---

• 点进ArrayList类看看：

• 想看其他的可以一层一层的点进来，因为都是有继承关系的。

---

---

3、Collection集合特点

• List系列集合： 添加的元素是有序的、可重复、有索引。

  • ArrayList、LinkedList： 有序、可重复、有索引。

• Set系列集合： 添加的元素是无序的、不重复、无索引。

  • HashSet： 无序、不重复、无索引；
    • LinkedHashSet： 有序、不重复、无索引。
  • TreeSet： 按照大小默认升序排序、不重复、无索引。

package com.app.d1_collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;

/**
    目标：明确Collection集合体系的特点
 */
public class CollectionDemo1 {
    public static void main(String[] args) {
        // 1、List系列的集合：有序、可重复、有索引
        // ArrayList list = new ArrayList();
        // 多态形式
        Collection arrayList = new ArrayList();
        arrayList.add("Java");
        arrayList.add("Java");
        arrayList.add("MyBatis");
        arrayList.add(23);
        arrayList.add(23);
        arrayList.add(false);
        arrayList.add(false);
        System.out.println("List系列：" + arrayList);

        System.out.println("-------------------------------");

        // 2、Set系列的集合：无序、不重复、无索引
        // 多态形式
        Collection hashSet = new HashSet();
        hashSet.add("Java");
        hashSet.add("Java");
        hashSet.add("MyBatis");
        hashSet.add(23);
        hashSet.add(23);
        hashSet.add(false);
        hashSet.add(false);
        System.out.println("Set系列：" + hashSet);
    }
}
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

List系列：[Java, Java, MyBatis, 23, 23, false, false]
-------------------------------
Set系列：[Java, false, 23, MyBatis]

Process finished with exit code 0
1
2
3
4
5

---

---

4、集合对于泛型的支持

• 集合都是支持泛型的，可以在编译阶段约束集合只能操作某种数据类型。

  Collection<String> lists = new ArrayList<String>();
  Collection<String> lists1 = new ArrayList<>();	// JDK 1.7开始后面的泛型类型申明可以省略不写
  1
  2

• 注意：集合和泛型都只支持引用数据类型，不支持基本数据类型，所以集合中存储的元素都认为是对象。

• 那有的同学就想当老六，调皮~~ 非得用基本数据类型

  Collection<int> lists1 = new ArraysList<>();	// 报错！！！
  Collection<double> lists2 = new ArrayList<>();	// 报错！！！
  1
  2

• 如果集合中要存储基本类型的数据咋整啊？

  • 存储基本类型的数据需要使用对应的包装类

  Collection<Integer> lists1 = new ArrayList<>();		// 存储基本类型的数据需要使用对应的包装类
  Collection<Double> lists2 = new ArrayList<>();		// 存储基本类型的数据需要使用对应的包装类
  1
  2

package com.app.d1_collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;

/**
    目标：明确Collection集合体系的特点
 */
public class CollectionDemo1 {
    public static void main(String[] args) {
        // 1、List系列的集合：有序、可重复、有索引
        // ArrayList list = new ArrayList();
        // 多态形式
        Collection arrayList = new ArrayList();
        arrayList.add("Java");
        arrayList.add("Java");
        arrayList.add("MyBatis");
        arrayList.add(23);
        arrayList.add(23);
        arrayList.add(false);
        arrayList.add(false);
        System.out.println("List系列：" + arrayList);


        // 2、Set系列的集合：无序、不重复、无索引
        // 多态形式
        Collection hashSet = new HashSet();
        hashSet.add("Java");
        hashSet.add("Java");
        hashSet.add("MyBatis");
        hashSet.add(23);
        hashSet.add(23);
        hashSet.add(false);
        hashSet.add(false);
        System.out.println("Set系列：" + hashSet);


        System.out.println("-------------------------------");
        // 3、集合都是支持泛型的，可以在编译阶段约束集合只能操作某种数据类型
        // Collection lists1 = new ArrayList();
        Collection<String> lists1 = new ArrayList<>();  // JDK7开始之后，右边的类型申明可以省略不写
        lists1.add("Java");
        lists1.add("Java");
        lists1.add("张飞");
        lists1.add("张飞");
        // lists1.add(34); // 报错！！受到约束：这个集合目前需要的是String类型，你给的数据是int类型
        System.out.println(lists1);

        Collection<String> lists2 = new HashSet<>();  // JDK7开始之后，右边的类型申明可以省略不写
        lists2.add("Java");
        lists2.add("Java");
        lists2.add("张飞");
        lists2.add("张飞");
        System.out.println(lists2);


        System.out.println("-------------------------------");
        // 注意：集合和泛型都只支持引用数据类型，不支持基本数据类型
        // Collection lists3 = new ArrayList<>();     // 报错！！
        // Collection lists4 = new ArrayList<>();     // 报错！！

        // 4、如果集合中要存储基本类型的数据，需使用对应的包装类来申明集合类型
        Collection<Integer> lists3 = new ArrayList<>();
        lists3.add(14);
        lists3.add(14);
        lists3.add(144);
        lists3.add(144);
        lists3.add(1444);
        System.out.println(lists3);

        Collection<Double> lists4 = new HashSet<>();
        lists4.add(14.0);
        lists4.add(14.0);
        lists4.add(144.4);
        lists4.add(144.4);
        lists4.add(1444.4);
        System.out.println(lists4);
    }
}
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

List系列：[Java, Java, MyBatis, 23, 23, false, false]
Set系列：[Java, false, 23, MyBatis]
-------------------------------
[Java, Java, 张飞, 张飞]
[Java, 张飞]
-------------------------------
[14, 14, 144, 144, 1444]
[14.0, 1444.4, 144.4]

Process finished with exit code 0
1
2
3
4
5
6
7
8
9
10

---

---

---

总结

1、集合的代表是？

• Collection接口。

2、Collection集合分了哪2大常用的集合体系？

• List系列的集合体系：添加的元素有序、可重复、有索引；
• Set系列的集合体系：添加的元素无序、不重复、无索引。
  • 注意：Set系列的集合，有些实现类可能会有些改变。
  • 就好比，现实生活中，你家族有个家规是每个人都必须遵守的，但是有个年轻后辈有了出息之后，会对家规做出一定的改变。

3、如何约定集合存储数据的类型，需要注意什么？

• 集合支持泛型；

• 集合和泛型不支持基本数据类型，只支持引用数据类型。

---

---

---

三、Collection集合的常用API

1、Collection集合

• Collection是单列集合的祖宗接口，它的功能是全部单列集合都可以继承使用的。

---

2、Collection的API：

package com.app.d1_collection;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;

/**
    目标：掌握Collection的常用API
 */
public class CollectionDemo2 {
    public static void main(String[] args) {
//         1、把给定的对象（元素）添加到当前集合中，成功为true，否则false
        System.out.println("---------添加对象（元素）----------");
        Collection<String> list1 = new ArrayList<>();
        list1.add("Java");      // true
        list1.add("Java");      // true
        list1.add("HTML");      // true
        list1.add("HTML");      // true
        list1.add("三国演义");   // true
        System.out.println("List系列list1集合：" + list1);

        Collection<Integer> list2 = new HashSet<>();
        list2.add(45);      // true
        list2.add(45);      // false 因为Set系列的集合，无序、不重复、无索引
        list2.add(888);     // true
        list2.add(66);      // true
        System.out.println("Set系列list2集合：" + list2);

        System.out.println();

//         2、把给定的对象（元素）在当前集合中删除，成功为true，否则false
        System.out.println("---------删除对象（元素）----------");
        System.out.println("从list1集合中删除\"html\"是否成功：" + list1.remove("html"));       // false 因为集合中无此对象（元素）
        System.out.println("从list1集合中删除\"Java\"是否成功：" + list1.remove("Java"));       // true
        System.out.println("从list2集合中删除\"45\"是否成功：" + list2.remove(45));           // true
        System.out.println("删除元素后：" + list1);
        System.out.println("删除元素后：" + list2);

        System.out.println("list1集合是否为空：" + list1.isEmpty());
        System.out.println("list2集合是否为空：" + list2.isEmpty());
        System.out.println();

//         3、判断当前集合中是否包含给定的对象（元素），包含true，否则false
        System.out.println("---------判断当前集合中是否包含给定的元素----------");
        System.out.println("list1集合中是否包含\"Java\"：" + list1.contains("Java"));         // true
        System.out.println("list2集合中是否包含\"45\"：" + list2.contains(45));               // false
        System.out.println("list1集合中是否包含\"三国演义\"：" + list1.contains("三国演义"));      // true

        System.out.println();

//         4、返回集合中元素的个数
        System.out.println("---------返回集合中元素的个数----------");
        System.out.println("list1集合中有" + list1.size() + "个元素");     // 4
        System.out.println("list2集合中有" + list2.size() + "个元素");     // 2

        System.out.println();

//         5、把集合中的所有元素，存储到数组中
        System.out.println("---------把集合中所有的元素存储到数组中----------");
        Object[] arr1 = list1.toArray();    // list1集合存储到数组arr1中
        Object[] arr2 = list2.toArray();    // list2结合存储到数组arr2中

        System.out.println("list1集合：" + list1);
        System.out.println("list1存储到数组arr1后：" + Arrays.toString(arr1));

        System.out.println("list2集合：" + list2);
        System.out.println("list2存储到数组arr2后：" + Arrays.toString(arr2));

        System.out.println();

//         6、清空集合中所有的元素
        System.out.println("---------清空集合中所有的元素----------");
        list1.clear();  // list1集合被清空所有元素
        System.out.println("list1集合：" + list1);
        System.out.println("list2集合：" + list2);

        System.out.println();

//         7、判断当前集合是否为空，为空true，否则false
        System.out.println("---------判断当前集合是否为空----------");
        System.out.println("list1集合是否为空：" + list1.isEmpty());   // true
        System.out.println("list2集合是否为空：" + list2.isEmpty());   // false

        System.out.println();

        System.out.println("--------------------------拓展---------------------------");
//         8、把一个集合中的所有元素拷贝到另一个集合中
        Collection<String> c1 = new ArrayList<>();
        c1.add("张翠山");
        c1.add("张无忌");
        System.out.println("c1集合：" + c1);

        Collection<String> c2 = new ArrayList<>();
        c2.add("赵敏");
        c2.add("殷素素");
        System.out.println("c2集合：" + c2);

        System.out.println("-------------------");

        // addAll方法：把c2集合的所有元素拷贝到c1集合中
        System.out.println("赵敏和殷素素是不是已经去张翠山和张无忌他们家了？" + c1.addAll(c2));
        System.out.println("c1集合：" + c1);
        System.out.println("c2集合：" + c2);
    }
}
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

---------添加对象（元素）----------
List系列list1集合：[Java, Java, HTML, HTML, 三国演义]
Set系列list2集合：[66, 888, 45]

---------删除对象（元素）----------
从list1集合中删除"html"是否成功：false
从list1集合中删除"Java"是否成功：true
从list2集合中删除"45"是否成功：true
删除元素后：[Java, HTML, HTML, 三国演义]
删除元素后：[66, 888]
list1集合是否为空：false
list2集合是否为空：false

---------判断当前集合中是否包含给定的元素----------
list1集合中是否包含"Java"：true
list2集合中是否包含"45"：false
list1集合中是否包含"三国演义"：true

---------返回集合中元素的个数----------
list1集合中有4个元素
list2集合中有2个元素

---------把集合中所有的元素存储到数组中----------
list1集合：[Java, HTML, HTML, 三国演义]
list1存储到数组arr1后：[Java, HTML, HTML, 三国演义]
list2集合：[66, 888]
list2存储到数组arr2后：[66, 888]

---------清空集合中所有的元素----------
list1集合：[]
list2集合：[66, 888]

---------判断当前集合是否为空----------
list1集合是否为空：true
list2集合是否为空：false

--------------------------拓展---------------------------
c1集合：[张翠山, 张无忌]
c2集合：[赵敏, 殷素素]
-------------------
赵敏和殷素素是不是已经去张翠山和张无忌他们家了？true
c1集合：[张翠山, 张无忌, 赵敏, 殷素素]
c2集合：[赵敏, 殷素素]

Process finished with exit code 0
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

---

---

拓展API

---

---

---

---

四、Collection集合的遍历

1、迭代器

• 遍历就是一个一个的把容器中的元素访问一遍。
• 迭代器在Java中的代表是 iterator ，迭代器是集合的专用遍历方式。

（1）Collection集合获取迭代器

---

（2）Iterator中的常用API

---

总结

1、迭代器的默认位置在哪里？

• 默认指向当前集合的索引0（第一个位置）。

2、迭代器如果取元素越界会出现什么问题？

• 会出现 NoSuchElementException 异常。

---

---

2、foreach（增强版的for循环）

• foreach：既可以遍历集合也可以遍历数组。

• 它是JDK5之后出现的，其内部原理是一个Iterator迭代器，遍历集合相当于是迭代器的简化写法。

• 实现Iterable接口的类才可以使用Iterator迭代器和foreach，Collection接口已经实现了Iterable接口

---

（2）foreach格式：

for(元素数据类型 变量名 : 数组或者Collection集合) {
	// 在此处使用变量即可，该变量就是元素
}
1
2
3

package com.app.d3_collection_foreach;

import java.util.ArrayList;
import java.util.Collection;

/**
    目标：学会使用foreach（增强for循环）来遍历Collection集合；
        foreach也可以遍历数组。
 */
public class ForeachDemo1 {
    public static void main(String[] args) {
        // 1、创建Collection集合，添加几个元素
        Collection<String> names = new ArrayList<>();
        names.add("殷素素");
        names.add("赵敏");
        names.add("小昭");
        names.add("周芷若");
        names.add("美杜莎");
        System.out.println(names);
        // [殷素素, 赵敏, 小昭, 周芷若, 美杜莎]
        //   ele

        // 2、使用foreach遍历Collection集合
        for (String ele : names) {
            System.out.print(ele + " ");
        }

        System.out.println("\n---------------------------------");

        // 3、创建一个数组，添加几个元素
        double[] scores = {100, 99.5, 67, 99, 88.9};
        //                 score

        // 4、使用foreach遍历数组
        for (double score : scores) {
            System.out.print(score + "\t");
        }
    }
}
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

[殷素素, 赵敏, 小昭, 周芷若, 美杜莎]
殷素素 赵敏 小昭 周芷若 美杜莎 
---------------------------------
100.0	99.5	67.0	99.0	88.9	
Process finished with exit code 0
1
2
3
4
5

---

总结

1、foreach（增强for）可以遍历哪些容器？

• 既可以遍历集合，也可以遍历数组。

2、foreach（增强for）的关键是记住它的遍历格式

for(元素数据类型 变量名 : 数组或者Collection集合) {
	// 在此处使用变量即可，该变量就是元素
}
1
2
3

---

---

3、Lambda表达式

• 得益于 JDK8 开始的新技术 Lambda 表达式，提供了一种更简单、更直接的遍历集合的方式。

---

（1）Collection结合Lambda遍历的API

package com.app.d3_collection_foreach;

import java.util.ArrayList;
import java.util.Collection;
import java.util.function.Consumer;

/**
    目标：掌握Collection结合Lambda表达式遍历的API：forEach()
 */
public class ForEachDemo2 {
    public static void main(String[] args) {
        // 1、创建Collection集合，添加几个元素
        Collection<String> names = new ArrayList<>();
        names.add("殷素素");
        names.add("赵敏");
        names.add("小昭");
        names.add("周芷若");
        names.add("美杜莎");
        System.out.println(names);
        // [殷素素, 赵敏, 小昭, 周芷若, 美杜莎]
        //    s

        // 2、得益于 `JDK8` 开始的新技术 `Lambda` 表达式，提供了一种更简单、更直接的遍历集合的方式
        // forEach
        
        // 原形式
//        names.forEach(new Consumer() {
//            @Override
//            public void accept(String s) {
//                System.out.println(s);
//            }
//        });

        
        // 进一步简化
//        names.forEach((String s) -> {
//                System.out.println(s);
//        });

        
        // 进一步简化
//        names.forEach( s -> {
//            System.out.println(s);
//        });

        
        // 进一步简化
        names.forEach( s -> System.out.println(s) );

        
        // 进一步简化
//        names.forEach( System.out::println );     // 拓展遍历形式
    }
}
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

[殷素素, 赵敏, 小昭, 周芷若, 美杜莎]
殷素素
赵敏
小昭
周芷若
美杜莎

Process finished with exit code 0
1
2
3
4
5
6
7
8

---

---

---

五、Collection集合存储自定义类型的对象

1、案例：影片信息展示

---

• 需求：

  • 某影院系统需要在后台存储上述三部电影，然后依次展示出来。

• 分析实现：

  • 1、定义电影类

    • 1-1、定义电影属性：电影名称、导演、主演、地区、类型、评分

    • 1-2、提供属性对应的getter、setter方法，暴露其取值和赋值

    • 1-3、提供无参、有参构造器，用于创建一个电影对象

    • 1-4、重写toString，格式化输出一个电影对象信息

  • 2、定义实现类

    • 2-1、定义一个集合用于存储电影对象
    • 2-2、创建3个电影对象，封装相关信息，将3个电影对象存入集合中
    • 2-3、遍历集合，依次展示电影信息

package com.app.d4_collection_test;

/**
    1、定义电影类
 */
public class Movie {
    /**
        1-1、定义电影属性：电影名称、导演、主演、地区、类型、评分
     */
    private String movieName;
    private String directName;
    private String StarringName;
    private String region;
    private String type;
    private double score;


    /**
        1-4、重写toString，格式化输出一个电影对象信息
     */
    @Override
    public String toString() {
        return "Movie{" +
                "movieName='" + movieName + '\'' +
                ", directName='" + directName + '\'' +
                ", StarringName='" + StarringName + '\'' +
                ", region='" + region + '\'' +
                ", type='" + type + '\'' +
                ", score=" + score +
                '}';
    }
    

    /**
        1-3、提供无参、有参构造器，用于创建一个电影对象
     */
    public Movie(){

    }

    public Movie(String movieName, String directName, String starringName, String region, String type, double score) {
        this.movieName = movieName;
        this.directName = directName;
        StarringName = starringName;
        this.region = region;
        this.type = type;
        this.score = score;
    }

    /**
        1-2、提供属性对应的getter、setter方法，暴露其取值和赋值
     */
    public String getMovieName() {
        return movieName;
    }

    public void setMovieName(String movieName) {
        this.movieName = movieName;
    }

    public String getDirectName() {
        return directName;
    }

    public void setDirectName(String directName) {
        this.directName = directName;
    }

    public String getStarringName() {
        return StarringName;
    }

    public void setStarringName(String starringName) {
        StarringName = starringName;
    }

    public String getRegion() {
        return region;
    }

    public void setRegion(String region) {
        this.region = region;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }
}
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

---

package com.app.d4_collection_test;

import java.util.ArrayList;
import java.util.Collection;

/**
    2、定义实现类
 */
public class MovieTest {
    public static void main(String[] args) {
        // 2-1、定义一个集合用于存储电影对象
        Collection<Movie> movies = new ArrayList<>();


        // 2-2、创建3个电影对象，封装相关信息，将3个电影对象存入集合中
        movies.add(new Movie("肖申克的救赎", "弗兰克·德拉邦特",
                "蒂姆·罗宾斯", "1994/美国", "犯罪 剧情", 9.7));
        movies.add(new Movie("霸王别姬", "陈凯歌",
                "张国荣/张丰毅", "1993/中国大陆 中国香港", "剧情 爱情 同性", 9.6));
        movies.add(new Movie("阿甘正传", "罗伯特·泽米吉斯",
                "汤姆·汉克斯", "1994/美国", "剧情 爱情", 9.5));


        System.out.println("------------------------");
        // 2-3、依次展示电影信息
        movies.forEach(movie -> {
            System.out.println(
                    "《" + movie.getMovieName() + "》"
                    + "\n导演：" + movie.getDirectName()
                    + "\n主演：" + movie.getStarringName()
                    + "\n地区：" + movie.getRegion()
                    + "\n类型：" + movie.getType()
                    + "\n评分：" + movie.getScore()
            );
            System.out.println("------------------------");
        });
    }
}
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

---

------------------------
《肖申克的救赎》
导演：弗兰克·德拉邦特
主演：蒂姆·罗宾斯
地区：1994/美国
类型：犯罪 剧情
评分：9.7
------------------------
《霸王别姬》
导演：陈凯歌
主演：张国荣/张丰毅
地区：1993/中国大陆 中国香港
类型：剧情 爱情 同性
评分：9.6
------------------------
《阿甘正传》
导演：罗伯特·泽米吉斯
主演：汤姆·汉克斯
地区：1994/美国
类型：剧情 爱情
评分：9.5
------------------------

Process finished with exit code 0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

---

2、执行原理

---

---

总结

1、集合中存储的是元素的什么信息？

• 集合中存储的是元素对象的地址。