Java8之stream实战

柔情只为你懂 2022-05-10 00:20 141阅读 0赞

最近并没有放下学互联网架构的框架，但是也用更多的时间去看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学完咯，加油！