Java8之stream实战

        最近并没有放下学互联网架构的框架，但是也用更多的时间去看Java8实战。最近一两个星期京东搞活动，来来去去买了三次书，买了9本，哈哈哈。其中有两本是关于Java编程的，一本是Java的编程思想（还没看），一本就是现在一到周末就看的Java8 In Action。因为学的框架越来越多，深有体会在某些业务场景他们真的很牛逼，但是说到底，我还是觉得编程的基础和编程的思想是最重要的，框架其实就等于工具，造他们的还不是语言。而且，公司的项目都用到了Java8，但是它的特性我竟然是一次都没用过，自从看了书之后，好想将自己以前的代码好好改进一番。。。

        关于Java8的新特性，我现在学到的是Lambda表达式和Stream流，这两玩意可谓是想当的好使啊，代码变得想当的简洁和健壮，而且操作起集合来简直就是得心应手，简简单单一行代码顶以前的几十行。

练习：

        下面是Java8 in Action学习玩Stream后的练习，挺好玩的，下面我就贴出来呗。领域：执行交易的交易员。经理让你为八个查询找到答案。

1、找出2011年发生的所有交易，并按交易金额排序（从低到高）

2、交易员都在哪些不同的城市工作？

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

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

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

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

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

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

领域：交易员和交易

下面是你要处理的领域，一个Trader和一个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 name, String city) {
		super();
		this.name = name;
		this.city = city;
	}
	public String getName() {
		return name;
	}
	public String getCity() {
		return city;
	}
	@Override
	public String toString() {
		return "Trader [name=" + name + ", city=" + city + "]";
	}
}

public class Transaction {
	private final Trader trader;
	private final int year;
	private final int value;
	
	public Transaction(Trader trader, int year, int value) {
		super();
		this.trader = trader;
		this.year = year;
		this.value = value;
	}

	public Trader getTrader() {
		return trader;
	}

	public int getYear() {
		return year;
	}

	public int getValue() {
		return value;
	}

	@Override
	public String toString() {
		return "Transaction [trader=" + trader + ", year=" + year + ", value=" + value + "]";
	}
}

想自己尝试一下的小伙伴可以先尝试，不想尝试的可以瞄瞄我做得咋样。

俺的练习：注解为我自己思考的过程

public class TestDemo {
	//交易员
	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));
	
	
	//找出2011年发生的所有交易，并按交易额排序（从低到高）
	@Test
	public void test1(){
		
		//Comparator.comparing默认是升序
		List<Transaction> result = transactions.stream()
				.filter( (t)->t.getYear()==2011)//滤掉year不为2011
				.sorted(Comparator.comparing(Transaction::getValue))//根据value排序
				.collect(Collectors.toList()); 
		result.forEach(System.out::println);
	}
	
	//交易员都在哪些不同的城市工作过
	@Test
	public void test2(){
		
		List<String> result = transactions.stream()
				.map(Transaction::getTrader)//从交易记录中映射出交易员
				.map(Trader::getCity)//从交易员映射出城市名
				.distinct()//再去重
				.collect(Collectors.toList());
		result.forEach(System.out::println);
	}
	
	//查找出所有来自剑桥的交易员，并按姓名排序
	@Test
	public void test3(){
		List<Trader> result = transactions.stream()
				.map(Transaction::getTrader)//映射出交易员
				.filter((t)->("Cambridge").equals(t.getCity()))//过滤城市为剑桥的交易员
				.distinct()//去重
				.sorted(Comparator.comparing(Trader::getName))//根据姓名排序
				.collect(Collectors.toList());
		result.forEach(System.out::println);
	}
	
	//返回所有交易员的姓名字符串，按字母顺序排序
	@Test
	public void test4(){
		String allName = transactions.stream()
				.map((t)->t.getTrader().getName())//映射出交易员名字
				.sorted() //排序（默认升序）
				.reduce("",(a,b)->a+b);  //如果不加"",返回的是Option<String>，因为防止源是空的
		System.out.println(allName);
	}
	
	//有没有交易员在米兰工作过
	@Test
	public void test5(){
		boolean flag = transactions.stream()
				.map(Transaction::getTrader)//映射出交易员
				.anyMatch(t->t.getCity().equals("Milan"));//进行匹配
		System.out.println("有没有在米兰工作的交易员："+flag);
	}
	
	//打印生活在剑桥的交易员的所有交易额  2650
	@Test
	public void test6(){
		Integer sum = transactions.stream()
				.filter(t->t.getTrader().getCity().equals("Cambridge"))//过滤生活在剑桥的交易员
				.map(Transaction::getValue)//映射出交易额
				.reduce(0, (a,b)->a+b);//最后进行处理
		System.out.println("生活在剑桥的交易员的所有交易额:"+sum);
	}
	
	//所有交易中，最高的交易额是多少
	@Test
	public void test7(){
		//一开始自己的做法
		List<Integer> list = transactions.stream()
				.sorted(Comparator.comparing(Transaction::getValue).reversed())//交易额排序（降序）
				.map(Transaction::getValue)//映射出交易额
				.limit(1)//只取第一个，那就是最高的交易额
				.collect(Collectors.toList());
		System.out.println("所有交易中，最高的交易额是"+list.get(0));
		//升级1
		Optional<Integer> max = transactions.stream()
				.map(Transaction::getValue)//映射出交易额
				.reduce(Integer::max);//使用reduce处理数据
		System.out.println("所有交易中，最高的交易额是"+max.get());
		
		//升级2
		Optional<Transaction> max2 = transactions.stream()
				.max(Comparator.comparing(Transaction::getValue));//直接使用max
		System.out.println("所有交易中，最高的交易额是"+max2.get().getValue());
	}
	
	//找到交易额最小的交易
	@Test
	public void test8(){
		Optional<Integer> min = transactions.stream()
				.map(Transaction::getValue)//映射出交易额
				.reduce(Integer::min);//使用reduce处理数据
		System.out.println("所有交易中，最小的交易额是"+min.get());
		
		//升级版
		Optional<Transaction> min2 =transactions.stream()
				.min(Comparator.comparing(Transaction::getValue));//直接使用min
		System.out.println("所有交易中，最小的交易额是"+min2.get().getValue());
		
	}
}

好了，上周末学的是Lambda表达式，今个星期学的是Stream流，剩下的时间要去继续把ZooKeeper学完咯，加油！