一. 集合
- 集合与数组类似，都是一种容器。
- 集合是Java中存储对象数据的一种容器。
- 集合也被称为对象容器。
数组的特点
集合的特点
- 集合的大小不固定，启动后可以动态变化，类型也可以选择不固定。集合更像气球，可大可小。
- 集合非常适合做元素个数不能确定，且要做元素的增删操作的场景。
- 同时，集合提供的种类特别丰富，功能也是非常强大的，开发中集合用的更多。
- 注意：集合中只能存储引用类型数据，如果要存储基本类型数据可以选用包装类。
- 包装类：把基本数据类型变成了一个引用数据类型，不是基本数据而是对象数据。
- 数据也可以称为元素。
二. 集合的体系特点
集合类体系结构
Collection集合体系
- Collection接口是单列集合的祖宗接口。
- Collection集合不支持索引，不能用fori来遍历。
- List接口和Set接口都继承了Collection接口。
- ArrayList和LinkedList实现了List接口，实现类就是一种所谓的子类。
- ArrayList和LinkedList它们底层存储数据的结构是不一样的，在以后做增删操作的时候，它们的性能是有差别的。
- Collection集合并没有规定什么特点，它只是代表了一个普通集合，真正分特点的是由List和Set分特点的。
- 添加的元素有序：先加了的元素在前面，后加了的元素在后面。
- 可重复：允许有同样的值的元素。
- 有索引：就是说第一个元素的索引是0，第二个元素的索引是1。
- 添加的元素无序：先加的元素可能是跑到后面去了，后加的元素可能是跑到前面去了。
- 不重复：就是不允许有两个同样的值在里面，它会去重复的。
- 集合打内容，因为集合本身已经重写了toString方法了，所以它里面打的是内容。
泛型
泛型相当于是一个标签
package com.gch.d1_collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
/**
目标:明确Collection集合体系的特点
*/
public class CollectionDemo1 {
public static void main(String[] args) {
// List系列集合:添加的元素是有序、可重复、有索引
// 把子类对象给到父类接口,父类引用指向子类对象,这是多态的写法
Collection list = new ArrayList();
list.add("Java");
list.add("Java");
list.add("Mybatis");
list.add(23);
list.add(23);
list.add(false);
list.add(false);
System.out.println(list); // [Java, Java, Mybatis, 23, 23, false, false]
// Set系列集合:添加的元素是无序、不重复、无索引
Collection list1 = new HashSet();
list1.add("Java");
list1.add("Java");
list1.add("Mybatis");
list1.add(23);
list1.add(23);
list1.add(false);
list1.add(false);
System.out.println(list1); // [Java, false, 23, Mybatis]
System.out.println("------------------泛型-------------------");
// Collection<String> list2 = new ArrayList<String>();
// 泛型相当于是一个标签
Collection<String> list2 = new ArrayList<>(); // 从JKD7开始之后后面的泛型类型申明可以省略不写
list2.add("Java");
// list2.add(23); // 直接报错,添加的类型为String
list2.add("Mybatis");
// 集合也被称为对象容器
// 集合和泛型不支持基本数据类型,只能支持引用数据类型
Collection<Integer> list3 = new ArrayList<>();
list3.add(23); // 自动装箱
list3.add(233);
list.add(2333);
Collection<Double> list4 = new ArrayList<>();
list4.add(23.4);
list4.add(23.0);
list4.add(233.3);
}
}
三. Collection集合常用API
package com.gch.d2_collection_api;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
/**
目标：Collection集合的常用API.
Collection是集合的祖宗类，它的功能是全部集合都可以继承使用的，所以要学习它。
Collection API如下:
- public boolean add(E e)： 把给定的对象添加到当前集合中 。
- public void clear() :清空集合中所有的元素。
- public boolean remove(E e): 把给定的对象在当前集合中删除。
- public boolean contains(Object obj): 判断当前集合中是否包含给定的对象。
- public boolean isEmpty(): 判断当前集合是否为空。
- public int size(): 返回集合中元素的个数。
- public Object[] toArray(): 把集合中的元素，存储到数组中。
小结：
记住以上API。
*/
public class CollectionDemo {
public static void main(String[] args) {
// HashSet:添加的元素是无序，不重复，无索引。
Collection<String> c = new ArrayList<>();
// List集合允许元素重复,基本上添加元素不会失败
// 1.添加元素, 添加成功返回true。
c.add("Java");
c.add("HTML");
System.out.println(c.add("HTML"));
c.add("MySQL");
c.add("Java");
System.out.println(c.add("黑马"));
System.out.println(c); // [Java, HTML, HTML, MySQL, Java, 黑马]
// 2.清空集合的元素。
// c.clear(); // 直接清空集合的元素
// System.out.println(c); // []
// 3.判断集合是否为空 是空返回true,反之。
// System.out.println(c.isEmpty());
// 4.获取集合的大小。
System.out.println(c.size());
// 5.判断集合中是否包含某个元素。 精准匹配的
System.out.println(c.contains("Java")); // true
System.out.println(c.contains("java")); // false
System.out.println(c.contains("黑马")); // true
// 6.删除某个元素:如果有多个重复元素默认删除前面的第一个！
// 只能通过元素值来删,不能通过索引删,因为这个集合是Collection类型的一个集合。
System.out.println(c.remove("java")); // false
System.out.println(c);
System.out.println(c.remove("Java")); // true
System.out.println(c);
// 7.把集合转换成数组 [HTML, HTML, MySQL, Java, 黑马]
Object[] arrs = c.toArray(); // 数组:[HTML, HTML, MySQL, Java, 黑马]
System.out.println("数组:" + Arrays.toString(arrs));
System.out.println("----------------------拓展----------------------");
Collection<String> c1 = new ArrayList<>();
c1.add("java1");
c1.add("java2");
Collection<String> c2 = new ArrayList<>();
c2.add("赵敏");
c2.add("殷素素");
// addAll把c2集合的元素全部倒入到c1中去。c2里面的数据还是在的
c1.addAll(c2);
System.out.println(c1); // [java1, java2, 赵敏, 殷素素]
System.out.println(c2); // [赵敏, 殷素素]
}
}
四. Collection集合的遍历方式
- 方式一：迭代器
- 方式二：foreach/增强for循环
- 方式三：lambda表达式
方式一：迭代器 迭代器是不能遍历数组的
package com.gch.d3_collection_traversal;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
a.迭代器遍历集合。
--流程：
1.先获取当前集合的迭代器
Iterator<String> it = lists.iterator();
2.定义一个while循环，问一次取一次。
通过it.hasNext()询问是否有下一个元素，有就通过
it.next()取出下一个元素。
小结：
记住代码。
*/
public class CollectionDemo01 {
public static void main(String[] args) {
ArrayList<String> lists = new ArrayList<>();
lists.add("赵敏");
lists.add("小昭");
lists.add("素素");
lists.add("灭绝");
System.out.println(lists); // [赵敏, 小昭, 素素, 灭绝]
// [赵敏, 小昭, 素素, 灭绝]
// it
System.out.println("--------------1.迭代器遍历--------------");
// public interface Iterator<E> Iterator是一个泛型接口
// 1、得到当前集合的迭代器对象。 这个迭代器就是遍历器的意思
Iterator<String> it = lists.iterator();
// // next是先取元素再移位的
// String ele = it.next();
// System.out.println(ele); // 赵敏
// System.out.println(it.next()); // 小昭
// System.out.println(it.next()); // 素素
// System.out.println(it.next()); // 灭绝
// 访问越界了,运行报错
// System.out.println(it.next()); // NoSuchElementException 出现没有/无此元素异常的错误
// boolean hasNext():询问当前位置是否有元素存在,存在返回true,不存在返回false
// E next():获取当前位置的元素,并同时将迭代器对象移向下一个位置,注意防止取出越界。
// 2、定义while循环(问一次取一次)
while (it.hasNext()){ // while循环一旦条件是false,循环结束
String ele = it.next();
System.out.println(ele);
}
// 迭代器的默认位置是在集合元素的第一个位置,也就是索引为0的位置
}
}
方式二：foreach/增强for循环
增强for循环
- 增强for循环：既可以遍历集合也可以遍历数组。
- 它是JDK5之后出现的，其内部原理是一个iterator迭代器，遍历集合相当于是迭代器的简化写法。
- 实现iterable接口的类才可以使用迭代器和增强for，Collection接口已经实现了iterable接口。
- 格式：
package com.gch.d3_collection_traversal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
/**
目标：Collection集合的遍历方式。
什么是遍历? 为什么开发中要遍历？
遍历就是一个一个的把容器中的元素访问一遍。
开发中经常要统计元素的总和，找最值，找出某个数据然后干掉等等业务都需要遍历。
Collection集合的遍历方式是全部集合都可以直接使用的，所以我们学习它。
Collection集合的遍历方式有三种:
（1）迭代器。
（2）foreach(增强for循环)。
（3）JDK 1.8开始之后的新技术Lambda表达式。
b.foreach(增强for循环)遍历集合。
foreach是一种遍历形式，可以遍历集合或者数组。
foreach遍历集合实际上是迭代器遍历集合的简化写法。
foreach遍历的关键是记住格式：
for(被遍历集合或者数组中元素的类型 变量名称 : 被遍历集合或者数组){
}
*/
public class CollectionDemo02 {
public static void main(String[] args) {
System.out.println("-------------------2.foreach遍历/增强for循环------------------------");
Collection<String> lists = new ArrayList<>();
lists.add("赵敏");
lists.add("小昭");
lists.add("殷素素");
lists.add("周芷若");
System.out.println(lists);
// [赵敏, 小昭, 殷素素, 周芷若]
// ele
System.out.println("------------------foreach遍历/增强for循环遍历集合----------------------");
// foreach只是个技术名称,真正用到的还是for关键字
for (String ele : lists) {
System.out.println(ele);
}
System.out.println("--------------------foreach遍历数组/增强for循环遍历数组---------------------------");
double[] scores = {100, 99.5 , 59.5};
for (double score : scores) {
System.out.println(score);
}
for (double score : scores) {
System.out.println(score);
if(score == 59.5){
score = 100.0; // foreach遍历修改变量无意义，不会影响数组的元素值。
}
}
System.out.println(Arrays.toString(scores)); // [100.0, 99.5, 59.5]
}
}
方式三：Lambda表达式
package com.gch.d3_collection_traversal;
import java.util.ArrayList;
import java.util.Collection;
import java.util.function.Consumer;
/**
目标：Collection集合的遍历方式。
Collection集合的遍历方式有三种:
（1）迭代器。
（2）foreach(增强for循环)。
（3）JDK 1.8开始之后的新技术Lambda表达式。
c.JDK 1.8开始之后的新技术Lambda表达式。
*/
public class CollectionDemo03 {
public static void main(String[] args) {
Collection<String> lists = new ArrayList<>();
lists.add("赵敏");
lists.add("小昭");
lists.add("殷素素");
lists.add("周芷若");
System.out.println(lists); // [赵敏, 小昭, 殷素素, 周芷若]
System.out.println("--------------3.Lambda表达式遍历-------------");
// [赵敏, 小昭, 殷素素, 周芷若]
// s
lists.forEach(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
});
// lists.forEach(s -> {
// System.out.println(s);
// });
// lists.forEach(s -> System.out.println(s) );
lists.forEach(System.out::println);
}
}
五. Collection集合存储自定义类型的对象
- 结论：集合中存储的是元素对象的地址。
package com.gch.d4_collection_object;
public class Movie {
private String name;
private double score;
private String actor;
public Movie() {
}
public Movie(String name, double score, String actor) {
this.name = name;
this.score = score;
this.actor = actor;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
public String getActor() {
return actor;
}
public void setActor(String actor) {
this.actor = actor;
}
@Override
public String toString() {
return "Movie{" +
"name='" + name + '\'' +
", score=" + score +
", actor='" + actor + '\'' +
'}';
}
}
package com.gch.d4_collection_object;
import java.util.ArrayList;
import java.util.Collection;
public class TestDemo {
public static void main(String[] args) {
// 1、定义一个电影类
// 2、定义一个集合对象存储3部电影对象
Collection<Movie> movies = new ArrayList<>();
movies.add(new Movie("《你好，李焕英》", 9.5, "张小斐,贾玲,沈腾,陈赫"));
movies.add(new Movie("《唐人街探案》", 8.5, "王宝强,刘昊然,美女"));
movies.add(new Movie("《刺杀小说家》",8.6, "雷佳音,杨幂"));
System.out.println(movies);
// 3、遍历集合容器中的每个电影对象
for (Movie movie : movies) {
System.out.println("片名:" + movie.getName());
System.out.println("评分:" + movie.getScore());
System.out.println("主演:" + movie.getActor());
}
}
}
