# Stream 流
– Stream流是一种流式接口,是jdk8出现的特性。
– Stream流对于集合做聚合操作。
– Stream流中的接口都是函数是接口,都可以使用lambda表达式。
## 获取流的方式
– 集合.Stream
“`java
import java.util.Arrays;
import java.util.ListIterator;
import java.util.stream.Stream;
public static void main(String[] args) {
// 创建一个list
List
//获取流的方式一
Stream
List
List
List
Stream
Stream
Stream
}
“`
– 合并流Stream.concat
“`java
public static void main(String[] args) {
// 获取流的方式二
Stream
Stream
Stream
}
“`
## 常用方法
– distinct() 去重,把流中重复的元素去重
– sorted() 排序
– limit(n) 获取前n个元素
– collect() 把流转换成对应的集合
– flatMap() 合并流
– filter() 过滤
– map()
– peek() 对集合中的每一个对象进行处理
### 案例一 :对指定的集合数据进行去重,然后降序排列,并获取前3个最大值
方式一:
“`java
import java.util.ArrayList;
import java.util.Collection;
public static void main(String[] args) {
List
//向集合中添加数据
Collection.addAll(list, 1, 3, 5, 1, 6, 8, 9, 3, 2, 6, 7, 5, 11, 66, 4, 88, 7);
//将流转换为集合
List
System.out.println(collect);
}
“`
方法二:
“`java
import java.util.Collections;
import java.util.Comparator;
import java.util.stream.Stream;
public static void main(String[] args) {
List
// 向集合中添加数据
Collections.addAll(list, 1, 3, 5, 1, 6, 8, 9, 3, 2, 6, 7, 5, 11, 66, 4, 88, 7);
}
public static void method() {
//获取流
Stream
//去重
Stream
//降序
// Stream
// @Override
// public int compare(Integer o1, Integer o2) {
// return o2 – o1;
// }
// });
//降序 lambda
Stream
//获取前三个值
List
System.out.println(collect);
}
“`
### 案例二:统计多个集合中最大最小值,平均值,和。排序去重后获取结果。
“`java
import java.util.Comparator;
import java.util.IntSummaryStatistics;
import java.util.List;
import java.util.function.ToIntFunction;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public static void main(String[] args) {
//定义三个集合
List
List
List
//合并到一个stream流中
//方式一 使用 Stream.concat 递归地合并多个 Stream
Stream
//方式二 使用匿名内部类与flatMap()合并多个流
Stream
//方式三 使用 flatMap 和 Lambda 表达式合并多个流
Stream
//方式四 使用 flatMap 和方法引用合并多个流
Stream
// 合并多个列表,去重,按降序排序,收集结果
List
System.out.println(collect);
// 计算统计信息
//使用匿名内部类计算统计信息
IntSummaryStatistics intSummaryStatistics = collect.stream().mapToInt(new ToIntFunction
@Override
public int applyAsInt(Integer value) {
return value.intValue();
}
}).summaryStatistics();
//使用Lambda表达式
collect.stream().mapToInt(v -> v.intValue());
//使用方法引用计算统计信息
IntSummaryStatistics intSummaryStatistics1 = collect.stream().mapToInt(Integer::intValue).summaryStatistics();
// 输出信息
// 平均值
System.out.println(intSummaryStatistics.getAverage());
// 最大值
System.out.println(intSummaryStatistics.getMax());
// 最小值
System.out.println(intSummaryStatistics.getMin());
// 和
System.out.println(intSummaryStatistics.getSum());
}
“`
### 案例三:统计集合中名字带o的,分数score > 40的人,根据成绩进行降序排序,根据id进行升序排序
“`java
import java.util.ArrayList;
import java.util.Comparator;
import java.util.stream.Collectors;
class Person {
public class Person {
private int id;
private String name;
private int score;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public Person(int id, String name, int score) {
this.id = id;
this.name = name;
this.score = score;
}
@Override
public String toString() {
return “Person{” +
“id=” + id +
“, name='” + name + ‘\” +
“, score=” + score +
‘}’;
}
}
}
public static void main(String[] args) {
// 统计集合中名字带o的,分数score > 40的人,根据成绩进行降序排序,根据id进行升序排序
List
new Person(1, “james”, 8),
new Person(3, “durant”, 45),
new Person(4, “curry”, 40),
new Person(5, “jordan”, 81),
new Person(2, “kobe”, 81),
new Person(6, “jokic”, 90),
new Person(7, “westbrook”, 39)
);
// 返回false的数据就会被过滤掉
// persons.stream().filter(new Predicate
// @Override
// public boolean test(Person person) {
// return person.getName().contains(“o”) && person.getScore() > 40;
// }
// });
List
.filter(person.getScore() > 40)
.sorted(Comparator(Person::getId))
.collect(Collectors.toList());
people.forEach(System.out::println);
}
public static void main(String[] args) {
List
// 传统方式 增强for循环
for (Person person : persons) {
if (person.getName().contains(“o”) && person.getScore() > 40) {
datalist.add(person);
}
}
//重写compare方法
// datalist.sort(new Comparator
// @Override
// public int compare(Person o1,Person o2){
// return o2.getScore() – o1.getScore;
// }
// });
//lambda表达式
// datalist.sort((o1,o2)->o2.getScore()-o1.getScore());
datalist.sort(Comparator.comparing(Person::getScore).reversed().thenComparing(Person::getId));
}
“`
### 案例四:把集合中的名称全部转换成大写
“`java
public static void main(String[] args) {
List
new Person(1, “james”, 8),
new Person(3, “durant”, 45),
new Person(4, “curry”, 40),
new Person(5, “jordan”, 81),
new Person(2, “kobe”, 81),
new Person(6, “jokic”, 90),
new Person(7, “westbrook”, 39)
);
// 传统方式
// List
// for (Person person : persons) {
// person.setName(person.getName().toUpperCase());
// list.add(person);
// }
// System.out.println(list);
// 流式调用
// map 对于集合中的每一个元素进行处理
// 泛型一:apply方法的参数类型
// 泛型二:返回值类型
// List
// @Override
// public Person apply(Person person) {
// person.setName(person.getName().toUpperCase());
// return person;
// }
// }).collect(Collectors.toList());
// lambda表达式
// List
// map(person -> new Person(person.getId(), person.getName().toUpperCase(), person.getScore())).
// collect(Collectors.toList());
// List
// person.setName(person.getName().toUpperCase());
// return person;
// }).collect(Collectors.toList());
// collect.forEach(System.out::println);
// 求结果中名字带u的人
List
filter(person -> person.getName().contains(“u”)).
map(person -> {
person.setName(person.getName().toUpperCase());
return person;
}).collect(Collectors.toList());
System.out.println(personList);
}
“`
### 案例五:给每个人的分数都加10分
“`java
public static void main(String[] args) {
List
new Person(1, “james”, 8),
new Person(3, “durant”, 45),
new Person(4, “curry”, 40),
new Person(5, “jordan”, 81),
new Person(2, “kobe”, 81),
new Person(6, “jokic”, 90),
new Person(7, “westbrook”, 39)
);
// List
// map(person -> {
// person.setScore(per son.getScore() + 10);
// return person;
// }).collect(Collectors.toList());
// System.out.println(collect);
// 匿名内部类
// List
// @Override
// public void accept(Person person) {
// person.setScore(person.getScore() + 10);
// }
// }).collect(Collectors.toList());
// lambda表达式
List
System.out.println(collect);
}
“`