Stream 是用函数式编程方式在集合类上进行复杂操作的工具，其集成了Java 8中的众多新特性之一的聚合操作，开发者可以更容易地使用Lambda表达式，并且更方便地实现对集合的查找、遍历、过滤以及常见计算等。
直接上代码：
基础实体类：
练习代码：
public static void main(String[] args) {
Student stuA = new Student(1, "A", "M", 184);
Student stuB = new Student(2, "B", "G", 163);
Student stuC = new Student(3, "C", "M", 175);
Student stuD = new Student(4, "D", "G", 158);
Student stuE = new Student(5, "A", "M", 158);
List<Student> list = new ArrayList<>();
list.add(stuA);
list.add(stuB);
list.add(stuC);
list.add(stuD);
list.add(stuE);
// stream-forEach循环
System.out.println("***********stream-forEach***********");
list.stream().forEach(stu -> System.out.println("stream-forEach: " + stu.getName()));
// stream-filter过滤即执行逻辑
System.out.println("***********stream-filter count***********");
long count = list.stream().filter(stu -> stu.height > 180).count();
list.stream().filter(stu -> stu.height > 180)
.forEach(stu -> System.out.println("stream-filter: " + stu));
// Stream-toMap 为了避免key冲突情况，(key1, key2) -> key1 表示冲突时取前者
System.out.println("***********Stream-toMap 字段:对象***********");
Map<String, Student> maps = list.stream()
.collect(Collectors.toMap(Student::getName, Function.identity(), (key1, key2) -> key1));
System.out.println("key-对象" + maps);
Map<String, Object> newMaps = list.stream()
.collect(Collectors.toMap(Student::getName, Student::getHeight, (key1, key2) -> key1));
System.out.println("key-字段" + newMaps);
// Stream-distinct 去重
System.out.println("***********Stream-distinct去重 必须重写equals和hashcode方法***********");
list.stream()
.distinct()
.forEach(b -> System.out.println("Stream-distinct去重 " + b.getName()+ "," + b.getHeight()));
list.stream()
.filter(StreamUtil.distinctByKey(b -> b.getSex()))
.forEach(b -> System.out.println("Stream-distinct指定字段去重 " + b.getName()+ "," + b.getSex()));
// 过滤后得到新集合
System.out.println("***********Stream操作后获取聚合集合***********");
List<Student> newList = list.stream().filter(stu -> stu.height > 165)
.collect(Collectors.toList());
System.out.println("新集合: " + newList);
// stream-聚合操作 最大值，最小值
System.out.println("**************stream-聚合操作 最大值，最小值************");
System.out.println("sum: " + list.stream().mapToDouble(Student::getHeight).sum());
System.out.println("max: " + list.stream().mapToDouble(Student::getHeight).max().getAsDouble());
System.out.println("min: " + list.stream().mapToDouble(Student::getHeight).min().getAsDouble());
System.out.println("avg: " + list.stream().mapToDouble(Student::getHeight).average().getAsDouble());
// Stream排序
System.out.println("**************stream-聚合操作 排序************");
List<Student> collect = list.stream().filter(stu -> stu.getHeight() > 165)
.sorted((e1,e2) -> Float.compare(e1.getHeight(), e2.getHeight()))
.collect(Collectors.toList());
System.out.println("stream 排序" + collect);
}指定字段去重：
public class StreamUtil {
/**
* 指定字段去重
* @param keyExtractor
* @return
*/
static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
Map<Object,Boolean> seen = new ConcurrentHashMap<>();
return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
}
}日常练习Demo：
package com.mine.stream;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;
/**
*
* @author 柯贤铭
* @date 2019年3月22日
* @email [email protected]
*/
public class TestForStream {
public static void main(String[] args) {
List<Transaction> transactions = null;
Trader raoul = new Trader("Raoul", "Cambridge");
Trader mario = new Trader("Mario", "Milan");
Trader alan = new Trader("Alan", "Cambridge");
Trader brian = new Trader("Brian", "Cambridge");
transactions = Arrays.asList(
new Transaction(brian, 2011, 300),
new Transaction(raoul, 2012, 1000),
new Transaction(raoul, 2011, 400),
new Transaction(mario, 2012, 400),
new Transaction(mario, 2012, 710),
new Transaction(alan , 2012, 950));
// ①找出2011年发生的所有交易， 并按交易额排序（从低到高）
// 方式一：
Long begin = System.currentTimeMillis();
List<Transaction> newTr = transactions.stream().filter(tran -> tran.getYear() == 2011)
.collect(Collectors.toList());
newTr.sort(Comparator.comparing(t -> t.getValue()));
Long end = System.currentTimeMillis();
System.out.println("耗时: " + (end - begin) + " " + newTr);
// 方式二: 差距是35倍左右！
Long begin2 = System.currentTimeMillis();
List<Transaction> collect = transactions.stream().filter(tran -> tran.getYear() == 2011)
.sorted((e1,e2) -> Integer.compare(e1.getValue(), e2.getValue()))
.collect(Collectors.toList());
Long end2 = System.currentTimeMillis();
System.out.println("耗时: " + (end2 - begin2) + " " + collect);
// ②交易员都在哪些不同的城市工作过？
// 方式一:
transactions.stream()
.filter(StreamUtil.distinctByKey(tran -> tran.getTrader().getCity()))
.collect(Collectors.toList())
.forEach(t -> System.out.println(t.getTrader().getCity()));
// 方式二:
List<String> collCityTwo = transactions.stream()
.map(e -> e.getTrader().getCity())
.distinct()
.collect(Collectors.toList());
System.out.println("城市为: " + collCityTwo);
//③查找所有来自剑桥的交易员，并按姓名排序
List<Trader> collPerson = transactions.stream().filter(tran -> tran.getTrader().getCity().equals("Cambridge"))
.map(Transaction::getTrader)
.sorted((e1,e2) -> e1.getName().compareTo(e2.getName()))
.collect(Collectors.toList());
System.out.println(collPerson);
// ⑤有没有交易员是在米兰工作的？
long count = transactions.stream().filter(tran -> tran.getTrader().getCity().equals("Milan")).count();
System.out.println("是否有人在米兰工作: " + (count > 0));
// ⑥打印生活在剑桥的交易员的所有交易额总和
int sum = transactions.stream()
.filter(e -> e.getTrader().getCity().equals("Cambridge"))
.mapToInt(Transaction::getValue)
.sum();
System.out.println("总额为: " + sum);
// ⑦所有交易中，最高的交易额是多少
int max = transactions.stream()
.mapToInt(Transaction::getValue)
.max()
.getAsInt();
System.out.println("最大值是: " + max);
// ⑧找到交易额最小的交易
Transaction transaction = transactions.stream()
.min((e1,e2) -> Integer.compare(e1.getValue(), e2.getValue()))
.get();
System.out.println("最小值交易是: " + transaction);
}
}
class Trader {
private String name;
private String 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;
}
@Override
public String toString() {
return "Trader [name=" + name + ", city=" + city + "]";
}
public Trader(String name, String city) {
super();
this.name = name;
this.city = city;
}
}
class Transaction {
private Trader trader;
private int year;
private int 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;
}
@Override
public String toString() {
return "Transaction [trader=" + trader + ", year=" + year + ", value=" + value + "]";
}
public Transaction(Trader trader, int year, int value) {
super();
this.trader = trader;
this.year = year;
this.value = value;
}
}