Stream流思想：
就相当于流水线一样，一道工序一道工序的进行排查，得出最后结果。
1.创建Stream流对象
1.1单列集合创建Stream流
// 单列 创建Stream List 可重复的
List<String> list = List.of("张三","李四","王五");
Stream<String> stream1 = list.stream();
// 单列不可重复的
Set<String> set = Set.of("张三","李四","王五");
Stream<String> stream2 = set.stream();1.2双列集合创建Stream流对象
// 双列 不能直接产生Stream流对象，而是通过先转单 Map<String, Integer> map = Map.of("张三", 19, "李四", 30); Set<String> set1 = map.keySet(); Stream<String> stream = set1.stream();
注意：双列集合不能直接创建Stream流对象，要用它的 keySet()方法 获取到单列集合。
3.数组 创建流对象
// 数组
int[] arr = {1,2,3};
IntStream stream3 = Arrays.stream(arr);数组要通过它的Arrays工具类 进行创建 Stream流。
4.相同类型;
Stream<String> stream4 = Stream.of("张三", "李四", "王五", "赵六");2.Stream流常用方法
1.中间方法
概念：执行完此方法之后,Stream流依然可以继续执行其他操作
| 方法名 | 说明 |
|---|---|
| Stream<T> filter(Predicate predicate) | 用于对流中的数据进行过滤 |
| Stream<T> limit(long maxSize) | 返回此流中的元素组成的流，截取前指定参数个数的数据 |
| Stream<T> skip(long n) | 跳过指定参数个数的数据，返回由该流的剩余元素组成的流 |
| static <T> Stream<T> concat(Stream a, Stream b) | 合并a和b两个流为一个流 |
| Stream<T> distinct() | 返回由该流的不同元素（根据Object.equals(Object) ）组成的流 |
| Stream<T> sorted() | 返回由此流的元素组成的流，根据自然顺序排序 |
| Stream<T> sorted(Comparator comparator) | 返回由该流的元素组成的流，根据提供的Comparator进行排序 |
| <R> Stream<R> map(Function mapper) | 返回由给定函数应用于此流的元素的结果组成的流 |
| IntStream mapToInt(ToIntFunction mapper) | 返回一个IntStream其中包含将给定函数应用于此流的元素的结果 |
展示几个常用方法：
1.filter(s -> 关系表达式) 过滤 保留返回值为true 的
public class MyStream3 {
public static void main(String[] args) {
// Stream<T> filter(Predicate predicate)：过滤
// Predicate接口中的方法 boolean test(T t)：对给定的参数进行判断，返回一个布尔值
ArrayList<String> list = new ArrayList<>();
list.add("张三丰");
list.add("张无忌");
list.add("张翠山");
list.add("王二麻子");
list.add("张良");
list.add("谢广坤");
//filter方法获取流中的 每一个数据.
//而test方法中的s,就依次表示流中的每一个数据.
//我们只要在test方法中对s进行判断就可以了.
//如果判断的结果为true,则当前的数据留下
//如果判断的结果为false,则当前数据就不要.
// list.stream().filter(
// new Predicate<String>() {
// @Override
// public boolean test(String s) {
// boolean result = s.startsWith("张");
// return result;
// }
// }
// ).forEach(s-> System.out.println(s));
//因为Predicate接口中只有一个抽象方法test
//所以我们可以使用lambda表达式来简化
// list.stream().filter(
// (String s)->{
// boolean result = s.startsWith("张");
// return result;
// }
// ).forEach(s-> System.out.println(s));、
//最后简化成
list.stream().filter(s ->s.startsWith("张")).forEach(s-> System.out.println(s));
}
}2.limit(n) 保留前n个 skip(n) 跳过 前n个
public class StreamDemo02 {
public static void main(String[] args) {
//创建一个集合，存储多个字符串元素
ArrayList<String> list = new ArrayList<String>();
list.add("林青霞");
list.add("张曼玉");
list.add("王祖贤");
list.add("柳岩");
list.add("张敏");
list.add("张无忌");
//需求1：取前3个数据在控制台输出
list.stream().limit(3).forEach(s-> System.out.println(s));
System.out.println("--------");
//需求2：跳过3个元素，把剩下的元素在控制台输出
list.stream().skip(3).forEach(s-> System.out.println(s));
System.out.println("--------");
//需求3：跳过2个元素，把剩下的元素中前2个在控制台输出
list.stream().skip(2).limit(2).forEach(s-> System.out.println(s));
}
}3.concat() 静态方法 类名直接调用 连接
distinct() 去重方法
public class StreamDemo03 {
public static void main(String[] args) {
//创建一个集合，存储多个字符串元素
ArrayList<String> list = new ArrayList<String>();
list.add("林青霞");
list.add("张曼玉");
list.add("王祖贤");
list.add("柳岩");
list.add("张敏");
list.add("张无忌");
//需求1：取前4个数据组成一个流
Stream<String> s1 = list.stream().limit(4);
//需求2：跳过2个数据组成一个流
Stream<String> s2 = list.stream().skip(2);
//需求3：合并需求1和需求2得到的流，并把结果在控制台输出
// Stream.concat(s1,s2).forEach(s-> System.out.println(s));
//需求4：合并需求1和需求2得到的流，并把结果在控制台输出，要求字符串元素不能重复
Stream.concat(s1,s2).distinct().forEach(s-> System.out.println(s));
}
}2.终结方法
常见方法
| 方法名 | 说明 |
|---|---|
| void forEach(Consumer action) | 对此流的每个元素执行操作 |
| long count() | 返回此流中的元素数 |
public class MyStream5 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("张三丰");
list.add("张无忌");
list.add("张翠山");
list.add("王二麻子");
list.add("张良");
list.add("谢广坤");
//method1(list);
// long count()：返回此流中的元素数
long count = list.stream().count();
System.out.println(count);
}
private static void method1(ArrayList<String> list) {
// void forEach(Consumer action)：对此流的每个元素执行操作
// Consumer接口中的方法void accept(T t)：对给定的参数执行此操作
//在forEach方法的底层,会循环获取到流中的每一个数据.
//并循环调用accept方法,并把每一个数据传递给accept方法
//s就依次表示了流中的每一个数据.
//所以,我们只要在accept方法中,写上处理的业务逻辑就可以了.
list.stream().forEach(
new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
}
);
System.out.println("====================");
//lambda表达式的简化格式
//是因为Consumer接口中,只有一个accept方法
list.stream().forEach(
(String s)->{
System.out.println(s);
}
);
System.out.println("====================");
//lambda表达式还是可以进一步简化的.
list.stream().forEach(s->System.out.println(s));
}
}注意：调用完终结方法就会直接关闭该流，不能再调用中间方法。
；分号也有终结的作用。
3.Stream流的收集操作******
对数据使用Stream流的方式操作完毕后,可以把流中的数据收集到集合中
常用方法：
| 方法名 | 说明 |
|---|---|
| R collect(Collector collector) | 把结果收集到集合中 |
工具类Collectors提供了具体的收集方式
| 方法名 | 说明 |
|---|---|
| public static <T> Collector toList() | 把元素收集到List集合中 |
| public static <T> Collector toSet() | 把元素收集到Set集合中 |
| public static Collector toMap(Function keyMapper,Function valueMapper) | 把元素收集到Map集合中 |
1.收集到List集合
List<Integer> list = List.of(1,2,3,4,5,6,7,8,9,10,10);
//收集成一个list集合
Stream<Integer> stream = list.stream();
List<Integer> list2 = stream.filter(s -> s % 2 == 0).collect(Collectors.toList());
System.out.println(list2);2.收集到Set集合
// 将数组去重 收集到 set集合中
Stream<Integer> stream2 = list.stream();
Set<Integer> set = stream2.filter(s -> s % 2 == 0).distinct().collect(Collectors.toSet());
System.out.println(set);3.收集到Map集合
ArrayList<String> list = new ArrayList<>();
list.add("张三,25");
list.add("李四,24");
list.add("王五,21");
list.add("赵六,28");
// 创建Map对象
HashMap<String,Integer> map = new HashMap<>();
Stream<String> stream = list.stream();
// 用Map接收
Map<String, String> map1 = stream.filter(s -> {
// 截取字符串
String[] strarr = s.split(",");
String name = strarr[0];//获取到名字
int age = Integer.parseInt(strarr[1]);
return age >= 24;
}).collect(Collectors.toMap(
s -> s.split(",")[0],
s -> s.split(",")[1]
));
System.out.println(map1);
6562
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
