Stream流的基本使用方法
0.常用方法
在介绍的各种方法中,凡是返回值仍然为Stream接口的为函数拼接方法,它们支持链式调用;而返回值不再为Stream接口的为终结方法,不再支持链式调用。如下表所示:
方法名 | 方法作用 | 方法种类 | 是否支持链式调用 |
---|---|---|---|
count | 统计个数 | 终结 | 否 |
forEach | 逐一处理 | 终结 | 否 |
filter | 过滤 | 函数拼接 | 是 |
limit | 取用前几个 | 函数拼接 | 是 |
skip | 跳过前几个 | 函数拼接 | 是 |
map | 映射 | 函数拼接 | 是 |
concat | 组合 | 函数拼接 | 是 |
1.测试类
package com.william;
import java.lang.reflect.Array;
import java.util.*;
import java.util.function.Consumer;
import java.util.stream.Stream;
/**
* 终结方法count(),forEach() 只能使用一次Stream
* 使用多次会抛异常:流已被操作或关闭
* Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed
*/
public class Test {
public static void main(String[] args) {
//ArrayList集合
System.out.println("--------ArrayList----------");
ArrayList<String> objects = new ArrayList<>();
objects.add("科比");
objects.add("詹姆斯");
objects.add("乔丹");
objects.add("姚明");
objects.add("艾弗森");
objects.add("奥尼尔");
objects.add("加内特");
Stream<String> stream = objects.stream();
stream.forEach(s -> System.out.println(s));
// Stream<String> stringStream = stream.filter(s -> s.length() == 3).filter(s->s.endsWith("森"));
//Stream<String> stringStream = stream.filter(s -> s.startsWith("科"));
// stringStream.forEach(s1 -> System.out.println(s1));
System.out.println("----------Map-------------");
HashMap<String, Object> map = new HashMap<>();
map.put("1","value1");
map.put("2","value2");
map.put("3","value3");
map.put("4","value4");
System.out.println("---------遍历map方式1 keys和values分开-------------");
// Set<String> strings = map.keySet();
// Collection<Object> values = map.values();
// Stream<String> stream1 = strings.stream();
// stream1.forEach(s-> System.out.println(s));
// Stream<Object> stream2 = values.stream();
// stream2.forEach(s2-> System.out.println(s2));
System.out.println("---------遍历map方式2 entrySet-------------");
Set<Map.Entry<String, Object>> entries = map.entrySet();
Stream<Map.Entry<String, Object>> stream3 = entries.stream();
// stream3.filter(s->s.getKey()=="1").forEach(s3-> System.out.println(s3));
long count = stream3.count();
System.out.println(count);
// ThreadMain threadMain = new ThreadMain();
// threadMain.start();
// Thread thread = Thread.currentThread();
//
// for (int i = 0; i < 100; i++) {
// System.out.println( thread.getName()+" : "+thread.getId()+"main---"+i);
// }
System.out.println("--------------数组-------------");
String[] array = {"1","2","3","4"};
Stream<String> array1 = Stream.of(array);
array1.forEach(sa-> System.out.println(sa));
Stream<String> babys = Stream.of("火娃", "水娃", "土娃", "金刚娃", "葫芦娃", "千里眼", "顺风耳", "爷爷", "蛇精");
babys.filter(s -> s.contains("娃")).filter(s -> s.length()==3).forEach(s -> System.out.println(s));
System.out.println("----------limit&skip------------");
//String[] limitDemo={"美国队长","绿巨人","钢铁侠","蜘蛛侠","蜂人","黑豹","蝙蝠侠","黑寡妇"};
Stream<String> limitDemoStream = Stream.of("美国队长", "绿巨人", "钢铁侠", "蜘蛛侠", "蜂人", "黑豹", "蝙蝠侠", "黑寡妇");
//limitDemoStream.limit(4).forEach(s -> System.out.println(s));//获取前四个
//获取前四个的后两个
limitDemoStream.limit(4).skip(2).forEach(s -> System.out.println(s));
System.out.println("-------将stream转换为persion对象------------");
Stream<String> limitDemoStream1 = Stream.of("美国队长", "绿巨人", "钢铁侠", "蜘蛛侠", "蜂人", "黑豹", "蝙蝠侠", "黑寡妇");
limitDemoStream1.map(s -> new Persion(s)).forEach(s-> System.out.println(s));
System.out.println("--------将stream流进行合并--------------");
Stream<String> limitDemoStream11 = Stream.of("美国队长", "绿巨人", "钢铁侠", "蜘蛛侠", "蜂人", "黑豹", "蝙蝠侠", "黑寡妇");
Stream<String> babys1 = Stream.of("火娃", "水娃", "土娃", "金刚娃", "葫芦娃", "千里眼", "顺风耳", "爷爷", "蛇精");
Stream.concat(babys1,limitDemoStream11).forEach(s -> System.out.println(s));
}
}
2.实体类Persion
package com.william;
public class Persion {
private String name;
public Persion(String name) {
this.name = name;
}
public Persion() {
}
@Override
public String toString() {
return "Persion{" +
"name='" + name + '\'' +
'}';
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
package com.asx.application.common.utils;
import java.util.*;
import java.util.stream.Collectors;
//Stream(流)是一个来自数据源的元素队列并支持聚合操作
//
// 元素是特定类型的对象,形成一个队列。 Java中的Stream并不会存储元素,而是按需计算。
// 数据源 流的来源。 可以是集合,数组,I/O channel, 产生器generator 等。
// 聚合操作 类似SQL语句一样的操作, 比如filter, map, reduce, find, match, sorted等。
// 和以前的Collection操作不同, Stream操作还有两个基础的特征:
//
// Pipelining: 中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道, 如同流式风格(fluent style)。 这样做可以对操作进行优化, 比如延迟执行(laziness)和短路( short-circuiting)。
// 内部迭代: 以前对集合遍历都是通过Iterator或者For-Each的方式, 显式的在集合外部进行迭代, 这叫做外部迭代。 Stream提供了内部迭代的方式, 通过访问者模式(Visitor)实现。
public class demo {
public static void main(String[] args) {
//
List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());;
filtered.forEach(s-> System.out.println(s));
// forEach
// Stream 提供了新的方法 'forEach' 来迭代流中的每个数据。以下代码片段使用 forEach 输出了10个随机数
Random random = new Random();
random.ints().limit(10).forEach(System.out::println);
// map
// map 方法用于映射每个元素到对应的结果,以下代码片段使用 map 输出了元素对应的平方数
List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
// 获取对应的平方数
List<Integer> squaresList = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());
squaresList.forEach(s-> System.out.println(s));//效果相同
squaresList.forEach(System.out::println);//效果相同
List<String>string1 = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
// 获取空字符串的数量
long count = string1.stream().filter(string -> string.isEmpty()).count();
System.out.println(count);
Random random1 = new Random();
random1.ints().limit(10).forEach(System.out::println);
// Collectors
// Collectors 类实现了很多归约操作,例如将流转换成集合和聚合元素。Collectors 可用于返回列表或字符串
List<String>strings2 = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
List<String> filtered1 = strings2.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());
System.out.println("筛选列表: " + filtered1);
String mergedString = strings2.stream().filter(string -> !string.isEmpty()).collect(Collectors.joining(", "));
System.out.println("合并字符串: " + mergedString);
List<Integer> numbers12 = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
//统计
IntSummaryStatistics stats = numbers12.stream().mapToInt((x) -> x).summaryStatistics();
IntSummaryStatistics intSummaryStatistics = numbers12.stream().mapToInt((a) -> a).summaryStatistics();
System.out.println("列表中最大的数 : " + stats.getMax());
System.out.println("列表中最小的数 : " + stats.getMin());
System.out.println("所有数之和 : " + stats.getSum());
System.out.println("平均数 : " + stats.getAverage());
}
}
Stream做非空判断
对排序的对象,以及排序对象的成员变量做非空判断
/**对排序的对象,以及排序对象的成员变量做非空判断**/
sortList = list.stream()
.filter(Objects::nonNull)
.filter(a -> a.getLastChgDt() != null)
.sorted(Comparator.comparing(RelDTO::getLastChgDt)
.reversed()).collect(Collectors.toList());