java stream流操作

stream：

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

1.实体类

//交易员类
class Trader {
    private final String name;
    private final String city;

    public Trader(String name, String city) {
        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 + '\'' +
                '}';
    }
}

//Transaction（交易记录）

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 +"}";
    }
}

2.测试代码

public class Test01 {
    public static void main(String[] args) {
        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));
        System.out.println("下面是第一题:找出2011年发生的所有交易，并按交易额排序（从低到高）");
        //  (1) 找出2011年发生的所有交易，并按交易额排序（从低到高）
        transactions.stream().filter(item->item.getYear()==2011)
                .sorted((o1,o2)->o1.getValue()- o2.getValue())
                .forEach(System.out::println);
        System.out.println("下面是第二题:交易员都在哪些不同的城市工作过");
        //  (2) 交易员都在哪些不同的城市工作过？
        transactions.stream().map(item->item.getTrader().getCity())
                .distinct().forEach(System.out::println);
        System.out.println("下面是第三题: 查找所有来自于剑桥的交易员，并按姓名排序");
        //  (3) 查找所有来自于剑桥的交易员，并按姓名排序。
        transactions.stream().map(item -> item.getTrader())
                .filter(item -> item.getCity().equals("Cambridge")).distinct()
                .sorted((o1, o2) -> Collator.getInstance(Locale.CHINA)
                        .compare(o1.getName(),o2.getName()))
                .collect(Collectors.toList())
                .forEach(System.out::println);
        System.out.println("下面是第四题: 返回所有交易员的姓名字符串，按字母顺序排序");
        //  (4) 返回所有交易员的姓名字符串，按字母顺序排序。
        transactions.stream().map(item -> item.getTrader().getName()).sorted()
                .distinct().forEach(System.out::println);
        System.out.println("下面是第五题: 有没有交易员是在米兰工作的？");
        //  (5) 有没有交易员是在米兰工作的？
        transactions.stream().map(item->item.getTrader())
                .filter(item->item.getCity().equals("Milan"))
                .distinct().forEach(System.out::println);
        System.out.println("下面是第六题: 打印生活在剑桥的交易员的所有交易额");
        // (6) 打印生活在剑桥的交易员的所有交易额。
        transactions.stream().filter(item->item.getTrader().getCity().equals("Cambridge"))
                .map(item->item.getValue())
                .forEach(System.out::println);
        System.out.println("下面是第七题: 所有交易中，最高的交易额是多少？");
        //(7) 所有交易中，最高的交易额是多少？
        Optional<Integer> max = transactions.stream().map(item -> item.getValue()).max((o1, o2) -> o1.intValue() - o2.intValue());
        System.out.println(max.get());
        System.out.println("下面是第八题: 找到交易额最小的交易");
        //(8) 找到交易额最小的交易
        Optional<Integer> min = transactions.stream().map(item -> item.getValue()).min((o1, o2) -> o1.intValue() - o2.intValue());
        System.out.println(min.get());
    }

}