Stream API的练习题

题目：

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

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

3. 查找所有来自Cambridge的交易员，并按姓名排序。

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

5. 有没有交易员在Milan工作

6. 打印生活在Cambridge的交易员的所有交易额。

7. 所有的交易额中，最高的交易额是多少？

8. 所有的交易额中，找到交易额最小的交易

一、代码结构：

com
└── example
    └── one
        ├── MainApp.java
        ├── Trader.java
        └── Transaction.java

二、案例所需的数据和实体类：

• 在com.example.one包路径下，创建Trader.java实体类。

package com.example.one;
​
@Data //省略封装方法，构造方法，equals和hashcode，toString
public class Trader {
    private String name;
    private String city;
​
​
    public Trader() {
    }
    public Trader(String name, String city) {
        this.name = name;
        this.city = city;
    }
}

• 在com.example.one包路径下，创建Transaction.java实体类。

package com.example.one;
​
@Data
public class Transaction {
    private Trader trader;
    private Integer year;
    private Integer value;
​
​
    public Transaction() {
    }
    public Transaction(Trader trader, Integer year, Integer value) {
        this.trader = trader;
        this.year = year;
        this.value = value;
    }
}

• 在com.example.one包路径下，创建MainApp.java测试类。

package com.example.one;
​
public class MainApp {
    private Trader raoul = new Trader("Raoul", "Cambridge");
    private Trader mario = new Trader("Mario", "Milan");
    private Trader alan = new Trader("Alan", "Cambridge");
    private Trader brian = new Trader("Brian", "Cambridge");
​
    private List<Transaction> transactionList = 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)
    );
    
    //TODO ... 待添加的方法...
}

三、使用Stream API提供的方法，解决问题：#

题目一：

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

/**
 * [
 *     Transaction(trader=Trader(name=Raoul, city=Cambridge), year=2011, value=400), 
 *     Transaction(trader=Trader(name=Brian, city=Cambridge), year=2011, value=300)
 * ]
 */
@Test
void test_01 () {
    List<Transaction> list = transactionList.stream()
            .filter(item -> item.getYear().equals(2011))
            .sorted((e1, e2) -> e2.getValue().compareTo(e1.getValue()))
            .collect(Collectors.toList());
    System.out.println(list);
}

题目二：

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

/**
 * [Cambridge, Milan]
 */
@Test
void test_01 () {
    List<String> list = transactionList.stream()
            .map(Transaction::getTrader).map(Trader::getCity)
            .distinct()
            .collect(Collectors.toList());
    System.out.println(list);
}

题目三：

• 查找所有来自Cambridge的交易员，并按姓名排序。

/**
 * [
 *     Trader(name=Alan, city=Cambridge), 
 *     Trader(name=Brian, city=Cambridge), 
 *     Trader(name=Mario, city=Milan), 
 *     Trader(name=Raoul, city=Cambridge)
 * ]
 */
@Test
void test_01 () {
    List<Trader> list = transactionList.stream()
            .map(Transaction::getTrader)
            .distinct()
            .sorted((e1, e2) -> e1.getName().compareTo(e2.getName()))
            .collect(Collectors.toList());
    System.out.println(list);
}

题目四：

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

实现方式一：

/**
 * [Alan, Brian, Mario, Raoul]
 */
@Test
void test_01 () {
    List<String> list = transactionList.stream()
            .map(Transaction::getTrader).map(Trader::getName)
            .distinct()
            .sorted(String::compareTo)
            .collect(Collectors.toList());
    System.out.println(list);
}

实现方式二：

/**
 * AlanBrianMarioRaoul
 */
@Test
void test_01 () {
    String concatStr = transactionList.stream()
            .map(Transaction::getTrader).map(Trader::getName)
            .distinct()
            .sorted(String::compareTo)
            .reduce("", String::concat);
    System.out.println(concatStr);
}

实现方式三：

/**
 * ABMRaaaaiillnnoorru
 */
@Test
void test_01() {
    String concatStr = transactionList.stream()
            .map(Transaction::getTrader).map(Trader::getName)
            .distinct()
            .flatMap(this::filterCharacter)
            .sorted(String::compareTo)
            .reduce("", String::concat);
    System.out.println(concatStr);
}
​
/**
 * 将字符串拆分，一个字符为一个字符串的流。
 */
private Stream<String> filterCharacter(String str) {
    List<String> list = new ArrayList<>();
    for (char ch : str.toCharArray()) {
        list.add(String.valueOf(ch));
    }
    return list.stream();
}

题目五：

• 有没有交易员在Milan工作。

/**
 * [Trader(name=Mario, city=Milan)]
 */
@Test
void test_01() {
    List<Trader> list = transactionList.stream()
            .map(Transaction::getTrader)
            .distinct()
            .filter(item -> item.getCity().equals("Milan"))
            .collect(Collectors.toList());
    System.out.println(list);
}

题目六：

• 打印生活在Cambridge的交易员的所有交易额。

实现方式一：

/**
 * 2650
 */
@Test
void test_01() {
    Integer sum = transactionList.stream()
            .filter(item -> item.getTrader().getCity().equals("Cambridge"))
            .collect(Collectors.summingInt(Transaction::getValue));
    System.out.println(sum);
}

实现方式二：

/**
 * 2650
 */
@Test
void test_01() {
    Integer sum = transactionList.stream()
            .filter(item -> item.getTrader().getCity().equals("Cambridge"))
            .map(Transaction::getValue)
            .reduce(0, Integer::sum);
    System.out.println(sum);
}

题目七：

• 所有的交易额中，最高的交易额是多少？

实现方式一：

/**
 * Optional[1000]
 */
@Test
void test_01() {
    Optional<Integer> max = transactionList.stream()
            .map(Transaction::getValue)
            .collect(Collectors.maxBy(Integer::compareTo));
    System.out.println(max);
}

实现方式二：

/**
 * Optional[1000]
 */
@Test
void test_01() {
    Optional<Integer> max = transactionList.stream()
            .map(Transaction::getValue)
            .max(Integer::compareTo);
    System.out.println(max);
}

题目八：

• 所有的交易额中，找到交易额最小的交易

实现方式一：

/**
 * Optional[Transaction(trader=Trader(name=Brian, city=Cambridge), year=2011, value=300)]
 */
@Test
void test_01() {
    Optional<Transaction> min = transactionList.stream()
            .min((e1, e2) -> e1.getValue().compareTo(e2.getValue()));
    System.out.println(min);
}

实现方式二：

/**
 * Optional[Transaction(trader=Trader(name=Brian, city=Cambridge), year=2011, value=300)]
 */
@Test
void test_01() {
    Optional<Transaction> min = transactionList.stream()
            .collect(Collectors.minBy((e1, e2) -> e1.getValue().compareTo(e2.getValue())));
    System.out.println(min);
}