【Java从入门到大牛】集合进阶下篇
本文由 程序喵正在路上 原创，CSDN首发！
系列专栏：Java从入门到大牛
首发时间：2023年8月2日
欢迎关注点赞收藏留言
一以贯之的努力 不得懈怠的人生
目录
- Collection的其他相关知识
-
- 可变参数
- Collections
- 综合案例
- Map集合
-
- 概述
- 常用方法
- 遍历方式
- HashMap
- LinkedHashMap
- TreeMap
- 集合的嵌套
- JDK8新特性：Stream流
-
- 认识Stream
- Stream的常用方法
Collection的其他相关知识
可变参数
什么是可变参数
就是一种特殊形参，定义在方法、构造器的形参列表里，格式为数据类型...参数名称;
可变参数的特点和好处
- 特点：可以不传数据给它；可以传一个或者同时传多个数据给它；也可以传一个数组给它
- 好处：常常用来灵活地接收数据
可变参数的注意事项
- 可变参数在方法内部就是一个数组
- 一个形参列表可变参数只能有一个
- 可变参数必须放在形参列表的最后面
具体应用
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}); // 传输一个数组给可变参数
}
// 注意事项1：一个形参列表中，只能有一个可变参数。
// 注意事项2：可变参数必须放在形参列表的最后面
public static void test(int...nums){
// 可变参数在方法内部，本质就是一个数组。
System.out.println(nums.length);
System.out.println(Arrays.toString(nums));
System.out.println("-----------------------------------------");
}
}
Collections
什么是 Collections ？
是一个用来操作集合的工具类
Collections提供的常用静态方法
Collections只能支持对List集合进行排序
-
排序方式1：
public static <T> void sort(List<T> list) // 对List集合中元素按照默认规则排序注意：本方法可以直接对自定义类型的 List 集合排序，但自定义类型必须实现了 Comparable 接口，指定了比较规则才可以
-
排序方式2：
public static <T> void sort(List<T> list, Comparator<? super T> c) // 对List集合中元素，按照比较器对象指定的规则进行排序
具体应用
学生类
public class Student implements Comparable<Student>{
private String name;
private int age;
private double height;
@Override
public int compareTo(Student o) {
// 按照年龄升序排序
return this.age - o.age;
}
public Student() {
}
public Student(String name, int age, double height) {
this.name = name;
this.age = age;
this.height = 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 +
'}';
}
}
测试类
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<String> 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<Integer> list = new ArrayList<>();
list.add(3);
list.add(5);
list.add(2);
Collections.sort(list);
System.out.println(list);
List<Student> 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<Student>() {
@Override
public int compare(Student o1, Student o2) {
return Double.compare(o1.getHeight(), o2.getHeight());
}
});
System.out.println(students);
}
}
综合案例
案例：斗地主游戏
分析业务需求
- 总共有 54 张牌
- 点数: “3”,“4”,“5”,“6”,“7”,“8”,“9”,“10”,“J”,“Q”,“K”,“A”,“2”
- 花色: “♠”, “♥”, “♣”, "♦“
- 大小王: “” , "“
- 斗地主：发出 51 张牌，剩下 3 张做为底牌
分析实现
- 在启动游戏房间的时候，应该提前准备好 54 张牌
- 接着，需要完成洗牌、发牌、对牌排序、看牌
代码示例
Card.java
// 牌类
public class Card {
private String number; // 点数
private String color; // 花色
private int size; // 每张牌的大小
public Card() {
}
public Card(String number, String color, int size) {
this.number = number;
this.color = color;
this.size = size;
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public int getSize() {
return size;
}
public void setSize(int size) {
this.size = size;
}
@Override
public String toString() {
return color + number ;
}
}
Room.java
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
// 房间类
public class Room {
// 首先要有一副牌
private List<Card> allCards = new ArrayList<>();
public Room(){
// 1、做出54张牌，存入到集合allCards
// a、点数：个数确定了，类型确定，点数从小到大排列
String[] numbers = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
// b、花色：个数确定了，类型确定
String[] colors = {"♠", "♥", "♣", "♦"};
int size = 0; // 表示每张牌的大小
// c、遍历点数，再遍历花色，组织牌
for (String number : numbers) {
// number = "3"
size++; // 1 2 ....
for (String color : colors) {
// 得到一张牌
Card c = new Card(number, color, size);
allCards.add(c); // 存入牌
}
}
// 单独存入大小王的
Card c1 = new Card("", "", ++size);
Card c2 = new Card("", "", ++size);
Collections.addAll(allCards, c1, c2);
System.out.println("新牌：" + allCards);
}
/**
* 启动游戏
*/
public void start() {
// 1、洗牌
Collections.shuffle(allCards);
System.out.println("洗牌后：" + allCards);
// 2、发牌，首先肯定要定义三个玩家。 List(ArrayList) Set(TreeSet)
List<Card> linHuChong = new ArrayList<>();
List<Card> jiuMoZhi = new ArrayList<>();
List<Card> renYingYing = new ArrayList<>();
// 正式发牌给这三个玩家，依次发出51张牌，剩余3张做为底牌
// allCards = [♥3, ♣10, ♣4, ♥K, ♦Q, ♣2, , ♣8, ....
for (int i = 0; i < allCards.size() - 3; i++) {
Card c = allCards.get(i);
// 判断牌发给谁
if(i % 3 == 0){
linHuChong.add(c);
}else if(i % 3 == 1){
jiuMoZhi.add(c);
}else {
renYingYing.add(c);
}
}
// 3、对3个玩家的牌进行排序
sortCards(linHuChong);
sortCards(jiuMoZhi);
sortCards(renYingYing);
// 4、看牌
System.out.println("啊冲：" + linHuChong);
System.out.println("啊鸠：" + jiuMoZhi);
System.out.println("盈盈：" + renYingYing);
List<Card> lastThreeCards = allCards.subList(allCards.size() - 3, allCards.size());
System.out.println("底牌：" + lastThreeCards);
jiuMoZhi.addAll(lastThreeCards);
sortCards(jiuMoZhi);
System.out.println("啊鸠抢到地主后：" + jiuMoZhi);
}
/**
* 集中进行排序
* @param cards
*/
private void sortCards(List<Card> cards) {
Collections.sort(cards, (o1, o2) -> {
return o2.getSize() - o1.getSize(); // 降序排序
});
}
}
GameDemo.java
public class GameDemo {
public static void main(String[] args) {
// 1、牌类
// 2、房间
Room m = new Room();
// 3、启动游戏
m.start();
}
}
执行结果
Map集合
概述
认识Map集合
- Map 集合称为双列集合，格式为
{key1=value1, key2=value2, key3=value3, ...}，一次需要存一对数据作为一个元素 - Map 集合的每个元素 “key=value” 称为一个键值对 / 键值对对象 / 一个 Entry 对象，Map 集合也被叫做 ”键值对集合“
- Map 集合的所有键是不允许重复的，但值可以重复，键和值是一一对应的，每一个键只能找到自己对应的值
Map集合的应用场景
当我们需要存储一一对应的数据时，就可以考虑使用 Map 集合来做
Map集合体系
Map集合体系的特点
注意：Map 系列集合的特点都是由键决定的，值只是一个附属品，值是不做要求的
- HashMap（由键决定特点）：无序、不重复、无索引（用得最多）
- LinkedHashMap（由键决定特点）：有序、不重复、无索引
- TreeMap（由键决定特点）：按照大小默认升序排序、不重复、无索引
具体应用
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.TreeMap;
/**
* 目标：掌握Map集合的特点
*/
public class MapTest1 {
public static void main(String[] args) {
// Map map = new HashMap<>(); // 一行经典代码。 按照键 无序，不重复，无索引
Map<String, Integer> map = new LinkedHashMap<>(); // 有序，不重复，无索引
map.put("手表", 100);
map.put("手表", 220); // 后面重复的数据会覆盖前面的数据（键）
map.put("手机", 2);
map.put("Java", 2);
map.put(null, null);
System.out.println(map);
Map<Integer, String> map1 = new TreeMap<>(); // 可排序，不重复，无索引
map1.put(23, "Java");
map1.put(23, "MySQL");
map1.put(19, "李四");
map1.put(20, "王五");
System.out.println(map1);
}
}
常用方法
Map的常用方法如下：
具体应用
import java.util.*;
/**
* 目标：掌握Map集合的常用方法
*/
public class MapTest2 {
public static void main(String[] args) {
// 1.添加元素: 无序，不重复，无索引
Map<String, Integer> map = new HashMap<>();
map.put("手表", 100);
map.put("手表", 220);
map.put("手机", 2);
map.put("Java", 2);
map.put(null, null);
System.out.println(map);
// 2.public int size():获取集合的大小
System.out.println("map.size: " + map.size());
// 3、public void clear():清空集合
//map.clear();
//System.out.println(map);
// 4.public boolean isEmpty(): 判断集合是否为空，为空返回true ,反之！
System.out.println("map.isEmpty: " + map.isEmpty());
// 5.public V get(Object key)：根据键获取对应值
int v1 = map.get("手表");
System.out.println("v1: " + v1);
System.out.println(map.get("手机")); // 2
System.out.println(map.get("张三")); // null
// 6. public V remove(Object key)：根据键删除整个元素(删除键会返回键的值)
System.out.println("map.remove(\"手表\"): " + 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<String> keys = map.keySet();
System.out.println("keys: " + keys);
// 10.public Collection values(); 获取Map集合的全部值
Collection<Integer> values = map.values();
System.out.println("values: " + values);
// 11.把其他Map集合的数据倒入到自己集合中来(拓展)
Map<String, Integer> map1 = new HashMap<>();
map1.put("java1", 10);
map1.put("java2", 20);
Map<String, Integer> map2 = new HashMap<>();
map2.put("java3", 10);
map2.put("java2", 222);
map1.putAll(map2); // putAll：把map2集合中的元素全部倒入一份到map1集合中去
System.out.println("map1: " + map1);
System.out.println("map2: " + map2);
}
}
遍历方式
Map集合的遍历方式
- 键找值：先获取 Map 集合全部的键，再通过遍历键来找值
- 键值对：把 “键值对” 看成一个整体进行遍历（难度较大）
- Lambda：JDK1.8 开始之后的新技术（非常简单）
方式一：键找值
需要用到 Map 的如下方法：
具体应用：
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* 目标：掌握Map集合的遍历方式1：键找值
*/
public class MapTest1 {
public static void main(String[] args) {
// 准备一个Map集合
Map<String, Double> map = new HashMap<>();
map.put("蜘蛛精", 162.5);
map.put("蜘蛛精", 169.8);
map.put("紫霞", 165.8);
map.put("至尊宝", 169.5);
map.put("牛魔王", 183.6);
System.out.println("map: " + map);
// 1、获取Map集合的全部键
Set<String> keys = map.keySet();
System.out.println("keys: " + keys);
// 2、遍历全部的键，根据键获取其对应的值
for (String key : keys) {
// 根据键获取对应的值
double value = map.get(key);
System.out.println(key + "=====>" + value);
}
}
}
方式二：键值对
需要用到 Map 和 Map.Entry 的如下方法：
具体应用：
import java.util.*;
/**
* 目标：掌握Map集合的第二种遍历方式：键值对
*/
public class MapTest2 {
public static void main(String[] args) {
Map<String, Double> map = new HashMap<>();
map.put("蜘蛛精", 169.8);
map.put("紫霞", 165.8);
map.put("至尊宝", 169.5);
map.put("牛魔王", 183.6);
System.out.println(map);
// 1、调用Map集合提供entrySet方法，把Map集合转换成键值对类型的Set集合
Set<Map.Entry<String, Double>> entries = map.entrySet();
for (Map.Entry<String, Double> entry : entries) {
String key = entry.getKey();
double value = entry.getValue();
System.out.println(key + "=====>" + value);
}
}
}
方式三：Lambda
需要用到 Map 的如下方法：
具体应用：
import java.util.HashMap;
import java.util.Map;
/**
* 目标：掌握Map集合的第三种遍历方式：Lambda
*/
public class MapTest3 {
public static void main(String[] args) {
Map<String, Double> map = new HashMap<>();
map.put("蜘蛛精", 169.8);
map.put("紫霞", 165.8);
map.put("至尊宝", 169.5);
map.put("牛魔王", 183.6);
System.out.println(map);
map.forEach(( k, v) -> {
System.out.println(k + "=====>" + v);
});
}
}
案例：统计投票人数
需求
某个班级有 80 名学生，现在需要组织秋游活动，班长提供了四个景点依次是 A、B、C、D，每个学生只能选择一个景点，请统计出最终哪个景点想去的人数最多
分析
- 将 80 个学生选择的数据拿到程序中去
- 准备一个 Map 集合用于存储统计的结果，Map
- 遍历 80 个学生选择的景点，每遍历一个景点，就看 Map 集合中是否存在该景点，不存在则存入 “景点=1”，存在则其对应值+1
代码示例
import java.util.*;
/**
* 目标：案例：统计投票人数
*/
public class MapDemo4 {
public static void main(String[] args) {
// 1、把80个学生选择的景点数据拿到程序中来
List<String> data = new ArrayList<>();
String[] selects = {"A", "B", "C", "D"};
Random r = new Random();
for (int i = 1; i <= 80; i++) {
// 每次模拟一个学生选择一个景点，存入到集合中去
int index = r.nextInt(4); // 0 1 2 3
data.add(selects[index]);
}
System.out.println(data);
// 2、开始统计每个景点的投票人数
// 准备一个Map集合用于统计最终的结果
Map<String, Integer> result = new HashMap<>();
// 3、开始遍历80个景点数据
for (String s : data) {
// 问问Map集合中是否存在该景点
if(result.containsKey(s)){
// 说明这个景点之前统计过。其值+1. 存入到Map集合中去
result.put(s, result.get(s) + 1);
}else {
// 说明这个景点是第一次统计，存入"景点=1"
result.put(s, 1);
}
}
System.out.println(result);
}
}
HashMap
HashMap集合的底层原理
HashMap 跟 HashSet 的底层原理是一模一样的，都是基于哈希表实现的
实际上，原来学的 Set 系列集合的底层就是基于 Map 实现的，只是 Set 集合中的元素只要键数据，不要值数据而已
HashMap 的底层是利用键来计算哈希值的，和值无关
HashMap集合总结
- HashMap 集合是一种增删改查数据性能都比较好的集合
- 但是它是无序的、不重复的、无索引支持的（由键决定特点）
- HashMap 的键依赖 hashCode 方法和 equals 方法保证键的唯一
- 如果键存储的是自定义类型的对象，可以通过重写 hashCode 和 equals 方法，这样可以保证多个对象内容一样时，HashMap 集合就能认为是重复的
案例：HashMap集合存储自定义对象并遍历
需求
创建一个 HashMap 集合，键是学生对象 Student，值是籍贯，存储几个键值对元素并遍历
分析
- 定义一个学生类
- 创建 HashMap 集合对象
- 创建学生对象
- 把学生添加到集合
- 遍历集合
代码示例
Student.java
import java.util.Objects;
public class Student implements Comparable<Student> {
private String name;
private int age;
private double height;
@Override
public int compareTo(Student o) {
return this.age - o.age; // 年龄升序排序
}
@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 Student() {
}
public Student(String name, int age, double height) {
this.name = name;
this.age = age;
this.height = 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 +
'}';
}
}
TestHashMap.java
import java.util.HashMap;
import java.util.Map;
public class TestHashMap {
public static void main(String[] args) {
Map<Student, String> map = new HashMap<>();
map.put(new Student("蜘蛛精", 25, 168.5), "盘丝洞");
map.put(new Student("蜘蛛精", 25, 168.5), "水帘洞");
map.put(new Student("至尊宝", 23, 163.5), "水帘洞");
map.put(new Student("牛魔王", 28, 183.5), "牛头山");
map.forEach((k, v) -> System.out.println(k + ", " +v));
}
}
LinkedHashMap
LinkedHashMap集合的底层原理
底层数据结构依然是基于哈希表实现的，只是每个键值对元素又额外地多了一个双链表的机制记录元素顺序，目的是保证元素的有序
实际上，我们原来学习的 LinkedHashSet 集合的底层原理就是 LinkedHashMap
具体应用
import java.util.LinkedHashMap;
/**
* 目标：掌握LinkedHashMap的底层原理
*/
public class TestLinkedHashMap {
public static void main(String[] args) {
LinkedHashMap<String, Integer> map = new LinkedHashMap<>(); // 有序，不重复，无索引
map.put("手表", 100);
map.put("手表", 220);
map.put("手机", 2);
map.put("Java", 2);
map.put(null, null);
System.out.println(map);
}
}
TreeMap
TreeMap
- 特点：不重复、无索引、可排序（按照键的大小默认升序排序，只能对键排序）
- 原理：TreeMap 跟 TreeSet 集合的底层原理是一样的，都是基于红黑树实现的排序
TreeMap集合同样也支持两种方式来指定排序规则
- 让类实现 Comparable 接口，重写比较规则
- TreeMap 集合有一个参数构造器，支持创建 Comparator 比较器对象，以便用来指定比较规则
具体应用
import java.util.Comparator;
import java.util.Map;
import java.util.TreeMap;
/**
* 目标：掌握TreeMap集合的使用
*/
public class TestTreeMap {
public static void main(String[] args) {
Map<Student, String> map = new TreeMap<>(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return Double.compare(o2.getHeight(), o1.getHeight()); // 降序排序
}
});
// lambda表达式写法
// Map map = new TreeMap<>(( o1, o2) -> Double.compare(o2.getHeight(), o1.getHeight()));
map.put(new Student("蜘蛛精", 25, 168.5), "盘丝洞");
map.put(new Student("蜘蛛精", 25, 168.5), "水帘洞");
map.put(new Student("至尊宝", 23, 163.5), "水帘洞");
map.put(new Student("牛魔王", 28, 183.5), "牛头山");
map.forEach((k, v) -> System.out.println(k + ", " + v));
}
}
集合的嵌套
什么是集合嵌套 ？
指的是集合中的元素又是一个集合
Map集合实现类特点
- HashMap：元素按照键是无序、不重复、无索引、值不做要求、基于哈希表
- LinkedHashMap：元素按照键是有序、不重复、无索引、值不做要求、基于哈希表
- TreeMap：元素只能按照键排序、不重复、无索引、值不做要求、可以做排序
Map集合案例-省和市
需求
要求在程序中记住如下省份和其对应的城市信息，记录成功后，要求可以查询出湖北省的城市信息
- 江苏省 = 南京市，扬州市，苏州市，无锡市，常州市
湖北省 = 武汉市，孝感市，十堰市，宜昌市，鄂州市
河北省 = 石家庄市，唐山市，邢台市，保定市，张家口
分析
- 定义一个 Map 集合，键表示省份名称，值表示城市名称，注意有多个城市
- 根据 “湖北省” 这个键获取对应的值展示即可
代码示例
import java.util.*;
/**
* 目标：理解集合的嵌套
*/
public class Test {
public static void main(String[] args) {
// 1、定义一个Map集合存储全部的省份信息，和其对应的城市信息
Map<String, List<String>> map = new HashMap<>();
List<String> cities1 = new ArrayList<>();
Collections.addAll(cities1, "南京市","扬州市","苏州市" ,"无锡市","常州市");
map.put("江苏省", cities1);
List<String> cities2 = new ArrayList<>();
Collections.addAll(cities2, "武汉市","孝感市","十堰市","宜昌市","鄂州市");
map.put("湖北省", cities2);
List<String> cities3 = new ArrayList<>();
Collections.addAll(cities3, "石家庄市","唐山市", "邢台市", "保定市", "张家口市");
map.put("河北省", cities3);
map.forEach((k, v) -> System.out.println(k + " = " + v));
List<String> cities = map.get("湖北省");
for (String city : cities) {
System.out.println(city);
}
}
}
JDK8新特性：Stream流
认识Stream
什么是 Stream ?
- 也叫做 Stream 流，是 JDK8 开始新增的一套 API（java.util.stream.*），可以用于操作集合或者数组的数据
- 优势：Stream 流大量地结合了 Lambda 的语法风格来编程，提供了一种更加强大、更加简单的方式操作集合或者数组中的数据，代码更简洁，可读性更好
案例：体验Stream流
需求
List<String> names = new ArrayList<>();
Collections.addAll(names, "张三丰","张无忌","周芷若","赵敏","张强");
把集合中所有以 “张” 开头，且是 3 个字的元素存储到一个新的集合中
代码示例
import java.util.*;
import java.util.stream.Collectors;
/**
目标：初步体验Stream流的方便与快捷
*/
public class StreamTest1 {
public static void main(String[] args) {
List<String> names = new ArrayList<>();
Collections.addAll(names, "张三丰","张无忌","周芷若","赵敏","张强");
System.out.println(names);
// 找出姓张，且是3个字的名字，存入到一个新集合中去
List<String> list = new ArrayList<>();
for (String name : names) {
if(name.startsWith("张") && name.length() == 3){
list.add(name);
}
}
System.out.println("一般方式: " + list);
// 开始使用Stream流来解决这个需求
List<String> list2 = names.stream().filter(s -> s.startsWith("张"))
.filter(a -> a.length()==3).collect(Collectors.toList());
System.out.println("Stream流: " + list2);
}
}
Stream流的使用步骤
Stream的常用方法
1、获取Stream流
- 获取集合的 Stream 流
- 获取数组的 Stream 流
import java.util.*;
import java.util.stream.Stream;
/**
* 目标：掌握Stream流的创建
*/
public class StreamTest2 {
public static void main(String[] args) {
// 1、如何获取List集合的Stream流？
List<String> names = new ArrayList<>();
Collections.addAll(names, "张三丰","张无忌","周芷若","赵敏","张强");
Stream<String> stream = names.stream();
// 2、如何获取Set集合的Stream流？
Set<String> set = new HashSet<>();
Collections.addAll(set, "刘德华","张曼玉","蜘蛛精","马德","德玛西亚");
Stream<String> stream1 = set.stream();
stream1.filter(s -> s.contains("德")).forEach(System.out::println);
// 3、如何获取Map集合的Stream流？
Map<String, Double> map = new HashMap<>();
map.put("古力娜扎", 172.3);
map.put("迪丽热巴", 168.3);
map.put("马尔扎哈", 166.3);
map.put("卡尔扎巴", 168.3);
Set<String> keys = map.keySet();
Stream<String> ks = keys.stream();
Collection<Double> values = map.values();
Stream<Double> vs = values.stream();
Set<Map.Entry<String, Double>> entries = map.entrySet();
Stream<Map.Entry<String, Double>> kvs = entries.stream();
kvs.filter(e -> e.getKey().contains("巴"))
.forEach(e -> System.out.println(e.getKey()+ "-->" + e.getValue()));
// 4、如何获取数组的Stream流？
String[] names2 = {"张翠山", "东方不败", "唐大山", "独孤求败"};
Stream<String> s1 = Arrays.stream(names2);
Stream<String> s2 = Stream.of(names2);
}
}
2、Stream流常见的中间方法
中间方法指的是调用完成后会返回新的 Stream 流，可以继续使用（支持链式编程）
Student 类和前面的一样
import java.util.*;
import java.util.stream.Stream;
/**
* 目标：掌握Stream流提供的常见中间方法
*/
public class StreamTest3 {
public static void main(String[] args) {
List<Double> 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(System.out::println);
List<Student> 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(System.out::println);
// 需求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<String> st1 = Stream.of("张三", "李四");
Stream<String> st2 = Stream.of("张三2", "李四2", "王五");
Stream<String> allSt = Stream.concat(st1, st2);
allSt.forEach(System.out::println);
}
}
3、Stream流常见的终结方法
终结方法指的是调用完成后，不会返回新的 Stream 了，没法继续使用流了
收集 Stream 流：就是把 Stream 流操作后的结果转回到集合或者数组中去返回
Stream 流：方便操作集合或数组的手段；集合 / 数组：才是开发中的目的
import java.util.*;
import java.util.stream.Collectors;
/**
* 目标：Stream流的终结方法
*/
public class StreamTest4 {
public static void main(String[] args) {
List<Student> 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<Student> students1 = students.stream().filter(a -> a.getHeight() > 170).collect(Collectors.toList());
System.out.println(students1);
Set<Student> students2 = students.stream().filter(a -> a.getHeight() > 170).collect(Collectors.toSet());
System.out.println(students2);
// 需求5：请找出身高超过170的学生对象，并把学生对象的名字和身高，存入到一个Map集合返回
Map<String, Double> 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));
}
}