【Java学习|黑马笔记|Day18】Stream流|获取、中间方法、终结方法、收集方法及其练习

【DAY18】

不可变集合

• 如果某个数据不能被修改，把它拷贝到不可变集合中
• 当集合对象不被可信的库调用时不可变形式是安全的

创建不可变集合的书写格式

方法名称	说明
static list of(E…elements)	创建一个具有指定元素的List集合对象
static Setof(E…elements)	创建一个具有指定元素的Set集合对象
static<K,V> Map<K,V> of(E…elements)	创建一个具有指定元素的Map集合对象

List<String> list = List.of("a","b","c","d");
//参数要保持唯一性
System.out.println(list.get(0));
System.out.println(list.get(1));
System.out.println(list.get(2));
System.out.println(list.get(3));
for (String s : list) {System.out.println(s);
}

//细节：键不能重复，参数有上限，最多只能传递10个键值对
Map<String,String> map = Map.of("a","b","c","d","e","f");
Set<String> keys = map.keySet();
for (String key : keys) {System.out.println(key + "=" + map.get(key));
}

//创建Map的不可变集合，键值对的数量超过10个
//1.创建一个普通的Map集合
HashMap<String, String> hm = new HashMap<>();
hm.put("a","1");
hm.put("b","2");
hm.put("c","3");
hm.put("d","4");
hm.put("e","5");
hm.put("f","6");
hm.put("g","7");
hm.put("h","8");
hm.put("i","9");
//2.利用上面数据获取一个不可变的集合
//获取到所有的键值对对象（Entry对象）
Set<Map.Entry<String, String>> entries = hm.entrySet();
//把entries变成一个数组
Map.Entry[] arr1 = new Map.Entry[0];
//toArray方法在底层会比较集合的长度跟数组的长度两者的大小
//如果集合的长度 > 数组的长度 ：数据在数组中放不下，此时会根据实际数据的个数，重新创建数组
//如果集合的长度 <= 数组的长度：数据在数组中放的下，此时不会创建新的数组，而是直接用//简化
Map<String,String> map = Map.copyOf(hm);

一.Stream流

可理解为把一堆数据放到一个流水线上

作用：结合Lambda表达式，简化集合、数组的操作

1.1）获取Stream流

Stream流的使用步骤：

1. 先得到一条Stream流，并把数据放上去

   

2. 使用中间方法进行操作

3. 使用终结方法进行操作

//单列集合获取Stream流
ArrayList<String> list = new ArrayList();
Collections.addAll(list,"a","b","c","d","e","f","g");
/*Stream<String> stream1 = list.stream();
stream1.forEach(new Consumer<String>() {@Overridepublic void accept(String s) {System.out.println(s);}
});*/
list.stream().forEach(s -> System.out.println(s));

//双列集合获取Stream流
HashMap<String, Integer> hm = new HashMap<>();
hm.put("a",1);
hm.put("b",2);
hm.put("c",3);
hm.put("d",4);
//第一种 键
hm.keySet().stream().forEach(s -> System.out.println(s));
//第二种 键值对
hm.entrySet().stream().forEach(s -> System.out.println(s));

//数组的Stream流
int[] arr = {1,2,3,4,5,6};
Arrays.stream(arr).forEach(s -> System.out.println(s));
String[] arr2 = {"a","b","c","d","e","f","g"};
Arrays.stream(arr2).forEach(s -> System.out.println(s));

//一堆零散数据
Stream.of(1,2,3,4,5,6,7,8,9).forEach(s -> System.out.println(s));
Stream.of("aa","bb","cc","dd").forEach(s -> System.out.println(s));

1.2）中间方法

filter

ArrayList<String> list = new ArrayList<>();
Collections.addAll(list,"a","abc","ca","dc","ae","fs","gs");
//filter 过滤 留下以a开头的/*list.stream().filter(new Predicate<String>() {@Overridepublic boolean test(String s) {//如果返回true 表示当前的要留下 反之不要return s.startsWith("a");}}).forEach(s -> System.out.println(s));*///简化//list.stream().filter(s -> s.startsWith("a")).forEach(s -> System.out.println(s));//筛选a开头且长度为三的Stream<String> stream1 = list.stream().filter(s ->s.startsWith("a"));Stream<String> stream2 = stream1.filter(s -> s.length() == 3);stream2.forEach(s -> System.out.println(s));//化简list.stream().filter(s -> s.startsWith("a")).filter(s -> s.length() == 3).forEach(s -> System.out.println(s));

limit 和 skip

ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "a", "abc", "ca", "dc", "ae", "fs", "gs");//limit 获取前几个元素
list.stream().limit(3).forEach(s -> System.out.println(s));//skip 跳过前几个元素
list.stream().skip(3).forEach(s -> System.out.println(s));

distinct

ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "a","a","abc", "abc", "ca", "dc", "ae", "fs", "gs");
//去重 依赖hashCode和equals
list.stream().distinct().forEach(s ->System.out.println(s));

concat

ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "a","a","abc", "abc", "ca", "dc", "ae", "fs", "gs");
ArrayList<String> list2 = new  ArrayList<>();
Collections.addAll(list2, "a","a","abc", "abc", "ca", "dc", "ae", "fs", "gs");
Stream.concat(list.stream(), list2.stream()).forEach(s -> System.out.println(s));

map

ArrayList<String> list = new ArrayList<>();
//要求：只要数字
Collections.addAll(list, "a-11","a-12","abc-23", "abc-3", "ca-3", "dc-34", "ae-45", "fs-87", "gs-49");//String 转 Integer
list.stream().map(new Function<String, Integer>() {//第一个类型 流中原本的数据//第二个类型 要转变之后的类型//apply的形参 依次表示流里面每一个数据//返回值 表示转换之后的数据@Overridepublic Integer apply(String s) {String[] arr = s.split("-");String ageString = arr[1];//获取后面部分int age = Integer.parseInt(ageString);//转成Integerreturn age;}
}).forEach(s -> System.out.print(s + " "));
System.out.println();//简化
list.stream().map(s -> Integer.parseInt(s.split("-")[1])).forEach(s -> System.out.print(s + " "));

1.3）终结方法

forEach

ArrayList<String> list = new ArrayList();
Collections.addAll(list,"a","b","c","d","e","f","g");
//遍历
//Consumer的泛型：表示流中数据的类型
//accept方法的形参：依次表示流里面是每一个数据
list.stream().forEach(new Consumer<>() {@Overridepublic void accept(String s){System.out.println(s);}
});list.stream().forEach(s -> System.out.println(s));

count

ArrayList<String> list = new ArrayList();
Collections.addAll(list,"a","b","c","d","e","f","g");
//统计 long类型
long count = list.stream().count();
System.out.println(count);//7

toArray

ArrayList<String> list = new ArrayList();
Collections.addAll(list,"a","b","c","d","e","f","g");
//toArray 收集流中数据并放到数组中
Object[] arr1 = list.stream().toArray();
System.out.println(Arrays.toString(arr1));//[a, b, c, d, e, f, g]//IntFunction的泛型：具体类型的数组
//apply的形参:流中数据的个数，要跟数组的长度保持一致
//apply的返回值：具体类型的数组//toArray方法参数的作用：负责创建一个指定类型的数组
//toArray方法的底层：依次得到流里面的每一个数据，并把数据放到数组里
//toArray方法的返回值：是一个载着流里面所有数据的数组
String[] arr = list.stream().toArray(new IntFunction<String[]>() {@Overridepublic String[] apply(int value) {return new String[value];}
});
System.out.println(Arrays.toString(arr));//化简
String[] arr2 = list.stream().toArray(value ->new String[value]);
System.out.println(Arrays.toString(arr2));

1.4）收集方法collect

//需求：收集所有的女性ArrayList<String> list = new ArrayList<>();
Collections.addAll(list,"z-女-11", "a-男-12","f-女-15","e-男-43", "e-男-11","w-女-92","o-男-11");//收集到List中
List<String> newList = list.stream().filter(s ->"女".equals(s.split("-")[1])).collect(Collectors.toList());
System.out.println(newList);//收集到Set中 可以自动去重
Set<String> newSet = list.stream().filter(s ->"女".equals(s.split("-")[1])).collect(Collectors.toSet());
System.out.println(newSet);//收集到Map中
//键不能重复
Map<String,Integer> map = list.stream().filter(s ->"女".equals(s.split("-")[1]))//toMap：参数一表示键的生成规则 //       参数二表示值的生成规则//参数一：Function泛型一表示流中每一个数据的类型//               泛型二表示Map集合中键的数据类型//        apply形参：依次表示流里面的每个数据//             方法体：生成键的代码////.collect(Collectors.toMap(new Function<String, String>() {@Overridepublic String apply(String s) {return s.split("-")[0];}},new Function<String,Integer>() {@Overridepublic Integer apply(String s) {return Integer.parseInt(s.split("-")[2]);}}));System.out.println(map);//化简Map<String,Integer> map2 = list.stream().filter(s ->"女".equals(s.split("-")[1])).collect(Collectors.toMap(s -> s.split("-")[0],s -> Integer.parseInt(s.split("-")[2])));System.out.println(map2);

2）练习

2.1数据过滤

定义一个集合，并添加整数1,2,3,4,5,6,7,8,9,10，过滤奇数只留下偶数并将结果保留起来

//练习一：
ArrayList<Integer> list = new ArrayList<>();
Collections.addAll(list,1,2,3,4,5,6,7,8,9,10);
//过滤奇数
List<Integer> newList = list.stream().filter(n -> n % 2 == 0).collect(Collectors.toList());System.out.println(newList);

2.2字符串过滤并收集

创建一个ArrayList集合，添加以下字符串，保留年龄大于24的人 并把结果收集到集合中

//练习二：
ArrayList<String> list = new ArrayList();
Collections.addAll(list,"zs,23","ls,24","ww,25");
Map<String,Integer> mp = list.stream().filter(s ->Integer.parseInt(s.split(",")[1]) >= 24).collect(Collectors.toMap(s -> s.split(",")[0],s -> Integer.parseInt(s.split(",")[1])));System.out.println(mp);

2.3自定义对象并过滤

现在有两个ArrayList集合，分别存储6名男演员名称和6名女演员名称，要求完成如下的操作

• 男演员只要名字为3个字的前三人
• 女演员只要姓林的，并且不要第一个
• 把过滤后的男演员姓名和女演员姓名合并到一起
• 把上一步操作后的元素作为构造方法的参数创建演员对象,遍历数据

演员类Actor已经提供，里面有一个成员变量，一个带参构造方法，以及成员变量对应的get/set方法

ArrayList<String> manList = new ArrayList<>();
ArrayList<String> womanList = new ArrayList<>();Collections.addAll(manList, "aaa,24","bb,23","c,26","ddd,20","ee,30","fff,18");
Collections.addAll(womanList,"yq,23","ywwww,13","r,34","ttt,26","yp,25","oo,28");Stream<String> stream1 = manList.stream().filter(s -> s.split(",")[0].length() == 3).limit(2);Stream<String> stream2 = womanList.stream().filter(s -> s.split(",")[0].startsWith("y")).skip(1);//合并 转String-> Actor对象
/*Stream.concat(stream1,stream2).map(new Function<String, Actor>() {@Overridepublic Actor apply(String s) {String name = s.split(",")[0];int age = Integer.parseInt(s.split(",")[1]);return new Actor(name,age);}}).forEach(s -> System.out.println(s));*///化简List<Actor> list  = Stream.concat(stream1,stream2).map(s -> new Actor(s.split(",")[0],Integer.parseInt(s.split(",")[1]))).collect(Collectors.toList());System.out.println(list);