Stream的使用
- 遍历/匹配—find/foreach/match
- 筛选—filer
- 聚合—max/min/count
- 映射—map/flatmap
- 归约—reduce
- 统计—count/averaging
- 计数:count
- 平均值:averagingInt,averagingDouble,averagingLong
- 最值:maxBy,minBy
- 求和:summingInt,summingDouble,summingLong
- 统计以上所有:summarizingInt,summarizingLong,summarizingDouble
- 分组—partitioningBy/groupingBy
- 接合—joining
- 排序—sorted
- 提取/组合:合并/去重/限制/跳过—distinct/limit/skip
import com.example.demo.entity.Person;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class StreamTestAll {
public static void main(String[] args) {
tq();
}
/**
* 遍历/匹配/
* find/foreach/match
*/
public static void test() {
List<Integer> list = Arrays.asList(1, 9, 8, 6, 7, 5);
//遍历输出符合条件的元素--简写(x-> System.err.println(x) --System.err::println)
list.stream().filter(x -> x > 6).forEach(System.err::println);
//匹配第一个
Optional<Integer> first = list.stream().filter(x -> x > 6).findFirst();
//匹配任意(适用于并行流)
Optional<Integer> any = list.stream().filter(x -> x > 6).findAny();
//是否包含符合特定条件的元素
boolean b = list.stream().anyMatch(z -> z > 6);
System.err.println("匹配第一个值" + first.get());
System.err.println("匹配任意一个值" + any.get());
System.err.println("是否存在大于6的值" + b);
}
/**
* 筛选 filer
* 按照一定的规则校验流中的元素,将符合条件的元素提取到新的流中的操作
* 1.筛选出数组中大于7的元素
*/
public static void filterOne() {
List<Integer> list = Arrays.asList(1, 8, 9, 10, 5, 6, 7);
list.stream().filter(x -> x > 7).forEach(System.err::println);
}
/**
* 筛选 filer
* 按照一定的规则校验流中的元素,将符合条件的元素提取到新的流中的操作
* 2. 筛选员工中工资高于8000的人
*/
public static void filterTwo() {
List<Person> personList = new ArrayList<>();
personList.add(new Person("Tom", 8900, 23, "male", "New York"));
personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
personList.add(new Person("Anni", 8200, 24, "female", "New York"));
personList.add(new Person("Owen", 9500, 25, "male", "New York"));
personList.add(new Person("Alisa", 7900, 26, "female", "New York"));
List<String> collect = personList.stream().filter(x -> x.getSalary() > 8000).map(Person::getName).collect(Collectors.toList());
System.err.println("薪资大于8000的人" + collect);
}
/**
* 聚合
* max/min/count
* 获取String集合中最长的元素//yellow
*/
public static void fileterThree() {
List<String> strings = Arrays.asList("apple", "yellow", "banana");
Optional<String> max = strings.stream().max(Comparator.comparing(String::length));
System.err.println("最长的元素" + max.get());
}
/**
* 聚合
* max/min/count
* 获取Integer集合中最大的元素
*/
public static void fileterFour() {
List<Integer> strings = Arrays.asList(1001, 10, 99, 5, 1000);
//自然排序
Optional<Integer> max = strings.stream().max(Integer::compareTo);
//自定义排序
Integer integer = strings.stream().max(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1 - o2;
}
}).get();
//简写.max((o1, o2) -> o1 - o2),更简写Comparator.comparingInt(o -> o)
Integer integer2 = strings.stream().max(Comparator.comparingInt(o -> o)).get();
System.err.println("最大的元素" + max.get());
System.err.println("最大的元素" + integer);
System.err.println("最大的元素" + integer2);
}
/**
* 聚合
* max/min/count
* 获取员工工资中薪资最高的人
*/
public static void fileterFive() {
List<Person> personList = new ArrayList<>();
personList.add(new Person("Tom", 8900, 23, "male", "New York"));
personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
personList.add(new Person("Anni", 8200, 24, "female", "New York"));
personList.add(new Person("Owen", 9500, 25, "male", "New York"));
personList.add(new Person("Alisa", 7900, 26, "female", "New York"));
Optional<Person> max = personList.stream().max(Comparator.comparingInt(Person::getSalary));
System.err.println(
"员工工资最高的人" + max.get()
);
}
/**
* 聚合
* max/min/count
* 计算integer集合中大于6的个数
*/
public static void fileterSix() {
List<Integer> list = Arrays.asList(9, 8, 7, 6, 78, 89);
long count = list.stream().filter(x -> x > 6).count();
System.err.println("大于6的个数" + count);
}
/**
* 映射
* map/flatmap
* 可以将一个流的元素按照一定的规则映射到另一个集合中
* map:接收一个函数作为参数,该函数会被应用到每个元素上,并将其映射成一个新的元素
* flatmap:接收一个函数作为参数,将流中的每个值都换成另一个流,然后把所有的流连接成一个流
* 例题:英文字符串数组的元素全部改为大写。整数数组每个元素+3。
*/
public static void fileterSeven() {
List<String> list = Arrays.asList("ab", "fg", "er");
List<String> collect = list.stream().map(String::toUpperCase).collect(Collectors.toList());
System.err.println("英文字符串改为大写" + collect.toString());
List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5, 6);
List<Integer> collect1 = integerList.stream().map(x -> x + 3).collect(Collectors.toList());
System.err.println("整数数组元素" + collect1.toString());
}
/**
* 将所有员工的薪资全部增加1000
*/
public static void fileterEight() {
List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Tom", 8900, 23, "male", "New York"));
personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
personList.add(new Person("Anni", 8200, 24, "female", "New York"));
personList.add(new Person("Owen", 9500, 25, "male", "New York"));
personList.add(new Person("Alisa", 7900, 26, "female", "New York"));
List<Integer> collect = personList.stream().map(x -> x.getSalary() + 1000).collect(Collectors.toList());
System.err.println("全部薪资加1000" + collect.toString());
//不改变原来员工集合的方式
List<Person> peopleOne = personList.stream().map(person -> {
Person personNew = new Person(person.getName(), 0, 0, null, null);
personNew.setSalary(person.getSalary() + 1000);
return personNew;
}).collect(Collectors.toList());
System.err.println("一次改动前" + personList.get(0).getName() + "--->" + personList.get(0).getSalary());
System.err.println("一次改动后" + peopleOne.get(0).getName() + "--->" + peopleOne.get(0).getSalary());
List<Person> personLTwo = personList.stream().map(person -> {
person.setSalary(person.getSalary() + 1000);
return person;
}).collect(Collectors.toList());
System.err.println("二次改动前" + personList.get(0).getName() + "--->" + personList.get(0).getSalary());
System.err.println("二次改动后" + personLTwo.get(0).getName() + "--->" + personLTwo.get(0).getSalary());
}
/**
* 将两个字符数组合并成一个新的数组
*/
public static void fileterNine() {
List<String> list = Arrays.asList("a,b", "1,2,3,4", "a,d");
List<String> collect = list.stream().flatMap(s -> {
String[] split = s.split(",");
Stream<String> stream = Arrays.stream(split);
return stream;
}).collect(Collectors.toList());
//[a,b, 1,2,3,4, a,d]
System.err.println("处理前的" + list);
//[a, b, 1, 2, 3, 4, a, d]
System.err.println("处理后的" + collect);
}
/**
* reduce (归约也称:缩减),就是把一个流缩减成一个值,能够实现对集合求和,求乘积等操作
* 求Integer集合的元素之和,乘积和最大值
*/
public static void reduceOne() {
List<Integer> list = Arrays.asList(1, 5, 6, 9, 8);
//求和1
Optional<Integer> sum1 = list.stream().reduce((x, y) -> x + y);
//求和2
Optional<Integer> sum2 = list.stream().reduce(Integer::sum);
//求和3
Integer sum3 = list.stream().reduce(0, Integer::sum);
//求乘积
Optional<Integer> product = list.stream().reduce((x, y) -> x * y);
//求最大值1
Optional<Integer> maxOne = list.stream().reduce((x, y) -> x > y ? x : y);
//求最大值2
//T reduce(T identity, BinaryOperator<T> accumulator);
//给定一个初始值identity,通过累加器accumulator迭代计算,得到一个同Stream中数据同类型的结果
Integer maxTwo = list.stream().reduce(1, Integer::max);
Integer maxThere = list.stream().reduce(0, Integer::max);
System.err.println("求和1:" + sum1.get() + "求和2:" + sum2.get() + "求和3:" + sum3);
System.err.println("求乘积:" + product.get());
System.err.println("求最大值1:" + maxOne.get() + "求最大值2:" + maxTwo + "bzdss:" + maxThere);
}
/**
* 求所有员工的工资之和和最高工资
*/
public static void reduceTwo() {
List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Tom", 8900, 23, "male", "New York"));
personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
personList.add(new Person("Anni", 8200, 24, "female", "New York"));
personList.add(new Person("Owen", 9500, 25, "male", "New York"));
personList.add(new Person("Alisa", 7900, 26, "female", "New York"));
//求工资之和方式1
Optional<Integer> reduce = personList.stream().map(Person::getSalary).reduce(Integer::max);
//求工资之和方式2
Integer sum3 = personList.stream().reduce(0, (sum, p) -> sum += p.getSalary(), (sum1, sum2) -> sum1 + sum2);
// 求工资之和方式3:
Integer sumSalary3 = personList.stream().reduce(0, (sum, p) -> sum += p.getSalary(), Integer::sum);
// 求最高工资方式1:
Integer maxSalary = personList.stream().reduce(0, (max, p) -> max > p.getSalary() ? max : p.getSalary(),
Integer::max);
// 求最高工资方式2:
Integer maxSalary2 = personList.stream().reduce(0, (max, p) -> max > p.getSalary() ? max : p.getSalary(),
(max1, max2) -> max1 > max2 ? max1 : max2);
System.err.println("最大值:" + reduce.get());
Optional<Integer> sum = personList.stream().map(Person::getSalary).reduce(Integer::sum);
System.err.println("sum:" + sum.get());
}
/**
* 收集,把一个收集起来,最终可以收集成一个值也可以收集成一个新的集合
* 主要依赖于java.util.stream.Collectors类内置的静态方法
*/
public static void collectOne() {
//toList,toSet,toMap
List<Integer> list = Arrays.asList(1, 3, 6, 9, 8, 5, 4, 6, 8);
//list结果[6, 8, 4, 6, 8]
List<Integer> integerList = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toList());
//set去重:结果[4, 6, 8]
Set<Integer> set = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toSet());
System.err.println(integerList);
System.err.println(set);
List<Person> pList = new ArrayList<>();
pList.add(new Person("Tom", 8900, 23, "male", "New York"));
pList.add(new Person("Jack", 7000, 25, "male", "Washington"));
pList.add(new Person("Lily", 7800, 21, "female", "Washington"));
pList.add(new Person("Anni", 8200, 24, "female", "New York"));
Map<String, Person> map = pList.stream().filter(x -> x.getSalary() > 8000).collect(Collectors.toMap(Person::getName, p -> p));
System.err.println(map);
}
/**
* 统计(count/averaging)
* 计数:count
* 平均值:averagingInt,averagingDouble,averagingLong
* 最值:maxBy,minBy
* 求和:summingInt,summingDouble,summingLong
* 统计以上所有:summarizingInt,summarizingLong,summarizingDouble
*/
public static void countOne() {
//统计员工人数,平均工资,工资总额,最高工资
List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Tom", 8900, 23, "male", "New York"));
personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
//求员工总数
Long count = personList.stream().collect(Collectors.counting());
//求平均工资
Double avgSalary = personList.stream().collect(Collectors.averagingDouble(Person::getSalary));
//求最高工资
Optional<Integer> maxSalary = personList.stream().map(Person::getSalary).collect(Collectors.maxBy(Integer::compare));
//求工资之和
Double sumSalary = personList.stream().collect(Collectors.summingDouble(Person::getSalary));
//简化版
double sum2Salary = personList.stream().mapToDouble(Person::getSalary).sum();
//一次性统计所有的信息
//结果:DoubleSummaryStatistics{count=3, sum=23700.000000, min=7000.000000, average=7900.000000, max=8900.000000}
DoubleSummaryStatistics collect = personList.stream().collect(Collectors.summarizingDouble(Person::getSalary));
System.err.println("员工总数:" + count);
System.err.println("平均工资:" + avgSalary);
System.err.println("最高工资:" + maxSalary.get());
System.err.println("工资之和:" + sumSalary);
System.err.println("工资之和2:" + sum2Salary);
System.err.println("员工工资所有统计:" + collect);
}
/**
* 分组partitioningBy/groupingBy
* 分区:将stream按条件分成两个map,比如按照员工薪资是否高于8000分为两部分
* 分组:将集合分为多个map,比如员工按照性别分组。有年级分组和多级分组
* 1.将员工按照薪资是否高于8000分为两部分。
* 2.将员工按照性别和地区分组
*/
public static void groupOne() {
List<Person> personList = new ArrayList<>();
personList.add(new Person("Tom", 8900, "male", "New York"));
personList.add(new Person("Jack", 7000, "male", "Washington"));
personList.add(new Person("Lily", 7800, "female", "Washington"));
personList.add(new Person("Anni", 8200, "female", "New York"));
personList.add(new Person("Owen", 9500, "male", "New York"));
personList.add(new Person("Alisa", 7900, "female", "New York"));
Map<Boolean, List<Person>> collect = personList.stream().collect(Collectors.partitioningBy(p -> p.getSalary() > 8000));
Map<String, List<Person>> sexCollect = personList.stream().collect(Collectors.groupingBy(Person::getSex));
Map<String, Map<String, List<Person>>> sexAndArea = personList.stream().collect(Collectors.groupingBy(Person::getSex, Collectors.groupingBy(Person::getArea)));
System.err.println("按照薪资分:" + collect.toString());
System.err.println();
System.err.println("按照性别分:" + sexCollect);
System.err.println();
System.err.println("按照性别和地区分" + sexAndArea.toString());
}
/**
* 接合(joining)
* 可以将stream中的元素用特定的连接符(没有的话直接连接),连接成一个字符串
*/
public static void groupTwo() {
List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Tom", 8900, 23, "male", "New York"));
personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
String collect = personList.stream().map(Person::getName).collect(Collectors.joining(","));
System.err.println("连接起来的name:" + collect);
List<String> strings = Arrays.asList("12", "56", "89");
String collect1 = strings.stream().collect(Collectors.joining("-"));
System.err.println("拼接后的字符串" + collect1);
}
/**
* 归约:reducing
* Collectors提供的reducing,比stream的reduce增加了自定义归约的支持
*/
public static void reducingOne() {
List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Tom", 8900, 23, "male", "New York"));
personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
//每个员工减去起征点后的薪资之和
Integer sum1 = personList.stream().collect(Collectors.reducing(0, Person::getSalary, (i, j) -> (i + j - 5000)));
//简写后的
Integer collect2 = personList.stream().map(Person::getSalary).reduce(0, (i, j) -> (i + j - 5000));
//stream的reduce
Optional<Integer> sum2 = personList.stream().map(Person::getSalary).reduce(Integer::sum);
System.err.println("扣税薪资总和" + sum1);
System.err.println("全部薪资总和" + sum2);
}
/**
* 排序sorted:中间操作
* 1.sorted() 自然排序,流中元素需实现Comparable接口
* 2.sorted(Comparator com)Comparator排序器自定义排序
* 将员工按照工资由高到低(工资一样按照年龄由大到小)
*/
public static void sortOne() {
List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Sherry", 9000, 24, "female", "New York"));
personList.add(new Person("Tom", 8900, 22, "male", "Washington"));
personList.add(new Person("Jack", 9000, 25, "male", "Washington"));
personList.add(new Person("Lily", 8800, 26, "male", "New York"));
personList.add(new Person("Alisa", 9000, 26, "female", "New York"));
//按照工资升序排序(自然排序)
List<Integer> collect = personList.stream().map(Person::getSalary).sorted().collect(Collectors.toList());
System.err.println(collect);
//按照工资升序排序(自然排序)[Lily, Tom, Sherry, Jack, Alisa]
List<String> sortOne = personList.stream().sorted(Comparator.comparing(Person::getSalary)).map(Person::getName).collect(Collectors.toList());
System.err.println("升序排序" + sortOne);
//按工资倒叙排序[Sherry, Jack, Alisa, Tom, Lily]
List<String> sortTwo = personList.stream().sorted(Comparator.comparing(Person::getSalary).reversed()).map(Person::getName).collect(Collectors.toList());
System.err.println("倒叙排序" + sortTwo);
//先按照工资在按照年龄排序[Lily, Tom, Sherry, Jack, Alisa]
List<String> sortThere = personList.stream().sorted(Comparator.comparing(Person::getSalary).thenComparing(Person::getAge)).map(Person::getName).collect(Collectors.toList());
System.err.println("先按照工资在按照年龄:" + sortThere);
//先按工资,在按年龄自定义排序(降序)[Alisa, Jack, Sherry, Tom, Lily]
List<String> sortFour = personList.stream().sorted(Comparator.comparing(Person::getSalary).thenComparing(Person::getAge).reversed()).map(Person::getName).collect(Collectors.toList());
System.err.println("先按照工资在按照年龄降序" + sortFour);
}
/**
* 提取/组合
* 流也可以进行合并,去重,限制,跳过等
*/
public static void tq() {
String[] arr1 = {"a", "b", "c", "d"};
String[] arr2 = {"d", "e", "f", "g"};
Stream<String> stream1 = Stream.of(arr1);
Stream<String> stream2 = Stream.of(arr2);
//concat:合并两个流,distinct:去重
List<String> distinct = Stream.concat(stream1, stream2).distinct().collect(Collectors.toList());
System.err.println("合并并去重:" + distinct);
//限制从流中获取前n个数据
List<Integer> limit = Stream.iterate(1, x -> x + 2).limit(10).collect(Collectors.toList());
System.err.println("截取数据" + limit);
//skip 跳过前几条数据
List<Integer> skip = Stream.iterate(1, x -> x + 2).skip(1).limit(5).collect(Collectors.toList());
System.err.println("跳过数据" + skip);
}
}