1、前言：
使用java8的lambda表达式和流处理方式可以极大的简化java代码，编写出优雅的java代码。
2、基础
2.1、Lambda表达式
2.1.1、Lambda表达式理解为，简洁地表示可传递的匿名函数的一种方式。它没有名称，但它有参数列表、函数主体、返回类型，可能还有一个可以抛出的异常列表。
2.1.2、Lambda表达式有三个部分，参数列表、箭头、Lambda主体。
基本语法是：(parameters) -> expression
或（请注意语句的花括号） (parameters) -> { statements; }
2.2、流
2.2.1、流是Java API的新成员，它允许你以声明性方式处理数据集合（通过查询语句来表达，而不是临时编写一个实现）。就现在来说，你可以把它们看成遍历数据集的高级迭代器
2.2.2、流与集合
粗略地说，集合与流之间的差异就在于什么时候进行计算。
集合是一个内存中的数据结构，它包含数据结构中目前所有的值——集合中的每个元素都得先算出来才能添加到集合中。（你可以往集合里加东西或者删东西，但是不管什么时候，集合中的每个元素都是放在内存里的，元素都得先算出来才能成为集合的一部分。）
相比之下，流则是在概念上固定的数据结构（你不能添加或删除元素），其元素则是按需计算的。
2.2.2.1 流只能遍历一次。集合可以遍历多次。
2.2.2.2 流使用内部迭代。它帮你把迭代做了，还把得到的流值存在了某个地方，你只要给出一个函数说要干什么就可以。
集合需要用户做迭代，称为外部迭代。（foreach/iterator）
2.2.3、流操作
2.2.3.1、中间操作：
中间操作会返回另一个流，合并起来，在终端操作时一次性全部处理。
例如：filter、map、limit、distinct、
2.2.3.2、终端操作：
终端操作会从流的流水线生成结果（非流的值）。例如：count、forEach、collect
2.2.3.3、使用流
流的使用一般包括三件事：
一个数据源（如集合）来执行一个查询；
一个中间操作链，形成一条流的流水线；
一个终端操作，执行流水线，并能生成结果
3、代码实例
3.1、找出2011年发生的所有交易，并按交易额排序。
Java8以前写法：
//定义临时变量
List<Transaction> transactionTempList = new ArrayList<Transaction>();
//先过滤出2011年份发生的交易，存入临时变量中
for (Transaction transaction : transactionList) {
if(transaction.getTradTime().equals("2011")){
transactionTempList.add(transaction);
}
}
//按交易额排序，实现Comparator接口
Collections.sort(transactionTempList, new Comparator<Transaction>() {
@Override
public int compare(Transaction o1, Transaction o2) {
return String.valueOf((o1.getTranMoney())).compareTo(String.valueOf((o2.getTranMoney())));
}
});
//打印数据
for (Transaction transaction : transactionTempList) {
System.out.println(transaction.toString());
}
Java8写法16行代码变1行
//使用stream处理数据。使用filter过滤2011年的交易记录。使用sorted排序。
//Transaction::getTranMoney写法可以简单理解为调用Transaction的getTranMoney方法。
List<Transaction> tranList1 = transactionList.stream().filter(tran -> tran.getTradTime().equals("2011")).sorted(comparing(Transaction::getTranMoney)).collect(toList());
//打印数据
tranList1.stream().forEach(System.out::println);
3.2、交易员都在哪些不同的城市工作过。
Java7写法：
//定义变量存储城市
List<String> cityTempList = new ArrayList<String>();
for (Transaction transaction : transactionList) {
String cityTemp = transaction.getTrader().getCity();
if(!cityTempList.contains(cityTemp)){
cityTempList.add(cityTemp);
}
}
//遍历城市集合
for (String string : cityTempList) {
System.out.println(string);
}
Java8优雅写法：
//2、交易员都在哪些不同的城市工作过
transactionList.stream().map(tran -> tran.getTrader()).map(trad -> trad.getCity()).distinct().forEach(System.out::println);
3.3、查找所有来自于成都的交易员，并按姓名排序。
Java7写法：
List<Transaction> cityTempList = new ArrayList<Transaction>();
for (Transaction transaction : transactionList) {
String cityTemp = transaction.getTrader().getCity();
if(cityTemp.equals("成都")){
cityTempList.add(transaction);
}
}
for (Transaction transaction : cityTempList) {
System.out.println(transaction.getTrader());
}
Java8优雅写法：
List<Trader> tranList3 = transactionList.stream().map(tran -> tran.getTrader()).filter(trad -> trad.getCity().equals("成都")).sorted(comparing(Trader::getName)).collect(toList());
tranList3.forEach(System.out::println);
3.4、返回所有交易员的姓名字符串，按字母顺序排序
List<String> tranList4 = transactionList.stream().map(tran -> tran.getTrader()).map(trad -> trad.getName()).distinct().sorted().collect(toList());
3.5、有没有交易员是在成都工作的
写法1：
transactionList.stream().map(tran -> tran.getTrader().getCity().equals("成都")).findAny().ifPresent(System.out::println);;
写法2：
System.out.println(transactionList.stream().anyMatch(transaction -> transaction.getTrader().getCity().equals("成都")));
3.6、打印生活在成都的交易员的所有交易额
System.out.println(transactionList.stream().filter(tranB -> tranB.getTrader().getCity().equals("成都")).map(Transaction::getTranMoney).reduce(Double::sum));
3.7、所有交易中，高的交易额是多少？
System.out.println(transactionList.stream().map(Transaction::getTranMoney).reduce(Double::max));
3.8、找到交易额小的交易 System.out.println(transactionList.stream().map(Transaction::getTranMoney).reduce(Double::min));
扩张：
交易员类Trader
public class Trader {
private String name;
private String city;
/**
含参构造函数
*/
public Trader(String name, String city) {
super();
this.name = name;
this.city = city;
}
/**
重写tostring方法
*/
@Override
public String toString() {
return "Trader [name=" + name + ", city=" + city + "]";
}
/**
省略get、set方法
*/
}
交易类Transaction。
public class Transaction {
private Trader trader;//交易员
private String tradTime;//交易年份
private double tranMoney;//交易金额
public Transaction(Trader trader, String tradTime, double tranMoney) {
super();
this.trader = trader;
this.tradTime = tradTime;
this.tranMoney = tranMoney;
}
@Override
public String toString() {
return "Transaction [trader=" + trader + ", tradTime=" + tradTime + ", tranMoney=" + tranMoney + "]";
}
}
初始化交易员类
Trader t1 = new Trader("liubei", "成都");
Trader t2 = new Trader("caocao", "洛阳");
Trader t3 = new Trader("sunquan", "南京");
Trader t4 = new Trader("guanyu", "成都");
Trader t5 = new Trader("zhangfei", "成都");
Trader t6 = new Trader("zhaoyun", "成都");
初始化交易类
List<Transaction> transactionList = Arrays.asList(new Transaction(t1, "2011", 300),
new Transaction(t2, "2013", 500),
new Transaction(t3, "2014", 700),
new Transaction(t4, "2011", 600),
new Transaction(t5, "2012", 600),
new Transaction(t6, "2011", 200));