1. foreach 遍历
// void forEach(Consumer<? super T> action);
personList.stream()
.forEach(person -> System.out.println("person = " + person));
2. count 统计流中元素个数
//long count();
long count = personList.stream()
.count();
System.out.println("count = " + count);
3. findFirst 查找第一个
// Optional<T> findFirst();
// 找出年龄大于18的第一个人
Optional<Person> personFirst = personList.stream()
.filter(person -> person.getAge() > 18)
.sorted(Comparator.comparing(Person::getAge))
.findFirst();
System.out.println("personFirst.get() = " + personFirst.get());
4. findAny 随机查找一个
// Optional<T> findAny();
// 提供findAny方法是为了更好的利用并行流
// 找出年龄大于60的任意一个人
Optional<Person> any = personList.parallelStream()
.filter(person -> person.getAge() > 60)
.findAny();
// 如果any不为空，则执行括号内的语句
any.ifPresent(person -> System.out.println("person = " + person));
// 判断any是不是空
if (any.isPresent()){
System.out.println("any.get() = " + any.get());
}
5. reduce 将流中的元素组合
// Optional<T> reduce(BinaryOperator<T> accumulator);
// T reduce(T identity, BinaryOperator<T> accumulator);
// reduce接受两个参数，一个初始值这里是0，一个 BinaryOperatoraccumulator，来将两个元素结合起来产生一个新值，另外reduce方法还有一个没有初始化值的重载方法。
// 求和
Optional<Integer> reduce = personList.stream()
.map(person -> person.getAge())
.reduce((age, age2) -> age + age2);
Optional<Integer> reduce1 = personList.stream()
.map(person -> person.getAge())
.reduce(Integer::sum);
Integer reduce2 = personList.stream()
.map(Person::getAge)
.reduce(0, Integer::sum);
// 求最值
// 找出年龄最大的职员，如果年龄相同，则找出工资最高的
Optional<Person> reduce3 = personList.stream()
.reduce((person, person2) -> {
int compareFlag = person.getAge().compareTo(person2.getAge());
if (compareFlag == 0){
return person.getSalary().compareTo(person2.getSalary())>0?person:person2;
}
return compareFlag > 0 ? person : person2;
});
// 求平均
// 计算平均薪资
long count1 = personList.stream().count();
double sum = personList.stream()
.mapToDouble(Person::getSalary)
.reduce(0.0, Double::sum);
System.out.println(String.format("平均薪资为：%1.2f",sum/count1));
6. min/max 获取最小最大值
// 方法参数为 Comparator<?superT>comparator
// 找出符合判断条件的最大最小数据
Optional<Person> personMax = personList.stream()
.max((o1, o2) -> {
if (o1.getAge().compareTo(o2.getAge()) == 0) {
return o1.getSalary().compareTo(o2.getSalary());
}
return o1.getAge().compareTo(o2.getAge());
});
if (personMax.isPresent()){
System.out.println("personMax.get() = " + personMax.get());
}
Optional<Person> personMin = personList.stream()
.min((o1, o2) -> {
if (o1.getAge().compareTo(o2.getAge()) == 0) {
return o1.getSalary().compareTo(o2.getSalary());
}
return o1.getAge().compareTo(o2.getAge());
});
if (personMin.isPresent()){
System.out.println("personMin.get() = " + personMin.get());
}
// 输出
// person.get() = StreamTest.Person(name=test08, age=38, salary=4.8)
// person.get() = StreamTest.Person(name=test03, age=16, salary=0.5)
7. sum / summingxxx 求和
int sumAge = personList.stream()
.mapToInt(Person::getAge)
.sum();
System.out.println("sumAge = " + sumAge);
// 如果数据类型为double、long，则通过summingDouble、summingLong方法进行求和。
Double sumSalary = personList.stream()
.collect(Collectors.summingDouble(Person::getSalary));
System.out.println("sumSalary = " + sumSalary);
// 输出
// sumAge = 262
// sumSalary = 18.8
8. averagingxxx 求平均值
Double averSalary = personList.stream()
.collect(Collectors.averagingDouble(Person::getSalary));
System.out.println(String.format("averSalary = %3.2f",averSalary));
// 输出
// averSalary = 1.88
9. summarizingxxx 同时求总和、平均值、最大值、最小值
DoubleSummaryStatistics summaryStatistics = personList.stream()
.collect(Collectors.summarizingDouble(Person::getSalary));
System.out.println("平均值：summaryStatistics.getAverage() = " + summaryStatistics.getAverage());
System.out.println("最大值：summaryStatistics.getMax() = " + summaryStatistics.getMax());
System.out.println("最小值：summaryStatistics.getMin() = " + summaryStatistics.getMin());
System.out.println("总和：summaryStatistics.getSum() = " + summaryStatistics.getSum());
System.out.println("计数：summaryStatistics.getCount() = " + summaryStatistics.getCount());
// 输出
//平均值：summaryStatistics.getAverage() = 1.8800000000000001
//最大值：summaryStatistics.getMax() = 4.8
//最小值：summaryStatistics.getMin() = 0.5
//总和：summaryStatistics.getSum() = 18.8
//计数：summaryStatistics.getCount() = 10
10. collect 返回集合
Set<Double> salarySet = personList.stream()
.map(Person::getSalary)
.collect(Collectors.toSet());
System.out.println("salarySet = " + salarySet);
List<Person> personList18 = personList.stream()
.filter(person -> person.getAge() > 18)
.collect(Collectors.toList());
System.out.println("personList18 = " + personList18);
// (a,b)->b，如果重复选择后者
Map<String, Person> personMap = personList.stream()
.collect(Collectors.toMap(Person::getName, Function.identity(),(a,b)->b));
System.out.println("personMap = " + personMap);
// 根据某个参数对列表进行去重
List<ttt> list = new ArrayList<ttt>() {{
add(new ttt().setName("1").setAge(120));
add(new ttt().setName("2").setAge(180));
add(new ttt().setName("2").setAge(18));
add(new ttt().setName("1").setAge(12));
}};
System.out.println("list = " + list);
System.out.println("***********************************************");
ArrayList<ttt> arrayList = list.stream().collect(
Collectors.collectingAndThen(
Collectors.toCollection(
() -> new TreeSet<>(Comparator.comparing(ttt::getName))
), ArrayList::new
)
);
System.out.println("arrayList = " + arrayList);
System.out.println("=================");
11. joining 拼接流中的元素
// 去除重复的姓名
String join = personList.stream()
.map(Person::getName)
.distinct()
.collect(Collectors.joining("-"));
System.out.println("join = " + join);
// 输出：join = test01-test02-test03-test04-test05-test06-test07-test08
12. groupingBy 分组
// 根据name分组
Map<String, List<Person>> groupName = personList.stream()
.collect(Collectors.groupingBy(Person::getName));
System.out.println("groupName = " + groupName);
// 根据name和age分组
Map<String, List<Person>> groupNameAge= personList.stream()
.collect(Collectors.groupingBy(person->person.getName()+"-"+person.getAge()));
System.out.println("groupNameAge = " + groupNameAge);
// 将成年的按照年龄分组，未成年的分成一组
Map<String, List<Person>> groupAge = personList.stream()
.collect(Collectors.groupingBy(person -> {
if (person.getAge() < 18) {
return "未成年";
} else {
return person.getAge() + "岁";
}
}));
System.out.println("groupAge = " + groupAge);
13. partitioningBy 分区
// 分区是特殊的分组，它分类依据是true和false，所以返回的结果最多可以分为两组。
Map<Boolean, List<Person>> listMap = personList.stream()
.collect(Collectors.partitioningBy(person -> person.getAge() > 18));
System.out.println("listMap = " + listMap);
// 将person划分为是否大于18
14. allMatch/anyMatch/noneMatch 匹配
// 是否全部person的age都大于18
boolean matchAll = personList.stream()
.allMatch(person -> person.getAge() > 18);
System.out.println("matchAll = " + matchAll);
// 是否存在person的age大于18
boolean anyMatch = personList.stream()
.anyMatch(person -> person.getAge() > 18);
System.out.println("anyMatch = " + anyMatch);
// 是否不存在person的age大于100
boolean noneMatch = personList.stream()
.noneMatch(person -> person.getAge() > 100);
System.out.println("noneMatch = " + noneMatch);
// 输出
// matchAll = false
// anyMatch = true
// noneMatch = true
