Java 8实战（七）- Stream实践练习

一、实践

(1) 找出2011年发生的所有交易，并按交易额排序（从低到高）。
(2) 交易员都在哪些不同的城市工作过？
(3) 查找所有来自于剑桥的交易员，并按姓名排序。
(4) 返回所有交易员的姓名字符串，按字母顺序排序。
(5) 有没有交易员是在米兰工作的？
(6) 打印生活在剑桥的交易员的所有交易额。
(7) 所有交易中，最高的交易额是多少？
(8) 找到交易额最小的交易。

以下是你要处理的领域，一个Traders和Transactions的列表：

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)
);

Trader和Transaction类的定义如下：

public class Trader{
	private final String name;
	private final String city;
	public Trader(String n, String c){
		this.name = n;
		this.city = c;
	}
	public String getName(){
		return this.name;
	}
	public String getCity(){
		return this.city;
	}
	public String toString(){
		return "Trader:"+this.name + " in " + this.city;
	}
}

public class Transaction{
		private final Trader trader;
		private final int year;
		private final int value;
		public Transaction(Trader trader, int year, int value){
			this.trader = trader;
			this.year = year;
			this.value = value;
		}
		public Trader getTrader(){
			return this.trader;
		}
		public int getYear(){
			return this.year;
		}
		public int getValue(){
			return this.value;
		}
		public String toString(){
			return "{" + this.trader + ", " +
			"year: "+this.year+", " +
			"value:" + this.value +"}";
		}
}

1. 找出2011年的所有交易并按交易额排序（从低到高）

List<Transaction> tr2011 = transactions.stream()
							.filter(transaction -> transaction.getYear() == 2011)
							.sorted(comparing(Transaction::getValue))
							.collect(toList());

2. 交易员都在哪些不同的城市工作过

List<String> cities = transactions.stream()
								.map(transaction -> transaction.getTrader().getCity())
								.distinct()
								.collect(toList());

这里还有一个新招：你可以去掉distinct()，改用toSet()，这样就会把流转换为集合。

Set<String> cities = transactions.stream()
								.map(transaction -> transaction.getTrader().getCity())
								.collect(toSet());

3. 查找所有来自于剑桥的交易员，并按姓名排序

List<Trader> traders = transactions.stream()
								.map(Transaction::getTrader)
								.filter(trader -> trader.getCity().equals("Cambridge"))
								.distinct()
								.sorted(comparing(Trader::getName))
								.collect(toList());

4. 返回所有交易员的姓名字符串，按字母顺序排序

String traderStr = transactions.stream()
								.map(transaction -> transaction.getTrader().getName())
								.distinct()
								.sorted()
								// 逐个拼接每个名字，得到一个将所有名字连接起来的String
								.reduce("", (n1, n2) -> n1 + n2);

请注意，此解决方案效率不高（所有字符串都被反复连接，每次迭代的时候都要建立一个新的String对象）。下一章中，你将看到一个更为高效的解决方案，它像下面这样使用joining（其内部会用到StringBuilder）：

String traderStr = transactions.stream()
								.map(transaction -> transaction.getTrader().getName())
								.distinct()
								.sorted()
								.collect(joining());

5. 有没有交易员是在米兰工作的

boolean milanBased = transactions.stream()
								.anyMatch(transaction -> transaction.getTrader()
								.getCity()
								.equals("Milan"));

6. 打印生活在剑桥的交易员的所有交易额

transactions.stream()
			.filter(t -> "Cambridge".equals(t.getTrader().getCity()))
			.map(Transaction::getValue)
			.forEach(System.out::println);

7. 所有交易中，最高的交易额是多少

Optional<Integer> highestValue = transactions.stream()
											.map(Transaction::getValue)
											.reduce(Integer::max);

8. 找到交易额最小的交易

Optional<Transaction> smallestTransaction = transactions.stream()
						// 通过反复比较每个交易的交易额，找出最小的交易
						.reduce((t1, t2) -> t1.getValue() < t2.getValue() ? t1 : t2);

你还可以做得更好。流支持min和max方法，它们可以接受一个Comparator作为参数，指定计算最小或最大值时要比较哪个键值：

Optional<Transaction> smallestTransaction = transactions.stream()
											.min(comparing(Transaction::getValue));