Java8 新特性 - Stream流相关函数练习题（一）

package org.example;
 
/**
 * @author 
 * @Description:
 * @data 2022 年 08 月 28 日 17:55
 */
public class Transaction {
 
    private Trader trader;
    private int yearOfTransaction;
    private int transactionAmount;
 
    public Transaction() {
    }
 
    public Transaction(Trader trader, int yearOfTransaction, int transactionAmount) {
        this.trader = trader;
        this.yearOfTransaction = yearOfTransaction;
        this.transactionAmount = transactionAmount;
    }
 
    public Trader getTrader() {
        return trader;
    }
 
    public void setTrader(Trader trader) {
        this.trader = trader;
    }
 
    public int getYearOfTransaction() {
        return yearOfTransaction;
    }
 
    public void setYearOfTransaction(int yearOfTransaction) {
        this.yearOfTransaction = yearOfTransaction;
    }
 
    public int getTransactionAmount() {
        return transactionAmount;
    }
 
    public void setTransactionAmount(int transactionAmount) {
        this.transactionAmount = transactionAmount;
    }
 
    @Override
    public String toString() {
        return "Transaction{" +
                "trader=" + trader +
                ", yearOfTransaction=" + yearOfTransaction +
                ", transactionAmount=" + transactionAmount +
                '}';
    }
}

package org.example;
 
/**
 * @author 
 * @Description:
 * @data 2022 年 08 月 28 日 17:55
 */
public class Trader {
 
    private String name;
    private String city;
 
    public Trader() {
    }
 
    public Trader(String name, String city) {
        this.name = name;
        this.city = city;
    }
 
    public Trader(String name) {
        this.name = name;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public String getCity() {
        return city;
    }
 
    public void setCity(String city) {
        this.city = city;
    }
 
    @Override
    public String toString() {
        return "Trader{" +
                "name='" + name + '\'' +
                ", city='" + city + '\'' +
                '}';
    }
}

/*      Trader（交易员）: 姓名 工作城市
        Transaction（交易记录）: 交易员  交易年份 交易金额 */

        List<Transaction> list = new ArrayList();
        list.add(new Transaction(new Trader("张大大", "上海"), 2006, 478));
        list.add(new Transaction(new Trader("李四", "广东"), 2011, 9874));
        list.add(new Transaction(new Trader("小王", "广东"), 2019, 2131));
        list.add(new Transaction(new Trader("晓白", "深圳"), 2011, 3412));
        list.add(new Transaction(new Trader("晓白", "深圳"), 2017, 2394));
        list.add(new Transaction(new Trader("达尔温", "波西"), 2009, 3121));

//        (1) 找出2011年发生的所有交易，并按交易额排序（从低到高）。
        list.stream()
                .filter(e -> e.getYearOfTransaction() == 2011)
                .sorted(Comparator.comparing(Transaction::getTransactionAmount).reversed())
                .forEach(System.out::println);
//        (2) 交易员都在哪些不同的城市工作过？
        list.stream()
                .map(e -> e.getTrader().getCity())
                .distinct()
                .forEach(System.out::println);
//        (3) 查找所有来自于剑桥的交易员，并按姓名排序。
        list.stream()
                .filter(e -> e.getTrader().getCity().equals("剑桥"))
                .sorted(Comparator.comparing(x -> x.getTrader().getName()))
                .forEach(System.out::println);
//        (4) 返回所有交易员的姓名字符串，按字母顺序排序。
        list.stream()
                .map(e -> e.getTrader().getName())
                .sorted(String::compareTo)
                .forEach(System.out::println);
//        (5) 有没有交易员是在米兰工作的？
        list.stream()
                .filter(e -> e.getTrader().getCity().equals("米兰"))
                .forEach(System.out::println);
//        (6) 打印生活在剑桥的交易员的所有交易额。
        list.stream()
                .filter(e -> e.getTrader().getCity().equals("剑桥"))
                .map(Transaction::getTransactionAmount)
                .forEach(System.out::println);
//        (7) 所有交易中，最高的交易额是多少？
        //reduce求最小值
        Integer integer1 = list.stream()
                .map(Transaction::getTransactionAmount)
                .reduce(Integer::max).get();
        System.out.println(integer1);
        //stream求最小值
        Integer integer2 = list.stream()
                .map(Transaction::getTransactionAmount)
                .max(Integer::max).get();
        System.out.println(integer2);
//        (8) 找到交易额最小的交易。
        //reduce求最小值
        Integer integer3 = list.stream()
                .map(Transaction::getTransactionAmount)
                .reduce(Integer::min).get();
        System.out.println(integer3);

        //stream求最小值
        Integer integer4 = list.stream()
                .map(Transaction::getTransactionAmount)
                .min(Integer::compareTo).get();
        System.out.println(integer4);