JavaStream流的使用
JavaStream流的使用
目录
- JavaStream流的使用
- 1、创建集合添加元素，完成以下需求
- 2、尝试Stream流
- 3、双列集合
- 4、数组
- 5、零散数据
- 6、filter，limit，skip的用法
- 7、去重，连接
- 8、map 转换流中的数据类型
- 9、遍历，统计，收集流中的数据，放到数组中
- 10、Collect(Collector collector) 收集流中的数据，放到集合中（List Set Map）
- 11、实战小练习
1、创建集合添加元素，完成以下需求
1.把所有以“张”开头的元素存储到新集合中
2.把“张”开头的，长度为3的元素再存储到新集合中
3.遍历打印最终结果
package com.zjzakia01mystream;
import java.util.ArrayList;
/**
* @author zjzaki
* @create 2023年05月27日 22:20:35
*/
public class StreamDemo01 {
public static void main(String[] args) {
/*
创建集合添加元素，完成以下需求
1.把所有以“张”开头的元素存储到新集合中
2.把“张”开头的，长度为3的元素再存储到新集合中
3.遍历打印最终结果
*/
ArrayList<String> list1 = new ArrayList<>();
list1.add("张无忌");
list1.add("周芷若");
list1.add("赵敏");
list1.add("张强");
list1.add("张三丰");
list1.stream().filter(name -> name.startsWith("张")).filter(name -> name.length() == 3).forEach(name -> System.out.println(name));
//ArrayList list1 = new ArrayList<>();
//list1.add("张无忌");
//list1.add("周芷若");
//list1.add("赵敏");
//list1.add("张强");
//list1.add("张三丰");
//
1.把所有以“张”开头的元素存储到新集合中
//ArrayList list2 = new ArrayList<>();
//for (String name : list1) {
// if (name.startsWith("张")) {
// list2.add(name);
// }
//}
//System.out.println(list2);
//
2.把“张”开头的，长度为3的元素再存储到新集合中
//ArrayList list3 = new ArrayList<>();
//for (String name : list2) {
// if (name.length() == 3) {
// list3.add(name);
// }
//}
//System.out.println(list3);
//
3.遍历打印最终结果
//for (String name : list3) {
// System.out.println(name);
//}
}
}
2、尝试Stream流
package com.zjzakia01mystream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.function.Consumer;
import java.util.stream.Stream;
/**
* @author zjzaki
* @create 2023年05月27日 22:50:23
*/
public class StreamDemo2 {
public static void main(String[] args) {
/*
单列集合 default Stream stream() Collection中的默认方法
双列集合 无 无法直接使用stream流
数组 public static Stream stream(T[] array) Arrays工具类中的静态方法
一堆零散数据 public static Stream of(T... values) Stream接口中的静态方法
*/
//1.单列集合
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "a", "b", "c", "d", "e");
//获取到一条流
//Stream stream1 = list.stream();
//使用终结方法打印一下流水线上的数据
//stream1.forEach(new Consumer() {
// @Override
// public void accept(String s) {
// //s:依次表示流水线上的数据
// System.out.println(s);
// }
//});
list.stream().forEach(s -> System.out.println(s));
}
}
3、双列集合
package com.zjzakia01mystream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
/**
* @author zjzaki
* @create 2023年05月27日 22:50:23
*/
public class StreamDemo3 {
public static void main(String[] args) {
//双列集合 无 无法直接使用stream流
//1.创建双列集合
HashMap<String, Integer> hm = new HashMap<>();
//2.添加数据
hm.put("aaa", 111);
hm.put("bbb", 222);
hm.put("ccc", 333);
hm.put("ddd", 444);
//3.获取Stream流
hm.keySet().stream().forEach(s -> System.out.println(s));
//4.第二种获取stream流的方法
hm.entrySet().stream().forEach(s -> System.out.println(s));
}
}
4、数组
package com.zjzakia01mystream;
import java.util.Arrays;
import java.util.HashMap;
/**
* @author zjzaki
* @create 2023年05月27日 22:50:23
*/
public class StreamDemo4 {
public static void main(String[] args) {
//数组 public static Stream stream(T[] array) Arrays工具类中的静态方法
//1.创建数组
int[] arr1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
String[] arr2 = {"a","b","c"};
//2.获取stream流
Arrays.stream(arr1).forEach(s -> System.out.println(s));
System.out.println("=========================");
Arrays.stream(arr2).forEach(s -> System.out.println(s));
}
}
5、零散数据
package com.zjzakia01mystream;
import java.util.Arrays;
import java.util.stream.Stream;
/**
* @author zjzaki
* @create 2023年05月27日 22:50:23
*/
public class StreamDemo5 {
public static void main(String[] args) {
//一堆零散数据 public static Stream of(T... values) Stream接口中的静态方法
Stream.of(1, 2, 3, 4, 5, 6).forEach(s -> System.out.println(s));
Stream.of("a","b","c","d").forEach(s -> System.out.println(s));
}
}
6、filter，limit，skip的用法
package com.zjzakia01mystream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Predicate;
/**
* @author zjzaki
* @create 2023年05月28日 10:45:28
*/
public class StreamDemo6 {
public static void main(String[] args) {
/*
filter 过滤
limit 获取前几个元素
skip 跳过前几个元素
注意1：中间方法，返回新的Stream，原来的Stream流只能使用一次，建议使用链式编程
注意2：修改Stream流中的数据，不会影响原来集合或者数组中的数据
*/
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤");
// filter 过滤 把张开头的留下
//list.stream().filter(new Predicate() {
// @Override
// public boolean test(String s) {
// //如果返回值为true,表示留下
// return s.startsWith("张");
// }
//}).forEach(s-> System.out.println(s));
//list.stream().filter(s -> s.startsWith("张")).forEach(s -> System.out.println(s));
//list.stream().limit(3)
//.forEach(s -> System.out.println(s));
list.stream().skip(4).forEach(s-> System.out.println(s));
}
}
7、去重，连接
package com.zjzakia01mystream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.stream.Stream;
/**
* @author zjzaki
* @create 2023年05月28日 10:45:28
*/
public class StreamDemo7 {
public static void main(String[] args) {
/*
filter 过滤
limit 获取前几个元素
skip 跳过前几个元素
注意1：中间方法，返回新的Stream，原来的Stream流只能使用一次，建议使用链式编程
注意2：修改Stream流中的数据，不会影响原来集合或者数组中的数据
*/
ArrayList<String> list1 = new ArrayList<>();
Collections.addAll(list1, "张无忌", "张无忌", "张无忌", "张无忌", "周芷若", "赵敏", "张强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤");
ArrayList<String> list2 = new ArrayList<>();
Collections.addAll(list2, "周芷若", "赵敏");
//list1.stream().distinct().forEach(s-> System.out.println(s));
Stream.concat(list1.stream(), list2.stream()).forEach(s -> System.out.println(s));
}
}
8、map 转换流中的数据类型
package com.zjzakia01mystream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Function;
import java.util.stream.Stream;
/**
* @author zjzaki
* @create 2023年05月28日 10:45:28
*/
public class StreamDemo8 {
public static void main(String[] args) {
/*
map 转换流中的数据类型
*/
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌-15", "周芷若-14", "赵敏-13", "张强-20", "张三丰-100", "张翠三-40", "张良-35", "王二麻子-37");
//只获取里面的年龄并进行打印
//String -> int
//第一个类型表示流中原本的类型，第二个表示转后的类型
// apply 依次表示流里面的每一个数据
//返回值：表示转换后的数据
//list.stream().map(new Function() {
//
// @Override
// public Integer apply(String s) {
// String[] arr = s.split("-");
// String ageStr = arr[1];
// int age = Integer.parseInt(ageStr);
//
// return age;
// }
//}).forEach(s -> System.out.println(s));
list.stream()
.map(s -> Integer.parseInt(s.split("-")[1]))
.forEach(s -> System.out.println(s));
}
}
9、遍历，统计，收集流中的数据，放到数组中
package com.zjzakia01mystream;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.function.Consumer;
import java.util.function.IntFunction;
/**
* @author zjzaki
* @create 2023年05月28日 10:45:28
*/
public class StreamDemo9 {
public static void main(String[] args) {
/*
void forEach(Consumer action) 遍历
long count() 统计
toArray() 收集流中的数据，放到数组中
*/
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰", "张翠三", "张良", "王二麻子");
//void forEach(Consumer action) 遍历
//Consumer的泛型表示流中的数据的类型
//accept方法的形参s：依次表示流里面的每一个数据0
//accept：对每个数据的处理操作
//list.stream().forEach(new Consumer() {
// @Override
// public void accept(String s) {
// System.out.println(s);
// }
//});
//list.stream().forEach(s -> System.out.println(s));
//long count
//long count = list.stream().count();
//System.out.println(count);
//toArray
//Object[] arr = list.stream().toArray();
//System.out.println(Arrays.toString(arr));
//IntFunction 泛型：具体类型的数组
//apply的形参：流中数据的个数，要跟数组的长度保持一致
//apply的返回值：具体类型的数组
//方法体: 就是创建数组
//String[] arr = list.stream().toArray(new IntFunction() {
// @Override
// public String[] apply(int value) {
//
// return new String[value];
// }
//});
//
//System.out.println(Arrays.toString(arr));
String[] arr = list.stream().toArray(value -> new String[value]);
System.out.println(Arrays.toString(arr));
}
}
10、Collect(Collector collector) 收集流中的数据，放到集合中（List Set Map）
package com.zjzakia01mystream;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
/**
* @author zjzaki
* @create 2023年05月28日 10:45:28
*/
public class StreamDemo10 {
public static void main(String[] args) {
/*
Collect(Collector collector) 收集流中的数据，放到集合中（List Set Map）
*/
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌-男-15", "周芷若-女-14", "赵敏-女-13", "张强-男-20",
"张三丰-男-100", "张翠三-男-40", "张良-男-35", "王二麻子-男-37", "谢广坤-男-41");
//收集到List集合当中
//需求：把所有的男性收集起来
List<String> newList = list.stream()
.filter(s -> "男".equals(s.split("-")[1]))
.collect(Collectors.toList());
System.out.println(newList);
//收集到Set集合当中
//需求：把所有的男性收集起来
Set<String> set = list.stream().filter(s -> "男".equals(s.split("-")[1]))
.collect(Collectors.toSet());
System.out.println(set);
//收集Map集合当中
//谁作为键，谁做为值
//键：姓名，值：年龄
Map<String, Integer> map = list.stream().filter(s -> "男".equals(s.split("-")[1]))
/*
toMap：参数一表示键的生成规则
参数二表示值的生成规则
参数一：
Function泛型一：表示流中每一个数据的类型
泛型二：表示map集合中键的数据类型
方法apply：依次表示流里面的每一个数据
方法体：生成键
返回值：已经生成的键
参数二：
Function泛型一：表示流中每一个数据的类型
泛型二：表示map集合中值的数据类型
方法apply：依次表示流里面的每一个数据
方法体：生成键
返回值：已经生成的键
*/
.collect(Collectors.toMap(new Function<String, String>() {
@Override
public String apply(String s) {
return s.split("-")[0];
}
}, new Function<String, Integer>() {
@Override
public Integer apply(String s) {
return Integer.parseInt(s.split("-")[2]);
}
}));
System.out.println(map);
Map<String, Integer> collect = list.stream().filter(s -> "男".equals(s.split("-")[1]))
.collect(Collectors.toMap(s -> s.split("-")[0], s -> Integer.parseInt(s.split("-")[2])));
System.out.println(collect);
}
}
11、实战小练习
Actor.java
package com.zjzaki.a02test;
/**
* @author zjzaki
* @create 2023年05月28日 17:53:51
*/
public class Actor {
private String name;
private int age;
public Actor() {
}
public Actor(String name, int age) {
this.name = name;
this.age = age;
}
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;
}
@Override
public String toString() {
return "Actor{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
Test1.java
package com.zjzaki.a02test;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
/**
* @author zjzaki
* @create 2023年05月28日 17:07:24
*/
public class Test1 {
public static void main(String[] args) {
/*
定义一个集合，并添加一些整数 1,2,3,4,5,6,7,8,9,10
过滤奇数，只留下偶数
并将结果保存起来
*/
//1.定义一个集合
ArrayList<Integer> list = new ArrayList<>();
//2.添加一些整数
Collections.addAll(list, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
//3.过滤奇数，只留下偶数
//进行判断，如果是偶数，返回true保留
List<Integer> collect = list.stream()
.filter(n -> n % 2 == 0)
.collect(Collectors.toList());
System.out.println(collect);
}
}
Test2.java
package com.zjzaki.a02test;
import java.util.ArrayList;
import java.util.Map;
import java.util.stream.Collectors;
/**
* @author zjzaki
* @create 2023年05月28日 17:13:21
*/
public class Test2 {
public static void main(String[] args) {
/*
练习：
创建一个ArrayList集合，并添加以下字符串，字符串中前面是姓名，后面是年龄
"zhangsan,23"
"list,24"
"wangwu,25"
保留年龄大于等于24岁的人，并将结果收集到Map集合中，姓名为键，年龄为值
*/
ArrayList<String> list = new ArrayList<>();
list.add("zhangsan,23");
list.add("list,24");
list.add("wangwu,25");
Map<String, Integer> map = 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(map);
}
}
Test3.java
package com.zjzaki.a02test;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* @author zjzaki
* @create 2023年05月28日 17:33:47
*/
public class Test3 {
public static void main(String[] args) {
/*
现在有两个ArrayList集合，分别存储6名男演员的名字和年龄以及6名女演员的名字和年龄
姓名和年龄中间用逗号隔开
比如：张三，23
要求完成如下的操作：
1.男演员只要名字为3个字的前两人
2.女演员只要姓杨的，并且不要第一个
3.把过滤后的男演员姓名和女演员姓名合并到一起
4.将上一步的演员姓名封装成Actor对象
5.将所有的演员对象都保存到List集合中
备注：演员类Actor，属性有name,age
男演员："蔡坤坤,24","叶齁咸,23","刘不甜,22","吴签,24","谷嘉,30","肖梁梁,27"
女演员："赵小颖,35","杨颖,36","高元元,43","张天天,31","刘诗,35","杨小幂,33"
*/
ArrayList<String> manList = new ArrayList<>();
ArrayList<String> womenList = new ArrayList<>();
//2.添加数据
Collections.addAll(manList, "蔡坤坤,24", "叶齁咸,23", "刘不甜,22", "吴签,24", "谷嘉,30", "肖梁梁,27");
Collections.addAll(womenList, "赵小颖,35", "杨颖,36", "高元元,43", "张天天,31", "刘诗,35", "杨小幂,33");
//3.男演员只要名字为3个字的前两人
Stream<String> stream1 = manList.stream()
.filter(s -> s.split(",")[0].length() == 3)
.limit(2);
//4.女演员只要姓杨的，并且不要第一个
Stream<String> stream2 = womenList.stream()
.filter(s -> s.split(",")[0].startsWith("杨"))
.skip(1);
//5.把过滤后的男演员姓名和女演员姓名合并到一起
//装成Actor对象
//Stream.concat(stream1, stream2).map(new Function() {
// @Override
// public 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> collect = Stream.concat(stream1, stream2)
.map(s -> new Actor(s.split(",")[0], Integer.parseInt(s.split(",")[1])))
.collect(Collectors.toList());
System.out.println(collect);
}
}