一、集合概述
- 集合和数组都是容器。
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、集合中存储的是元素的什么信息?
- 集合中存储的是元素对象的地址。