Stream API(java.util.stream.*)
Stream 是 Java8 中处理集合的关键抽象概念,
它可以指定你希望对集合进行的操作,
可以执行非常复杂的查找、过滤和映射数据等操作。
使用Stream API 对集合数据进行操作,就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。
简而言之,Stream API 提供了一种高效且易于使用的处理数据的方式。
-
流(Stream) 到底是什么呢?
是数据渠道,用于操作数据源(集合、数组等)所生成的元素序列。
集合讲的是数据,流讲的是计算!
注意:
①Stream 自己不会存储元素。
②Stream 不会改变源对象。相反,他们会返回一个持有结果的新Stream。
③Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。 -
Stream 的操作三个步骤
1.创建 Stream
一个数据源(如:集合、数组),获取一个流
2.中间操作
一个中间操作链,对数据源的数据进行处理
3.终止操作(终端操作)
一个终止操作,执行中间操作链,并产生结果
创建 Stream流
- Java8 中的 Collection 接口被扩展,提供了
两个获取流的方法:- default Stream stream() : 返回一个顺序流
- default Stream parallelStream() : 返回一个并行流
- Java8 中的 Arrays 的静态方法 stream() 可以获取数组流:
- static Stream stream(T[] array): 返回一个流
重载形式,能够处理对应基本类型的数组: - public static IntStream stream(int[] array)
- public static LongStream stream(long[] array)
- public static DoubleStream stream(double[] array)
- static Stream stream(T[] array): 返回一个流
- 由值创建流,可以使用静态方法 Stream.of(), 通过显示值创建一个流。它可以接收任意数量的参数。
- public static Stream of(T… values) : 返回一个流 (参数可为:数组、集合、数字)
- 由函数创建流:创建无限流可以使用静态方法 Stream.iterate()和Stream.generate(), 创建无限流。
- public static Stream iterate(final T seed, finalUnaryOperator f) 迭代
- public static Stream generate(Supplier s) 生成
中间操作
多个中间操作可以连接起来形成一个流水线,除非流水线上触发终止操作,否则中间操作不会执行任何的处理!
而在终止操作时一次性全部处理,称为“惰性求值”。
- 筛选与切片
- filter(Predicate p) 过滤 接收 Lambda , 从流中排除某些元素。
- distinct() 去重,通过流所生成元素的 hashCode() 和 equals() 去除重复元素
- limit(long maxSize) 截断流,使其元素不超过给定数量。
- skip(long n) 跳过元素,返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个,则返回一个空流。与 limit(n) 互补
- 映射
- map(Function f) 接收一个函数作为参数,该函数会被应用到每个元素上,并将其映射成一个新的元素。
- flatMap(Function f) 接收一个函数作为参数,将流中的每个值都换成另一个流,然后把所有流连接成一个流.
- mapToDouble(ToDoubleFunction f) 接收一个函数作为参数,该函数会被应用到每个元素上,产生一个新的 DoubleStream。
- mapToInt(ToIntFunction f) 接收一个函数作为参数,该函数会被应用到每个元素上,产生一个新的 IntStream。
- mapToLong(ToLongFunction f) 接收一个函数作为参数,该函数会被应用到每个元素上,产生一个新的 LongStream。
- 排序
- sorted() 产生一个新流,其中按自然顺序排序 元素实现Compareble接口
- sorted(Comparator comp) 产生一个新流,其中按比较器顺序排序 传入一个比较
终止操作(终端操作)
终端操作会从流的流水线生成结果。其结果可以是任何不是流的值,例如:List、Integer,甚至是 void 。
- 查找与匹配
- allMatch(Predicate p) 检查是否匹配所有元素 比如判断 所有员工的年龄都是17岁 如果有一个不是,就返回false
- anyMatch(Predicate p) 检查是否至少匹配一个元素 比如判断是否有姓王的员工,如果至少有一个就返回true
- noneMatch(Predicate p) 检查是否没有匹配所有元素 比如判断所有员工的工资都是否都是高于3000 如果有一个人低于3000 就返回false
- findFirst() 返回第一个元素 比如获取工资最高的人 或者 获取工资最高的值是
- findAny() 返回当前流中的任意元素 比如随便获取一个姓王的员工
- count() 返回流中元素总数
- max(Comparator c) 返回流中最大值 比如:获取最大年龄值
- min(Comparator c) 返回流中最小值 比如:获取最小年龄的值
- forEach(Consumer c) 内部迭代(使用 Collection 接口需要用户去做迭代,称为外部迭代。相反,Stream API 使用内部迭代——它帮你把迭代做了)
- 归约
- reduce(T iden, BinaryOperator b) 参1 是起始值, 参2 二元运算 可以将流中元素反复结合起来,得到一个值。返回 T 比如: 求集合中元素的累加总和
- reduce(BinaryOperator b) 这个方法没有起始值 可以将流中元素反复结合起来,得到一个值。返回 Optional , 比如你可以算所有员工工资的总和
备注:map 和 reduce 的连接通常称为 map-reduce 模式,因 Google 用它来进行网络搜索而出名。
- 收集
- collect(Collector c) 将流转换为其他形式。接收一个 Collector接口的实现,用于给Stream中元素做汇总的方法
Collector 接口中方法的实现决定了如何对流执行收集操作(如收集到 List、Set、Map)。
但是 Collectors 实用类提供了很多静态方法,可以方便地创建常见收集器实例,具体方法与实例如下
- collect(Collector c) 将流转换为其他形式。接收一个 Collector接口的实现,用于给Stream中元素做汇总的方法
- Collectors 中的方法
- List<?> toList() 把流中元素收集到List 比如把所有员工的名字通过map()方法提取出来之后,在放到List集合中去
例子:List emps= list.stream().map(提取名字).collect(Collectors.toList()); - Set<?> toSet() 把流中元素收集到Set 比如把所有员工的名字通过map()方法提取出来之后,在放到Set集合中去
例子:Set emps= list.stream().collect(Collectors.toSet()); - Collection<?> toCollection() 把流中元素收集到创建的集合 比如把所有员工的名字通过map()方法提取出来之后,在放到自己指定的集合中去
例子:Collectionemps=list.stream().map(提取名字).collect(Collectors.toCollection(ArrayList::new)); - Long counting() 计算流中元素的个数
例子:long count = list.stream().collect(Collectors.counting()); - Integer summingInt() 对流中元素的整数属性求和
例子:inttotal=list.stream().collect(Collectors.summingInt(Employee::getSalary)); - Double averagingInt() 计算流中元素Integer属性的平均值
例子:doubleavg= list.stream().collect(Collectors.averagingInt(Employee::getSalary)); - IntSummaryStatistics summarizingInt() 收集流中Integer属性的统计值。
例子:DoubleSummaryStatistics dss= list.stream().collect(Collectors.summarizingDouble(Employee::getSalary));
从DoubleSummaryStatistics 中可以获取最大值,平均值等
double average = dss.getAverage();
long count = dss.getCount();
double max = dss.getMax(); - String joining() 连接流中每个字符串 比如把所有人的名字提取出来,在通过"-“横杠拼接起来
例子:String str= list.stream().map(Employee::getName).collect(Collectors.joining(”-")); - Optional maxBy() 根据比较器选择最大值 比如求最大工资
例子:Optionalmax= list.stream().collect(Collectors.maxBy(comparingInt(Employee::getSalary))); - Optional minBy() 根据比较器选择最小值 比如求最小工资
例子:Optional min = list.stream().collect(Collectors.minBy(comparingInt(Employee::getSalary))); - 归约产生的类型 reducing() 从一个作为累加器的初始值开始,利用BinaryOperator与流中元素逐个结合,从而归约成单个值
例子:inttotal=list.stream().collect(Collectors.reducing(0, Employee::getSalar, Integer::sum)); - 转换函数返回的类型 collectingAndThen() 包裹另一个收集器,对其结果转换函数
例子:inthow= list.stream().collect(Collectors.collectingAndThen(Collectors.toList(), List::size)); - Map<K, List> groupingBy() 根据某属性值对流分组,属性为K,结果为V 比如按照 状态分组
例子:Map<Emp.Status, List> map= list.stream().collect(Collectors.groupingBy(Employee::getStatus)); - Map<Boolean, List> partitioningBy() 根据true或false进行分区 比如 工资大于等于6000的一个区,小于6000的一个区
例子:Map<Boolean,List>vd= list.stream().collect(Collectors.partitioningBy(Employee::getSalary));
- List<?> toList() 把流中元素收集到List 比如把所有员工的名字通过map()方法提取出来之后,在放到List集合中去
相关方法代码实现
1. 找出2011年发生的所有交易, 并按交易额排序(从低到高)
2. 交易员都在哪些不同的城市工作过?
3. 查找所有来自剑桥的交易员,并按姓名排序
4. 返回所有交易员的姓名字符串,按字母顺序排序
5. 有没有交易员是在米兰工作的?
6. 打印生活在剑桥的交易员的所有交易额
7. 所有交易中,最高的交易额是多少
8. 找到交易额最小的交易
功能代码实现:
Trader类实现:
public class Trader {
private String name; //交易员的姓名
private String city; //交易员工作的城市
public Trader(String name, String city) {
this.name = name;
this.city = city;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getCity() {
return city;
}
public void setCity(String city) {
this.city = city;
}
}
交易类实现
public class Transaction {
private Trader trader; //交易员
private int year; //年份
private int value; //交易额
public Transaction(Trader trader, int year, int value) {
this.trader = trader;
this.year = year;
this.value = value;
}
public Trader getTrader() {
return trader;
}
public void setTrader(Trader trader) {
this.trader = trader;
}
public int getYear() {
return year;
}
public void setYear(int year) {
this.year = year;
}
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
}
功能类实现:
public class test {
public static void main(String[] args) {
Trader raoul = new Trader("Raoul", "Cambridge");
Trader mario = new Trader("Mario", "Milan");
Trader alan = new Trader("Alan", "Cambridge");
Trader brian = new Trader("Brian", "Cambridge");
List<Transaction> transactions = Arrays.asList(
new Transaction(brian, 2011, 300),
new Transaction(raoul, 2012, 1000),
new Transaction(raoul, 2011, 400),
new Transaction(mario, 2012, 710),
new Transaction(mario, 2012, 700),
new Transaction(alan, 2012, 950)
);
Stream<Transaction> stream = transactions.stream();
//1. 找出2011年发生的所有交易,并按交易额排序(从低到高)
Stream<Transaction> sorted = stream.filter(transaction -> transaction.getYear() == 2011).sorted((o1, o2) -> o1.getValue() - o2.getValue());
sorted.forEach(transaction -> {
Trader trader = transaction.getTrader();
String name = trader.getName();
String city = trader.getCity();
int year = transaction.getYear();
int value = transaction.getValue();
System.out.println("姓名:"+name+"\t"+"城市"+city+"\t"+"年份:"+"\t"+year+"\t"+"交易额:"+value);
});
//2. 交易员都在哪些不同的城市工作过?
Stream<Trader> traderStream = stream.distinct().map(transaction -> transaction.getTrader());
Map<String, List<Trader>> collect = traderStream.collect(Collectors.groupingBy(trader -> {
String c = trader.getName();
return c;
}));
Set<String> strings = collect.keySet();
for (String string : strings) {
System.out.println("姓名:" + string);
List<Trader> traders = collect.get(string);
for (int i = 0; i < traders.size(); i++) {
for (int i1 = 0; i1 < traders.size(); i1++) {
if(traders.get(i).getCity().equals(traders.get(i1).getCity())){
System.out.println("\t\t"+traders.get(i).getCity());
traders.remove(i1);
}
}
}
}
//3. 查找所有来自剑桥的交易员,并按姓名排序
Stream<String> cambridge = stream.distinct().filter(transaction -> {
//transaction.getTrader().getCity().equals("Cambridge")
return transaction.getTrader().getCity().equals("Cambridge");
}).map(transaction -> transaction.getTrader().getName()).distinct().sorted((o1, o2) -> o1.compareTo(o2));
cambridge.forEach(System.out::println);
//4. 返回所有交易员的姓名字符串,按字母顺序排序
//将值装进List集合中
List<String> collect1 = stream.map(transaction -> transaction.getTrader().getName()).distinct().collect(Collectors.toList());
//调用Collections中的sort方法,进行字母顺序排序
Collections.sort(collect1);
System.out.println(collect1);
//5. 有没有交易员是在米兰工作的?
Stream<Transaction> milan = stream.filter(transaction -> transaction.getTrader().getCity().equals("Milan")).distinct();
milan.forEach(transaction -> {
Trader trader = transaction.getTrader();
String name = trader.getName();
String city = trader.getCity();
int year = transaction.getYear();
int value = transaction.getValue();
System.out.println("姓名:"+name+"\t"+"城市"+city+"\t"+"年份:"+"\t"+year+"\t"+"交易额:"+value);
});
//6. 打印生活在剑桥的交易员的所有交易额
Map<String, List<Transaction>> cambridge1 = stream.filter(transaction -> transaction.getTrader().getCity().equals("Cambridge")).collect(Collectors.groupingBy(transaction -> transaction.getTrader().getName()));
Set<Map.Entry<String, List<Transaction>>> entries = cambridge1.entrySet();
for (Map.Entry<String, List<Transaction>> entry : entries) {
String key = entry.getKey();
System.out.println("姓名:"+key);
List<Transaction> value = entry.getValue();
for (Transaction transaction : value) {
System.out.println("\t\t"+transaction.getValue());
}
}
//7. 所有交易中,最高的交易额是多少
DoubleSummaryStatistics collect12 = stream.map(transaction -> transaction.getValue()).collect(Collectors.summarizingDouble(value -> value));
double max = collect12.getMax();
System.out.println(max);
//8. 找到交易额最小的交易
Optional<Transaction> min = stream.min((o1, o2) -> o1.getValue() - o2.getValue());
Transaction transaction = min.get();
Trader trader = transaction.getTrader();
String name = trader.getName();
String city = trader.getCity();
int year = transaction.getYear();
int value = transaction.getValue();
System.out.println("姓名:"+name+"\t"+"城市:"+city+"\t"+"年份:"+"\t"+year+"\t"+"交易额:"+value);
}
}
给定一个数字列表,如何返回一个由每个数的平方构成的列表呢?,给定【1,2,3,4,5】, 应该返回【1,4,9,16,25】。
代码实现;
public class test {
public static void main(String[] args) {
// 作业1: 给定一个数字列表,如何返回一个由每个数的平方构成的列表呢?,给定【1,2,3,4,5】, 应该返回【1,4,9,16,25】。
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6); //获得列表
Stream<Integer> stream = list.stream(); //获得Stream流
Stream<Integer> doubleStream = stream.map(integer -> {
return integer*integer;
// return Math.pow(integer, 2); //math类的pow方法,获取一个数的平方
});
doubleStream.forEach(System.out::println);
}
}
怎样用 map() 和 reduce() 方法数一数流中有多少个Employee呢?
代码实现;
Employee类实现:
public class Employee {
private int id;
private String name;
private int age;
private double salary;
private Status status;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public Employee(String name, int age, double salary) {
this.name = name;
this.age = age;
this.salary = salary;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public Status getStatus() {
return status;
}
public void setStatus(Status status) {
this.status = status;
}
public enum Status {
FREE, //空闲
BUSY, //繁忙
VOCATION;//休假
}
}
测试类实现:
public class test2 {
public static void main(String[] args) {
//怎样用 map() 和 reduce() 方法数一数流中有多少个Employee呢?
List<Employee> emps = Arrays.asList(
new Employee("李四", 59, 6666.66),
new Employee("张三", 18, 9999.99),
new Employee("王五", 28, 3333.33),
new Employee("赵六", 8, 7777.77),
new Employee("赵六", 8, 7777.77),
new Employee("赵六", 8, 7777.77),
new Employee("田七", 38, 5555.55)
);
Stream<Employee> stream = emps.stream();
Integer reduce = stream.map(employee -> employee.getAge()).reduce(0, (integer, integer2) -> {
if (integer==0){
Integer i=integer2 / integer2;
return i;
}else{
Integer i1= integer;
Integer i2=integer2 / integer2;
Integer i = i1+i2;
return i;
}
});
System.out.println(reduce);
}
}