Stream流，lambda表达式相关练习（22.6.28）

/**
 * @author GuoShuo
 * @date 2022/6/28 17:12
 */
@AllArgsConstructor
@NoArgsConstructor
@Data
public class Trader {
    private String name;
    private String  city;
}

/**
 * @author GuoShuo
 * @date 2022/6/28 17:13
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Transaction {

    private Integer year;
    private Integer value;
    private Trader trader;

}

/**
 * @author GuoShuo
 * @date 2022/6/28 17:14
 */
public class TestStreamApi {

    @Test
    public void demo1(){
        // 有一个集合  [1,2,3,4]   返回 [1,4,9,16]

        Arrays.asList(1,2,3,4).stream()
                .map(x -> x*x)
                .forEach(System.out::println);

    }

    List<Student> list = Arrays.asList(
            new Student(1,"zs",18,88.5, Sex.男),
            new Student(2,"ls",19,89.5,Sex.男),
            new Student(3,"ww",21,86.5,Sex.女),
            new Student(4,"zl",20,99.5,Sex.女),
            new Student(5,"tq",22,82.5,Sex.女),
            new Student(6,"mb",21,92.5,Sex.女),
            new Student(6,"mb",21,92.5,Sex.男)

    );
    @Test
    public void demo2(){
        //使用map 和 reduce 来统计 Stream<Student> 中 有多少个 学生对象
        Optional<Integer> reduce = list.stream()
                .map(s -> 1)
                .reduce(Integer::sum);

        System.out.println(reduce.get());
    }



    List<Transaction> transactions = null;
    @Before
    public void doBefore(){
        Trader trader1 = new Trader("诸葛亮","南阳");
        Trader trader2 = new Trader("貂蝉","洛阳");
        Trader trader3 = new Trader("嬴政","咸阳");
        Trader trader4 = new Trader("王昭君","洛阳");

        transactions = Arrays.asList(
                new Transaction(2011,300,trader1),
                new Transaction(2012,1000,trader2),
                new Transaction(2011,400,trader2),
                new Transaction(2012,660,trader1),
                new Transaction(2011,800,trader3),
                new Transaction(2012,700,trader4)
        );

    }

    @Test
    public void demo3(){
        // 找出 2011 年发生的所有交易   并按照交易额排序   由低到高
        List<Transaction> collect =transactions.stream()
                .filter(t -> t.getYear() == 2011)
                .sorted((t1,t2) -> {
                    return t1.getValue() > t2.getValue() ? 1 : -1;
                })
                .collect(Collectors.toList());

        collect.forEach(System.out::println);

    }

    //2. 交易员都在哪些城市工作过
    @Test
    public void demo4(){
        transactions.stream()
                .map((t->t.getTrader().getCity()))
                .distinct()
                .forEach(System.out::println);

    }

    //3.查询所有来自洛阳的交易员  按照姓名排序
    @Test
    public void demo5(){
        List<Trader> traders = transactions.stream()
                .map(Transaction::getTrader)
                .filter(trader -> {
                    return trader.getCity().equals("洛阳");
                })
                .sorted((t1,t2) ->{
                    return t1.getName().compareTo(t2.getName());
                })
                .collect(Collectors.toList());

        traders.forEach(System.out::println);

    }


    //4.返回所有交易员的名字  按照字符串比较排序
    @Test
    public void test6(){
        transactions.stream()
                .map(t->t.getTrader())
                .map(t->t.getName())
                .distinct()
                .sorted()
                .forEach(System.out::println);
    }


    @Test
    public void test(){
        int i = "嬴政".compareTo("王昭君");
        System.out.println(i);
    }

    //5.有没有交易员在 南阳工作
    @Test
    public void test7(){
        boolean b = transactions.stream()
                .map(Transaction::getTrader)
                .anyMatch(t->"南阳".equals(t.getCity()));
        System.out.println(b);

    }

    //6. 输出 工作在 咸阳的交易员的 所有交易
    @Test
    public void test8(){
        List<Transaction> collect = transactions.stream()
                .filter(t->"咸阳".equals(t.getTrader().getCity()))
                .collect(Collectors.toList());

        System.out.println(collect);
    }

    //7. 所有 交易中  最高的交易额是多少
    @Test
    public void test9(){
        Optional<Integer> max = transactions.stream()
                .map(Transaction::getValue)
                .max((v1,v2) -> v1 > v2? 1:-1);
        System.out.println(max.get());

    }

    //8. 找到 交易额最小的 交易
    @Test
    public void test10(){
        Optional<Transaction> first = transactions.stream()
                .sorted((t1,t2) -> t1.getValue() > t2.getValue() ? 1:-1)
                .findFirst();

        System.out.println(first.get());
    }



}