java8实战关于Stream的一篇测试题

package java8.流.筛序苹果;

import java.util.*;
import java.util.function.Predicate;
import java.util.stream.Collectors;

/**
 * @program: javaCodeThink
 * @description:
 * @author: fbl
 * @create: 2020-10-29 08:37
 **/
public class FlatMap {

    public static void main(String[] args) {
        String[] words = {"Hello", "World"};

        // flatMap
        List<String> collect = Arrays.stream(words).map(w -> w.split("")).flatMap(Arrays::stream).distinct().collect(Collectors.toList());

        //collect.forEach(System.out::print);


        // 复合谓词
        Predicate<String> p = w -> w.equals("H");
        Predicate<String> b = p.or(w -> w.equals("W"));

        List<String> collect1 = Arrays.stream(words).map(w -> w.split("")).flatMap(Arrays::stream).filter(b.negate()).collect(Collectors.toList());
        //collect1.forEach(System.out::print);
        Integer[] n1 = {1, 2, 3};
        Integer[] n2 = {3, 4};
        Arrays.stream(n1).flatMap(nn1 -> Arrays.stream(n2).map(nn2 -> new int[]{nn1, nn2}));

        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年发生的所有交易，并按交易额排序（从低到高）
        List<Transaction> collect2 = transactions.stream().filter(t -> t.getYear() == 2011).sorted(Comparator.comparing(Transaction::getValue)).collect(Collectors.toList());
        for (Transaction transaction : collect2) {
            System.out.println(transaction.toString());
        }
        System.out.println("-------------------------------------------------");
        // 交易员都在哪些不同的城市工作过？
        List<String> collect3 = transactions.stream().map(t -> t.getTrader().getCity()).distinct().collect(Collectors.toList());
        for (String s : collect3) {
            System.out.println(s);
        }
        System.out.println("-------------------------------------------------");
        // 查找所有来自剑桥的交易员，并按照姓名排序
        List<Trader> cambridge2 = transactions.stream().filter(t -> t.getTrader().getCity().equals("Cambridge")).map(n -> n.getTrader()).distinct().sorted(Comparator.comparing(t -> t.getName())).collect(Collectors.toList());
        for (Trader s : cambridge2) {
            System.out.println(s);
        }
        System.out.println("-------------------------------------------------");
        // 返回所有交易员的姓名字符串，按字母顺序排序 第一种效率更高，第二种使用字符串拼接的形式，会使用StringBuilder
        String collect4 = transactions.stream().map(t -> t.getTrader().getName()).distinct().sorted(String::compareTo).collect(Collectors.joining());
        String collect5 = transactions.stream().map(t -> t.getTrader().getName()).distinct().sorted(String::compareTo).reduce("",(m,n) -> m + n);
        System.out.println(collect4);
        System.out.println(collect5);
        System.out.println("-------------------------------------------------");
        // 有没有交易员在米兰生活的？
        boolean cambridge = transactions.stream().anyMatch(t -> t.getTrader().getCity().equals("Cambridge"));
        System.out.println(cambridge);
        System.out.println("-------------------------------------------------");
        // 打印生活在剑桥的交易员的所有交易额
          transactions.stream().filter(t -> t.getTrader().getCity().equals("Cambridge")).map(Transaction::getValue).forEach(System.out::println);
       // 所有交易中，最高的交易是多少 第二种效率更高（不用拆装箱）  第三种存储有最大 最小 平均 统计总量 总计 等，要哪个get那个即可
        System.out.println("-------------------------------------------------");
        Optional<Integer> reduce = transactions.stream().map(t -> t.getValue()).reduce(Integer::max);
        OptionalInt max = transactions.stream().mapToInt(t -> t.getValue()).max();
        int summaryMax = transactions.stream().collect(Collectors.summarizingInt(Transaction::getValue)).getMax();
        System.out.println(reduce.get());
        System.out.println(max.getAsInt());
        System.out.println(summaryMax);
        System.out.println("-------------------------------------------------");
        // 找到交易额最小的交易 第一种自己写的，还是有命令式编程的样子 第二种是第三种的简化版
         List<Transaction> collect6 = transactions.stream().sorted(Comparator.comparing(Transaction::getValue)).limit(1).collect(Collectors.toList());
        Optional<Transaction> collect7 = transactions.stream().min(Comparator.comparing(Transaction::getValue));
        Optional<Transaction> collect8 = transactions.stream().collect(Collectors.minBy(Comparator.comparing(Transaction::getValue)));
        System.out.println(collect6);
        System.out.println(collect7);
        System.out.println(collect8);

   System.out.println("-------------------------------------------------");
        // 交易员按照城市分组
        Map<String, List<Trader>> collect9 = transactions.stream().map(Transaction::getTrader).distinct().collect(Collectors.groupingBy(Trader::getCity));
        System.out.println(collect9);
    }

}


class Trader {
    private final String name;
    private final String city;

    public Trader(String n, String c) {
        this.name = n;
        this.city = c;
    }

    public String getName() {
        return name;
    }

    public String getCity() {
        return city;
    }

    @Override
    public String toString() {
        return "Trader{" +
                "name='" + name + '\'' +
                ", city='" + city + '\'' +
                '}';
    }
}

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 trader;
    }

    public int getYear() {
        return year;
    }

    public int getValue() {
        return value;
    }

    @Override
    public String toString() {
        return "Transaction{" +
                "trader=" + trader +
                ", year=" + year +
                ", value=" + value +
                '}';
    }
}