集合框架
目录
集合体系概述
Collection集合体系编辑
迭代器
增强for循环
lambda表达式
List集合
Set集合
哈希值 就是一个int类型的数值，Java中每个对象都有一个哈希值。
TreeSet
集合的并发修改异常
集合体系概述
集合是一种容器，用来装数据的，类似于数组，但集合的大小可变，开发中也非常常用。
集合中存储的是元素对象的地址
集合体系结构：Collection Map
Collection :单列集合 每个元素（数据）只包含一个值。
它是单列集合的祖宗，它规定的方法（功能）是全部单列集合都会继承的。
Collection集合体系
Collection集合特点
- List集合特点：添加元素是有序、可重复、有索引。
- ArrayList、LinkedList:有序、可重复、有索引 。
- Set系列集合：添加的元素是无序、不重复、无索引的。
- HashSet:无序、不重复、无索引。
- LinkedHashSet：有序、不重复、无索引。
- TreeSet：按照大小默认升序排序、不重复、无索引。
Collection的常用方法
Collection的遍历方式
迭代器
是用来遍历集合的专用方式（数组没有迭代器），在Java中迭代器的代表是Iterator。
| 方法名称 | 说明 |
| Interator |
返回集合中的迭代器对象，该迭代器对象默认指向当前集合的第一个元素。 |
| 方法名称 | 说明 |
| boolean hasNext() | 询问当前位置是否有元素存在，存在返回true，不存在返回false |
| E next() | 获取当前位置的元素，并同时将迭代器对象指向下一个元素处 |
通过迭代器获取集合的元素，如果取元素越界会出现NoSuchElementException异常。
增强for循环
格式：
for（元素的数据类型 变量名：数组或者集合）{
//在此处使用变量即可，该变量就是元素
}
- 增强for可以用来遍历集合或者数组。
- 增强for遍历集合，本质就是迭代器遍历集合的简化写法。
增强for循环中的变量值不会影响到集合中的元素。
lambda表达式
得益于JDK8开始的新技术Lambda表达式，提供了一种更简单、更直接的方式来遍历集合。
需要使用Collection的如下方法来完成
| 方法名称 | 说明 |
| default void forEach(Consumer action) | 结合lambda遍历集合 |
List集合
import java.util.ArrayList;
import java.util.List;
/**
目标：掌握List系列集合的特点，以及其提供的特有方法。
*/
public class ListTest1 {
public static void main(String[] args) {
// 1.创建一个ArrayList集合对象（有序、可重复、有索引）
List list = new ArrayList<>(); // 一行经典代码
list.add("蜘蛛精");
list.add("至尊宝");
list.add("至尊宝");
list.add("牛夫人");
System.out.println(list); // [蜘蛛精, 至尊宝, 至尊宝, 牛夫人]
// 2.public void add(int index, E element): 在某个索引位置插入元素。
list.add(2, "紫霞仙子");
System.out.println(list);
// 3.public E remove(int index): 根据索引删除元素,返回被删除元素
System.out.println(list.remove(2));
System.out.println(list);
// 4.public E get(int index): 返回集合中指定位置的元素。
System.out.println(list.get(3));
// 5.public E set(int index, E element): 修改索引位置处的元素,修改成功后，会返回原来的数据
System.out.println(list.set(3, "牛魔王"));
System.out.println(list);
}
}
特点：有序、可重复、有索引
- ArrayList：有序，可重复，有索引。
- LinkedList：有序，可重复，有索引。
特有方法
List集合因为支持索引，所以多了很多与索引相关的方法，当然，Collection的功能List也都继承了。
List集合支持的遍历方式
- for循环（因为List集合有索引）
- 迭代器
- 增强for循环
- Lambda表达式
ArrayList集合的底层原理
- 基于数组实现的
- 查询速度快（是根据索引查询数据快）：查询数据通过地址值和索引定位，查询任意数据耗时相同
- 删除效率低：可能需要把后面很多的数据进行前移
- 添加效率低：可能需要把后面很多的数据后移，再添加元素；或者也可能需要进行数组的扩容。
- 利用无参构造器创建的集合，会在底层创建一个默认长度为0的数组
- 添加第一个元素时，底层会创建一个新的长度为10的数组
- 存满时，会扩容1.5倍
- 如果一次添加多个元素，1.5倍还放不下，则新创建数组的长度以实际为准
ArrayList集合适合的应用场景
- ArrayList适合根据索引查询数据，比如根据随即索引取数据（高效）！或者数据量不是很大时！
- ArrayList不适合数据量大的同时又要频繁的进行增删操作。
LinkedList集合的底层原理
- 基于双链表实现的
- 特点：查询慢，增删相对较快，但对于首尾元素进行增删改查的速度是极快的。
链表：链表中的结点是独立的对象，在内存中是不连续的，每个结点包含数据值和下一个结点的地址。
特点：
- 查询慢，无论查询哪个数据都要从头开始找
- 链表增删相对快
Set集合
HashSet集合的底层原理
哈希值
就是一个int类型的数值，Java中每个对象都有一个哈希值。
Java中的所有对象都可以调用Object类提供的hashCode方法，返回该对象自己的哈希值。
public int hashCode():返回对象的哈希码值
对象哈希值特点
- 同一个对象多次调用hashCode（）方法返回的哈希值是相同的。
- 不同的对象，他们的哈希值一般不相同，但也有可能会相同（哈希碰撞）
HashSet集合的底层原理
- 基于哈希表实现。
- 哈希表是一种增删改查数据，性能都较好的数据结构。
哈希表
- JDK8之前，哈希表=数组+链表
- JDK8开始，哈希表+数组+链表+红黑树
数组快占满了会导致链表过长，查询性能降低，需要扩容。
数组+链表
哈希表详细流程
- 创建一个默认长度16的数组，默认加载因子为0.75，数组名table
- 使用元素的哈希值对数组的长度求余计算出应存入的位置
- 判断当前位置是否为null，如果是null直接存入
- 如果不为null，表示有元素，则调用equals方法比较，相等则不存；不相等，则存入数组
- 当数组存满到16*0.75=12时，就自动扩容，每次扩容原先的两倍。
- JDK8之前，新元素存入数组，占老元素位置，老元素挂下面
- JDK8开始之后，新元素直接挂在老元素下面
JDK8开始，当链表长度超过8，且数组长度>=6时，自动将链表转成红黑树
HashSet集合去重复机制
HashSet集合默认不能对内容一样的两个不同对象去重复
如果希望Set集合认为两个内容一样的对象是重复的，必须重写对象的HashCode（）和equals（）方法
LinkedHashSet集合的底层原理
基于哈希表（数组、链表、红黑树）实现的。但是它的每一个元素都额外的多了一个双链表的机制记录它前后元素的位置。
TreeSet
底层是基于红黑树实现的排序。
特点：不重复、无索引、可排序（默认升序排序，按照元素的大小，由小到大排序）
注意：
- 对于数值类型：Integer，Double，默认按照数值本身的大小进行升序排序。
- 对于字符串类型：默认按照首字符的编号升序排序。
- 对于自定义类型如Student对象，TreeSet默认是无法直接排序的。
自定义排序规则
TreeSet集合存储自定义类型的对象时，必须指定排序规则，支持如下两种方式来指定比较规则。
- 让自定义的类（如学生类）实现Compare接口，重写里面的compareTo方法来指定比较规则。
- 通过调用TreeSet集合有参数构造器，可以设置Compare对象（比较器对象，用于指定比较规则）
public TreeSet(Comparatorcomparator）
两种方式中，关于返回值的规则：
- 如果认为第一个元素>第二个元素，返回正整数即可。
- 如果认为第一个元素<第二个元素返回负整数即可。
- 如果认为第一个元素=第二个元素返回即可，此时TreeSet集合只会保留一个元素，认为两者重复 。
如果类本身有实现Comparable接口，TreeSet集合同时也自带比较器，默认使用集合自带的比较器排序。
集合的并发修改异常
- 使用迭代器遍历集合时，又同时在删除集合中的数据，程序就会出现并发修改异常的错误。
- 由于增强for循环遍历集合就是迭代器遍历集合的简化写法，因此，使用增强for循环遍历集合，又在同时删除集合中的数据时，程序也会出现并发修改异常的错误。
package com.itheima.d3_collection_list.d5_collection_exception;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class CollectionTest1 {
public static void main(String[] args) {
List list = new ArrayList<>();
list.add("王麻子");
list.add("李麻子");
list.add("小李子");
list.add("牛爱华");
list.add("李狗蛋");
list.add("贤明");
list.add("黑虎");
System.out.println(list);
Iterator it= list.iterator();
while(it.hasNext()){
String name = it.next();
if(name.contains("李")){
it.remove();
}
}
System.out.println(list);
}
} 怎么保证遍历集合同时删除数据时不出bug
- 使用迭代器遍历集合，但用迭代器自己删除方法删除数据即可。
- 如果能用for循环遍历时，可以倒着遍历并删除 ；或者从前往后遍历，但删除元素后做 i-- 操作
Collection的其他相关知识
前置知识：可变参数
- 就是一种特殊形参，定义在方法、构造器的形参列表里，格式是：数据类型...参数名称；
package com.itheima.d1_parameter;
import java.util.Arrays;
public class ParamTest {
public static void main(String[] args) {
test();
test(10);
test(10,20,30);
test(new int[]{10,20,30,40});
}
public static void test(int...nums){
System.out.println(nums.length);
System.out.println(Arrays.toString(nums));
System.out.println("-----------------------------");
}
}
可变参数的特点和好处
- 特点：可以不传数据给它；可以传一个或者同时传多个数据给他；也可以传一个数组给它。
- 好处：常常用来灵活地接收数据。
可变参数的注意事项：
- 可变参数在方法内部就是一个数组。
- 一个参数列表中可变参数只能有一个
- 可变参数必须放在形参列表的最后面
Collections
- 是一个用来操作集合的工具类。
Collections提供的常用静态方法
| 方法名称 | 说明 |
| public static |
给集合批量添加元素 |
| public static void shuffle(List list) | 打乱List集合中的元素顺序 |
| public static |
对List集合中的元素进行升序排序 |
| public static |
对List集合中元素，按照比较器对象指定的规则进行排序 |
package com.itheima.d2_collections;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
/**
* 目标：掌握Collections集合工具类的使用。
*/
public class CollectionsTest1 {
public static void main(String[] args) {
// 1、public static boolean addAll(Collection c, T...elements)：为集合批量添加数据
List names = new ArrayList<>();
Collections.addAll(names, "张三", "王五", "李四", "张麻子");
System.out.println(names);
// 2、public static void shuffle(List list)：打乱List集合中的元素顺序。
Collections.shuffle(names);
System.out.println(names);
// 3、 public static void sort(List list)：对List集合中的元素进行升序排序。
List list = new ArrayList<>();
list.add(3);
list.add(5);
list.add(2);
Collections.sort(list);
System.out.println(list);
List students = new ArrayList<>();
students.add(new Student("蜘蛛精",23, 169.7));
students.add(new Student("紫霞",22, 169.8));
students.add(new Student("紫霞",22, 169.8));
students.add(new Student("至尊宝",26, 165.5));
// Collections.sort(students);
// System.out.println(students);
// 4、public static void sort(List list， Comparator c): 对List集合中元素，按照比较器对象指定的规则进行排序
Collections.sort(students, new Comparator() {
@Override
public int compare(Student o1, Student o2) {
return Double.compare(o1.getHeight(), o2.getHeight());
}
});
System.out.println(students);
}
}
package com.itheima.d3_collection_list.d4_collection_set;
import java.util.Objects;
public class Student implements Comparable{
private String name;
private int age;
private double height;
// this o
@Override
public int compareTo(Student o) {
// 如果认为左边对象大于右边对象返回正整数
// 如果认为左边对象小于右边对象返回负整数
// 如果认为左边对象等于右边对象返回0
// 需求：按照年龄升序排序、
return this.age - o.age;
}
public Student() {
}
public Student(String name, int age, double height) {
this.name = name;
this.age = age;
this.height = height;
}
// 只要两个对象内容一样就返回true
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age && Double.compare(student.height, height) == 0 && Objects.equals(name, student.name);
}
// 只要两个对象内容一样，返回的哈希值就是一样的。
@Override
public int hashCode() {
// 姓名 年龄 身高计算哈希值的
return Objects.hash(name, age, height);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public double getHeight() {
return height;
}
public void setHeight(double height) {
this.height = height;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", height=" + height +
'}';
}
}
Collection只能支持对List集合进行排序
排序方式一
| 方法名称 | 说明 |
| public static |
对List集合重元素按照默认规则排序 |
排序方式二
| 方法名称 | 说明 |
| public static |
对List集合中元素，按照比较器对象指定的规则进行排序 |
Map
Map是双列集合的祖宗，它的功能是全部双列集合都可以继承过来使用的。
- Map集合称为双列集合，格式：{key1=value1,key2=value2,key3=value3,...},一次需要存一对数据作为一个元素。
- Map集合的每个元素“key=value”称为一个键值对/键值对对像/ 一个Entry对象，Map集合也被叫做“键值对集合”。
- Map集合的所有键是不允许重复的，但值可以重复，键和值是一一对应的，每一个键只能找到自己对应的值。
需要存储一一对应的数据时就可以考虑使用Map集合来做
Map集合体系的特点
注意：Map系列集合的特点都是由键决定的，值只是一个附属品，值是不做要求的
- HashMap（由键决定特点）：无序、不重复、无索引；（用的最多）
- LinkedHashMap（由键决定特点）：有序、不重复、无索引。
- TreeMap（由键决定特点）：按照大小默认升序排序、不重复、无索引。
Map的常用方法
/**
* 目标：掌握Map集合的常用方法
*/
import java.util.*;
/**
* 目标：掌握Map集合的常用方法(重点)
*/
public class MapTest2 {
public static void main(String[] args) {
// 1.添加元素: 无序，不重复，无索引。
Map map = new HashMap<>();
map.put("手表", 100);
map.put("手表", 220);
map.put("手机", 2);
map.put("Java", 2);
map.put(null, null);
System.out.println(map);
// map = {null=null, 手表=220, Java=2, 手机=2}
// 2.public int size():获取集合的大小
System.out.println(map.size());
// 3、public void clear():清空集合
//map.clear();
//System.out.println(map);
// 4.public boolean isEmpty(): 判断集合是否为空，为空返回true ,反之！
System.out.println(map.isEmpty());
// 5.public V get(Object key)：根据键获取对应值
int v1 = map.get("手表");
System.out.println(v1);
System.out.println(map.get("手机")); // 2
System.out.println(map.get("张三")); // null
// 6. public V remove(Object key)：根据键删除整个元素(删除键会返回键的值)
System.out.println(map.remove("手表"));
System.out.println(map);
// 7.public boolean containsKey(Object key): 判断是否包含某个键 ，包含返回true ,反之
System.out.println(map.containsKey("手表")); // false
System.out.println(map.containsKey("手机")); // true
System.out.println(map.containsKey("java")); // false
System.out.println(map.containsKey("Java")); // true
// 8.public boolean containsValue(Object value): 判断是否包含某个值。
System.out.println(map.containsValue(2)); // true
System.out.println(map.containsValue("2")); // false
// 9.public Set keySet(): 获取Map集合的全部键。
Set keys = map.keySet();
System.out.println(keys);
// 10.public Collection values(); 获取Map集合的全部值。
Collection values = map.values();
System.out.println(values);
// 11.把其他Map集合的数据倒入到自己集合中来。(拓展)
Map map1 = new HashMap<>();
map1.put("java1", 10);
map1.put("java2", 20);
Map map2 = new HashMap<>();
map2.put("java3", 10);
map2.put("java2", 222);
map1.putAll(map2); // putAll：把map2集合中的元素全部倒入一份到map1集合中去。
System.out.println(map1);
System.out.println(map2);
}
}
Map集合的遍历方式
- 键找值：先获取Map集合全部的键，再通过遍历键来找值
- 键对值：把“键对值”看成一个整体进行遍历（难）
- Lambda：JDK1.8开始之后的新技术（简单）
键找值需要用到Map的如下方法
| 方法名称 | 说明 |
| public Set |
获取所有键的集合 |
| public V get(Object key) | 根据键获取其对应的值 |
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MapTest1 {
public static void main(String[] args) {
Map map=new HashMap<>();
map.put("蜘蛛精",162.5);
map.put("蜘蛛精",167.9);
map.put("紫霞",169.8);
map.put("至尊宝",165.4);
map.put("牛魔王",163.9);
System.out.println(map);
Setkeys=map.keySet();
for(String key:keys){
double value=map.get(key);
System.out.println(key+"====>"+value);
}
}
}
键值对用到的方法
| Map.Entry提供 | 说明 |
| K.getKey（） | 获取键 |
| V.getValue() | 获取值 |
| Map提供 | 说明 |
| Set | 获取所有键值对的集合 |
Set>entries =map.entrySet();
for(Map.Entryentry:entries){
String key=entry.getKey();
double value=entry.getValue();
System.out.println(key+"---->"+value);
} 键找值需要用到Map的如下方法
| 方法名称 | 说明 |
| default void forEach(BiConsumer action) | 结合lambda遍历Map集合 |
//map.forEach(new BiConsumer() {
// @Override
// public void accept(String k, Double v) {
// System.out.println(k+"--->"+v);
// }
// });
map.forEach((k,v)->{
System.out.println(k+"--->"+v);
});
}
}
HashMap集合的底层原理
- HashMap跟HashSet的底层原理是一模一样的，都是基于哈希表实现的
实际上：原来学的Set系列集合的底层就是基于Map实现的，只是Set集合中的元素只要键数据，不要值数据而已。
public HashSet(){
map=new HashMap<>();
}
- HashMap集合是一种增删改查数据，性能都较好的集合，但是它是无序，不重复，没有索引支持的（由键决定特点）
- HashMap的键依赖hashCode方法和equals方法保证键的唯一
- 如果键存储的是自定义类型的对象，可以通过重写hashCode和equals方法，这样可以保证多个对象内容一样时，HashMap集合就能认为是重复的。
TreeMap
- 特点： 不重复、无索引、可排序（按照键的大小默认升序排序，只能对键排序）
- 原理：TreeMap跟TreeSet集合的底层原理是一样的，都是基于红黑树实现的排序。
TreeMap集合同样也支持两种方式来指定排序规则
- 让类实现Comparable接口，重写比较规则。
- TreeMap集合有一个有参数构造器，支持创建Comparation比较器对象，以便用来指定比较规则。 （集合自定义Comparator比较器对象，重写比较规则）
集合的嵌套
指的是集合中的元素又是一个集合
JDK8新特性：Stream
- 也叫Stream流。是Jdk8开始新增的一套API(java.util.stream.*),可以用于操作集合或者数组的数据。
- 优势：Stream流大量地结合了Lambda的语法风格来编程，提供了一种更加强大，更加简单的方式操作集合或者数组中的数据，代码更简洁，可读性更好。
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
public class StreamTest1 {
public static void main(String[] args) {
List names=new ArrayList<>();
Collections.addAll(names,"章春惠","张雨绮","张三丰","周金立","吴豪","尤晓玉");
System.out.println(names);
/*List list =new ArrayList<>();
for (String name : names) {
if(name.startsWith("张")&&name.length()==3){
list.add(name);
}
}
System.out.println(list);*/
List list2=names.stream().filter(s->s.startsWith("张")).filter(a->a.length()==3).collect(Collectors.toList());
System.out.println(list2);
}
}
获取Stream流
- 获取集合的Stream流
| Collection提供的如下方法 | 说明 |
| default Stream |
获取当前集合对象的Stream流 |
// 1、如何获取List集合的Stream流？
List names = new ArrayList<>();
Collections.addAll(names, "张三丰","张无忌","周芷若","赵敏","张强");
Stream stream = names.stream();
// 2、如何获取Set集合的Stream流？
Set set = new HashSet<>();
Collections.addAll(set, "刘德华","张曼玉","蜘蛛精","马德","德玛西亚");
Stream stream1 = set.stream();
stream1.filter(s -> s.contains("德")).forEach(s -> System.out.println(s));
// 3、如何获取Map集合的Stream流？
Map map = new HashMap<>();
map.put("古力娜扎", 172.3);
map.put("迪丽热巴", 168.3);
map.put("马尔扎哈", 166.3);
map.put("卡尔扎巴", 168.3);
Set keys = map.keySet();
Stream ks = keys.stream();
Collection values = map.values();
Stream vs = values.stream();
Set> entries = map.entrySet();
Stream> kvs = entries.stream();
kvs.filter(e -> e.getKey().contains("巴"))
.forEach(e -> System.out.println(e.getKey()+ "-->" + e.getValue()));
- 获取数组的Stream流
| Arrays类提供的如下方法 | 说明 |
| public static |
获取当前数组的Stream流 |
| Stream类提供的如下方法 | 说明 |
| public static |
获取当前接收数据的Stream流 |
String[] names2 = {"张翠山", "东方不败", "唐大山", "独孤求败"};
Stream s1 = Arrays.stream(names2);
Stream s2 = Stream.of(names2); Stream常见的中间方法
- 中间方法指的是调用完成后会返回新的Stream流，可以继续使用（支持链式编程)。
import java.util.*;
import java.util.stream.Stream;
/**
* 目标：掌握Stream流提供的常见中间方法。
*/
public class StreamTest3 {
public static void main(String[] args) {
List scores = new ArrayList<>();
Collections.addAll(scores, 88.5, 100.0, 60.0, 99.0, 9.5, 99.6, 25.0);
// 需求1：找出成绩大于等于60分的数据，并升序后，再输出。
scores.stream().filter(s -> s >= 60).sorted().forEach(s -> System.out.println(s));
List students = new ArrayList<>();
Student s1 = new Student("蜘蛛精", 26, 172.5);
Student s2 = new Student("蜘蛛精", 26, 172.5);
Student s3 = new Student("紫霞", 23, 167.6);
Student s4 = new Student("白晶晶", 25, 169.0);
Student s5 = new Student("牛魔王", 35, 183.3);
Student s6 = new Student("牛夫人", 34, 168.5);
Collections.addAll(students, s1, s2, s3, s4, s5, s6);
// 需求2：找出年龄大于等于23,且年龄小于等于30岁的学生，并按照年龄降序输出.
students.stream().filter(s -> s.getAge() >= 23 && s.getAge() <= 30)
.sorted((o1, o2) -> o2.getAge() - o1.getAge())
.forEach(s -> System.out.println(s));
// 需求3：取出身高最高的前3名学生，并输出。
students.stream().sorted((o1, o2) -> Double.compare(o2.getHeight(), o1.getHeight()))
.limit(3).forEach(System.out::println);
System.out.println("----------------------------------------------------------------");
// 需求4：取出身高倒数的2名学生，并输出。 s1 s2 s3 s4 s5 s6
students.stream().sorted((o1, o2) -> Double.compare(o2.getHeight(), o1.getHeight()))
.skip(students.size() - 2).forEach(System.out::println);
// 需求5：找出身高超过168的学生叫什么名字，要求去除重复的名字，再输出。
students.stream().filter(s -> s.getHeight() > 168).map(Student::getName)
.distinct().forEach(System.out::println);
// distinct去重复，自定义类型的对象（希望内容一样就认为重复，重写hashCode,equals）
students.stream().filter(s -> s.getHeight() > 168)
.distinct().forEach(System.out::println);
Stream st1 = Stream.of("张三", "李四");
Stream st2 = Stream.of("张三2", "李四2", "王五");
Stream allSt = Stream.concat(st1, st2);
allSt.forEach(System.out::println);
}
}
Stream常见的终结方法
- 终结方法指的是调用完成后，不会返回新Stream了，没法继续使用流了。
- 收集Stream流：就是把Stream流操作后的结果转回到集合或者数组中去返回。
- Stream流 ：方便操作集合/数组的手段；集合/数组：才是开发中的目的
import java.util.*;
import java.util.stream.Collectors;
/**
* 目标：Stream流的终结方法
*/
public class StreamTest4 {
public static void main(String[] args) {
List students = new ArrayList<>();
Student s1 = new Student("蜘蛛精", 26, 172.5);
Student s2 = new Student("蜘蛛精", 26, 172.5);
Student s3 = new Student("紫霞", 23, 167.6);
Student s4 = new Student("白晶晶", 25, 169.0);
Student s5 = new Student("牛魔王", 35, 183.3);
Student s6 = new Student("牛夫人", 34, 168.5);
Collections.addAll(students, s1, s2, s3, s4, s5, s6);
// 需求1：请计算出身高超过168的学生有几人。
long size = students.stream().filter(s -> s.getHeight() > 168).count();
System.out.println(size);
// 需求2：请找出身高最高的学生对象，并输出。
Student s = students.stream().max((o1, o2) -> Double.compare(o1.getHeight(), o2.getHeight())).get();
System.out.println(s);
// 需求3：请找出身高最矮的学生对象，并输出。
Student ss = students.stream().min((o1, o2) -> Double.compare(o1.getHeight(), o2.getHeight())).get();
System.out.println(ss);
// 需求4：请找出身高超过170的学生对象，并放到一个新集合中去返回。
// 流只能收集一次。
List students1 = students.stream().filter(a -> a.getHeight() > 170).collect(Collectors.toList());
System.out.println(students1);
Set students2 = students.stream().filter(a -> a.getHeight() > 170).collect(Collectors.toSet());
System.out.println(students2);
// 需求5：请找出身高超过170的学生对象，并把学生对象的名字和身高，存入到一个Map集合返回。
Map map =
students.stream().filter(a -> a.getHeight() > 170)
.distinct().collect(Collectors.toMap(a -> a.getName(), a -> a.getHeight()));
System.out.println(map);
// Object[] arr = students.stream().filter(a -> a.getHeight() > 170).toArray();
Student[] arr = students.stream().filter(a -> a.getHeight() > 170).toArray(len -> new Student[len]);
System.out.println(Arrays.toString(arr));
}
}