Stream 练习

作者: tingshuo123 | 来源:发表于2018-10-02 20:57 被阅读23次

Stream 练习
Stream练习
JAVA8新特性: Stream-集合流操作
Stream流
Java8 stream练习
JDK8新特性之Stream流
2018-04-03
异步 Stream
Java8新特性
2019-02-02——Java8 Stream

这几天在看Java8的新特性Stream，想试试掌握如何，就找了一个题目练练手。

数据源

    // 数据源
    
    Trader raoul = new Trader("Raoul", "剑桥");
    Trader mario = new Trader("Mario", "米兰");
    Trader alan = new Trader("Alan", "剑桥");
    Trader brian = new Trader("Brian", "剑桥");
    
    List<Transaction> transactions = Arrays.asList(
        new Transaction(raoul, 2011, 400),
        new Transaction(brian, 2011, 300),
        new Transaction(raoul, 2012, 1000),
        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) {
        this.name = name;
        this.city = city;
    }
    // getter setter ...
}


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;
    }
    // getter setter ...
}

题目

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

        List<Transaction> list = transactions.stream()
                .filter(item -> item.getYear() == 2011)
                .sorted((a, b) -> ((Integer)a.getValue()).compareTo(b.getValue()))
                .collect(Collectors.toList());

交易员都在那些不同的城市工作过？

List<String> list = transactions.stream()
                .map(item -> item.getTrader().getCity())
                .distinct()
                .collect(Collectors.toList());

所有来至剑桥的交易员，按姓名排序

List<Trader> list = transactions.stream()
                .filter(item -> "剑桥".equals(item.getTrader().getCity()))
                .map(Transaction::getTrader)
                .distinct()
                .sorted((a, b) -> a.getName().compareTo(b.getName()))
                .collect(Collectors.toList());

返回所有交易员姓名的字符串

List<String> list = transactions.stream()
                .map(item -> item.getTrader().getName())
                .distinct()
                .sorted(String::compareToIgnoreCase)
                .collect(Collectors.toList());

有没有交易员是再米兰工作的

        Optional<Transaction> optional = transactions.stream()
                .filter(item -> "米兰".equals(item.getTrader().getCity()))
                .findAny();
        
        if (optional.isPresent()) {
            System.out.println("有");
        } else {
            System.out.println("没有");
        }

生活在剑桥的交易员所有交易额

int sum = transactions.stream()
                .filter(item -> "剑桥".equals(item.getTrader().getCity()))
                .map(item -> item.getValue())
                .reduce(0, Integer::sum);

最高的交易额

int max = transactions.stream()
                .filter(item -> "剑桥".equals(item.getTrader().getCity()))
                .map(item -> item.getValue())
                .reduce(Integer.MIN_VALUE, Integer::max);

最低的交易额

int min = transactions.stream()
                    .filter(item -> "剑桥".equals(item.getTrader().getCity()))
                    .map(item -> item.getValue())
                    .reduce(Integer.MAX_VALUE, Integer::min);