目录
- 一. 流的常用创建方法
- 1-1 使用Collection下的 stream() 和 parallelStream() 方法
- 1-2 使用Arrays 中的 stream() 方法,将数组转成流
- 1-3 使用Stream中的静态方法:of()、iterate()、generate()
- 1-4 使用 BufferedReader.lines() 方法,将每行内容转成流
- 1-5 使用 Pattern.splitAsStream() 方法,将字符串分隔成流
- 二、流的中间操作
- 2-1 筛选、去重与切片:filter、distinct、skip、limit
- 2-2 映射:map、flatMap
- 2-3 归约:统计-计算-逻辑处理:reduce
- 2-4 排序:sorted
- 三. 流的终止操作 allMatch,noneMatch,anyMatch,findFirst,findAny,count,max,min
- 3-1 普通收集 – 收集为List
- 3-2 普通收集 – 收集流为数组(Array)
- 3-3 普通收集 – 收集为Set
- 3-4 高级收集 – 收集为Map
- 3-5 高级收集 – 分组收集
- 四. Steam拓展
- 4-1 集合与对象互转
- 4-2 集合转对象
- 4-3 Java Steam中的并发操作实例
一. 流的常用创建方法
1-1 使用Collection下的 stream() 和 parallelStream() 方法
List<String> list = new ArrayList<>();
Stream<String> stream = list.stream();
Stream<String> parallelStream = list.parallelStream();
1-2 使用Arrays 中的 stream() 方法,将数组转成流
Integer[] nums = new Integer[10];
Stream<Integer> stream = Arrays.stream(nums);
1-3 使用Stream中的静态方法:of()、iterate()、generate()
Stream<Integer> stream = Stream.of(1,2,3,4,5,6);
Stream<Integer> stream2 = Stream.iterate(0, (x) -> x + 2).limit(6);
stream2.forEach(System.out::println);
Stream<Double> stream3 = Stream.generate(Math::random).limit(2);
stream3.forEach(System.out::println);
1-4 使用 BufferedReader.lines() 方法,将每行内容转成流
BufferedReader reader = new BufferedReader(new FileReader("F:\\test_stream.txt"));
Stream<String> lineStream = reader.lines();
lineStream.forEach(System.out::println);
1-5 使用 Pattern.splitAsStream() 方法,将字符串分隔成流
Pattern pattern = Pattern.compile(",");
Stream<String> stringStream = pattern.splitAsStream("a,b,c,d");
stringStream.forEach(System.out::println);
二、流的中间操作
filter:过滤流中的某些元素
limit skip distinct sorted 都是有状态操作,这些操作只有拿到前面处理后的所有元素之后才能继续下去。
limit(n):获取前n个元素
skip(n):跳过前n元素,配合limit(n)可实现分页
distinct:通过流中元素的 hashCode() 和 equals() 去除重复元素
map:接收一个函数作为参数,该函数会被应用到每个元素上,并将其映射成一个新的元素。
flatMap:接收一个函数作为参数,将流中的每个值都换成另一个流,然后把所有流连接成一个流。
sorted():自然排序,流中元素需实现Comparable接口
sorted(Comparator com):定制排序,自定义Comparator排序器
2-1 筛选、去重与切片:filter、distinct、skip、limit
Stream<Integer> stream = Stream.of(6, 4, 6, 7, 3, 9, 8, 10, 12, 14, 14);
Stream<Integer> newStream = stream.filter(s -> s > 5)
.distinct()
.skip(2)
.limit(2);
newStream.forEach(System.out::println);
2-2 映射:map、flatMap
List<String> list = Arrays.asList("a,b,c", "1,2,3");
List<String> collect = list.stream().map(s -> s.replaceAll(",", "")).collect(Collectors.toList());
System.out.println(collect);
Stream<String> stringStream = list.stream().flatMap(s -> {
String[] split = s.split(",");
Stream<String> stream = Arrays.stream(split);
return stream;
});
System.out.println(stringStream.collect(Collectors.toList()));
2-3 归约:统计-计算-逻辑处理:reduce
List<String> memberNames = new ArrayList<>();
memberNames.add("Amitabh");
memberNames.add("Shekhar");
memberNames.add("Aman");
memberNames.add("Rahul");
memberNames.add("Shahrukh");
memberNames.add("Salman");
memberNames.add("Yana");
memberNames.add("Lokesh");
Optional<String> reduced = memberNames.stream()
.reduce((s1,s2) -> s1 + "#" + s2);
reduced.ifPresent(System.out::println);
private static void testReduce() {
System.out.println("给定个初始值,求和");
System.out.println(Stream.of(1, 2, 3, 4).reduce(100, (sum, item) -> sum + item));
System.out.println(Stream.of(1, 2, 3, 4).reduce(100, Integer::sum));
System.out.println("给定个初始值,求min");
System.out.println(Stream.of(1, 2, 3, 4).reduce(100, (min, item) -> Math.min(min, item)));
System.out.println(Stream.of(1, 2, 3, 4).reduce(100, Integer::min));
System.out.println("给定个初始值,求max");
System.out.println(Stream.of(1, 2, 3, 4).reduce(100, (max, item) -> Math.max(max, item)));
System.out.println(Stream.of(1, 2, 3, 4).reduce(100, Integer::max));
System.out.println("无初始值,求和");
System.out.println(Stream.of(1, 2, 3, 4).reduce(Integer::sum).orElse(0));
Integer sum=Stream.of(1, 2, 3, 4).reduce((x,y)->x+y).get();
System.out.println(sum);
System.out.println("无初始值,求max");
System.out.println(Stream.of(1, 2, 3, 4).reduce(Integer::max).orElse(0));
System.out.println("无初始值,求min");
System.out.println(Stream.of(1, 2, 3, 4).reduce(Integer::min).orElse(0));
}
2-4 排序:sorted
stream.sorted();
stream.sorted((x,y)->Integer.compare(x.getSortNo(),y.getSortNo()));
2-4-1 函数式接口排序
pendingPeriod.stream().sorted(Comparator.comparingInt(ReservoirPeriodResult::getId));
pendingPeriod.stream().sorted(Comparator.comparingInt(ReservoirPeriodResult::getId).reversed());
2-4-2 LocalDate 和 LocalDateTime 排序
Stream<DateModel> stream = Stream.of(new DateModel(LocalDate.of(2020, 1, 1))
, new DateModel(LocalDate.of(2021, 1, 1)), new DateModel(LocalDate.of(2022, 1, 1)));
stream.sorted(Comparator.comparing(DateModel::getLocalDate))
.forEach(System.out::println);
stream.sorted(Comparator.comparing(DateModel::getLocalDate).reversed())
.forEach(System.out::println);
三. 流的终止操作 allMatch,noneMatch,anyMatch,findFirst,findAny,count,max,min
allmatch,noneMatch,anyMatch用于对集合中对象的某一个属性值是否存在判断。
allMatch全部符合该条件返回true,
noneMatch全部不符合该断言返回true
anyMatch 任意一个元素符合该断言返回true
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
boolean allMatch = list.stream().allMatch(e -> e > 10);
boolean noneMatch = list.stream().noneMatch(e -> e > 10);
boolean anyMatch = list.stream().anyMatch(e -> e > 4);
findFirst:返回流中第一个元素
String firstMatchedName = memberNames.stream()
.filter((s) -> s.startsWith("L"))
.findFirst().get();
findAny:返回流中的任意元素
count:返回流中元素的总个数
long totalMatched = memberNames.stream()
.filter((s) -> s.startsWith("A"))
.count();
max:返回流中元素最大值
min:返回流中元素最小值
3-1 普通收集 – 收集为List
List<String> collect = stream.collect(Collectors.toList());
userVos.stream().map(e -> e.setDeptName(hashMap.get(e.getDeptId())))
.collect(Collectors.toList());
List<Integer> list = new ArrayList<Integer>();
for(int i = 1; i< 10; i++){
list.add(i);
}
Stream<Integer> stream = list.stream();
List<Integer> evenNumbersList = stream.filter(i -> i%2 == 0)
.collect(Collectors.toList());
System.out.print(evenNumbersList);
3-2 普通收集 – 收集流为数组(Array)
Stream<Integer> stream = list.stream();
Integer[] evenNumbersArr = stream.filter(i -> i%2 == 0).toArray(Integer[]::new);
3-3 普通收集 – 收集为Set
Set<String> collect = stream.collect(Collectors.toSet());
3-4 高级收集 – 收集为Map
@Data
public class Entity {
private Integer id;
private String name;
}
List<Entity> entityList = Stream.of(new Entity(1,"A"),
new Entity(2,"B"), new Entity(3,"C")).collect(Collectors.toList());
Map<Integer, String> hashMap = entityList.stream()
.collect(Collectors.toMap(Entity::getId, Entity::getName));
3-5 高级收集 – 分组收集
Map<Integer, List<XUser>> hashMap =
xUsers.stream().collect(Collectors.groupingBy(XUser::getDeptId));
Map<Integer, List<XUser>> hashMap =
xUsers.stream().collect(Collectors.groupingBy(XUser::getDeptId, Collectors.toList()));
Map<Integer, List<String>> hashMap = xUsers.stream().collect(Collectors.groupingBy(XUser::getDeptId,Collectors.mapping(XUser::getUserName,Collectors.toList())));
四. Steam拓展
4-1 集合与对象互转
public static <T, C extends Collection<T>> Collection<T> toCollection(T t) {
return toCollection(t, ArrayList::new);
}
public static <T, C extends Collection<T>> Collection<T> toCollection(T t, Supplier<C> supplier) {
return Stream.of(t).collect(Collectors.toCollection(supplier));
}
4-2 集合转对象
public static <E> E toObject(Collection<E> collection) {
Collection<E> coll = Optional.ofNullable(collection).orElseGet(ArrayList::new);
return coll.stream().findFirst().orElse(null);
}
4-3 Java Steam中的并发操作实例
List<Integer> list = new ArrayList<Integer>();
for(int i = 1; i< 10; i++){
list.add(i);
}
Stream<Integer> stream = list.parallelStream();
Integer[] evenNumbersArr = stream.filter(i -> i%2 == 0).toArray(Integer[]::new);
System.out.print(evenNumbersArr);