一、集合概述
- 集合和数组都是容器。
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： 按照大小默认升序排序、不重复、无索引。
- HashSet： 无序、不重复、无索引；
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);
}
}
List系列：[Java, Java, MyBatis, 23, 23, false, false]
-------------------------------
Set系列：[Java, false, 23, MyBatis]
Process finished with exit code 0
4、集合对于泛型的支持
-
集合都是支持泛型的，可以在编译阶段约束集合只能操作某种数据类型。
Collection<String> lists = new ArrayList<String>(); Collection<String> lists1 = new ArrayList<>(); // JDK 1.7开始后面的泛型类型申明可以省略不写 -
注意：集合和泛型都只支持引用数据类型，不支持基本数据类型，所以集合中存储的元素都认为是对象。
-
那有的同学就想当老六，调皮~~ 非得用基本数据类型
Collection<int> lists1 = new ArraysList<>(); // 报错！！！ Collection<double> lists2 = new ArrayList<>(); // 报错！！！ -
如果集合中要存储基本类型的数据咋整啊？
- 存储基本类型的数据需要使用对应的包装类
Collection<Integer> lists1 = new ArrayList<>(); // 存储基本类型的数据需要使用对应的包装类 Collection<Double> lists2 = new ArrayList<>(); // 存储基本类型的数据需要使用对应的包装类
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<String> lists1 = new ArrayList<String>();
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<int> lists3 = new ArrayList<>(); // 报错！！
// Collection<double> 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);
}
}
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、集合的代表是？
- Collection接口。
2、Collection集合分了哪2大常用的集合体系？
- List系列的集合体系：添加的元素有序、可重复、有索引；
- Set系列的集合体系：添加的元素无序、不重复、无索引。
- 注意：Set系列的集合，有些实现类可能会有些改变。
- 就好比，现实生活中，你家族有个家规是每个人都必须遵守的，但是有个年轻后辈有了出息之后，会对家规做出一定的改变。
3、如何约定集合存储数据的类型，需要注意什么？
-
集合支持泛型；
-
集合和泛型不支持基本数据类型，只支持引用数据类型。
三、Collection集合的常用API
1、Collection集合
- Collection是单列集合的祖宗接口，它的功能是全部单列集合都可以继承使用的。
2、Collection的API：
| 方法 | 说明 |
|---|---|
| public boolean add(E e) | 把给定的对象（元素）添加到当前集合中 |
| public void clear() | 清空集合中所有的元素 |
| public boolean remove(E e) | 把给定的对象（元素）在当前集合中删除 |
| public boolean contains(Object o) | 判断当前集合中是否包含给定的对象（元素） |
| public boolean isEmpty() | 判断当前集合是否为空 |
| public int size() | 返回集合中元素的个数 |
| public Object[] toArray() | 把集合中的所有元素，存储到数组中 |
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);
}
}
---------添加对象（元素）----------
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
拓展API
| 方法 | 说明 |
|---|---|
| public boolean addAll(Collection<? extends E> c) | 把一个集合中的所有元素拷贝到另一个集合中 |
四、Collection集合的遍历
1、迭代器
- 遍历就是一个一个的把容器中的元素访问一遍。
- 迭代器在Java中的代表是
iterator，迭代器是集合的专用遍历方式。
（1）Collection集合获取迭代器
| 方法 | 说明 |
|---|---|
| Iterator< E > iterator() | 返回当前集合中元素的迭代器，该迭代器对象默认指向当前集合的0索引 |
（2）Iterator中的常用API
| 方法 | 说明 |
|---|---|
| boolean hasNext() | 询问当前位置是否有元素存在，存在返回true，否则返回false |
| E next() | 获取当前位置的元素，并同时将迭代器对象移向下一个位置，注意防止取出越界。 |
总结
1、迭代器的默认位置在哪里？
- 默认指向当前集合的索引0（第一个位置）。
2、迭代器如果取元素越界会出现什么问题？
- 会出现
NoSuchElementException异常。
2、foreach（增强版的for循环）
-
foreach：既可以遍历集合也可以遍历数组。
-
它是
JDK5之后出现的，其内部原理是一个Iterator迭代器，遍历集合相当于是迭代器的简化写法。 -
实现Iterable接口的类才可以使用Iterator迭代器和foreach，Collection接口已经实现了Iterable接口
（2）foreach格式：
for(元素数据类型 变量名 : 数组或者Collection集合) {
// 在此处使用变量即可，该变量就是元素
}
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");
}
}
}
[殷素素, 赵敏, 小昭, 周芷若, 美杜莎]
殷素素 赵敏 小昭 周芷若 美杜莎
---------------------------------
100.0 99.5 67.0 99.0 88.9
Process finished with exit code 0
总结
1、foreach（增强for）可以遍历哪些容器？
- 既可以遍历集合，也可以遍历数组。
2、foreach（增强for）的关键是记住它的遍历格式
for(元素数据类型 变量名 : 数组或者Collection集合) {
// 在此处使用变量即可，该变量就是元素
}
3、Lambda表达式
- 得益于
JDK8开始的新技术Lambda表达式，提供了一种更简单、更直接的遍历集合的方式。
（1）Collection结合Lambda遍历的API
| 方法 | 说明 |
|---|---|
| default void forEach(Consumer<? super T> action) | 结合Lambda遍历集合 |
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<String>() {
// @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 ); // 拓展遍历形式
}
}
[殷素素, 赵敏, 小昭, 周芷若, 美杜莎]
殷素素
赵敏
小昭
周芷若
美杜莎
Process finished with exit code 0
五、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;
}
}
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("------------------------");
});
}
}
------------------------
《肖申克的救赎》
导演：弗兰克·德拉邦特
主演：蒂姆·罗宾斯
地区：1994/美国
类型：犯罪 剧情
评分：9.7
------------------------
《霸王别姬》
导演：陈凯歌
主演：张国荣/张丰毅
地区：1993/中国大陆 中国香港
类型：剧情 爱情 同性
评分：9.6
------------------------
《阿甘正传》
导演：罗伯特·泽米吉斯
主演：汤姆·汉克斯
地区：1994/美国
类型：剧情 爱情
评分：9.5
------------------------
Process finished with exit code 0
2、执行原理
总结
1、集合中存储的是元素的什么信息？
- 集合中存储的是元素对象的地址。
243
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
