java stream流统一设置参数

Java中Stream()的使用实例

说明：此文章为了自己回顾使用

测试类1：
List<Employee> emps = Arrays.asList(
            new Employee(102, "李四", 79, 6666.66, Employee.Status.BUSY),
            new Employee(101, "张三", 18, 9999.99, Employee.Status.FREE),
            new Employee(103, "王五", 28, 3333.33, Employee.Status.VOCATION),
            new Employee(104, "赵六", 8, 7777.77, Employee.Status.BUSY),
            new Employee(104, "赵六", 8, 7777.77, Employee.Status.FREE),
            new Employee(104, "赵六", 8, 7777.77, Employee.Status.FREE),
            new Employee(105, "田七", 38, 5555.55, Employee.Status.BUSY)
    );

    @Test
    public void test01() {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        Long count = list.stream()
                .collect(Collectors.counting());
        System.out.println(count);

        System.out.println("-------------------------------");
        Optional<Integer> max = list.stream()
                .collect(Collectors.maxBy(Integer::compare));
        System.out.println(max.get());

        System.out.println("-------------------------------");
        list.stream()
                .map(e -> e * e)
                .forEach(System.out::println);

        System.out.println("-------------------------------");
        long count1 = list.stream()
                .count();
        System.out.println(count1);

        System.out.println("-------------------------------");
        List<Integer> list1 = list.stream()
                .map(e -> e * e)
                .collect(Collectors.toList());
        System.out.println(list1);

        System.out.println("-------------------------------");
        Integer[] list2 = new Integer[]{1, 2, 3, 4, 5};
        List<Integer> list3 = Arrays.stream(list2)
                .map(e -> e * e)
                .collect(Collectors.toList());
        list3.forEach(System.out::println);

    }

    @Test
    public void test02() {
        //用map和reduce方法数一数流中有多少个Employee

        long count = emps.stream()
                .count();
        System.out.println(count);

        System.out.println("--------------");

        Integer count1 = emps.stream()
                .map(e -> 1)
                .reduce(0, (a, b) -> a + b);
        System.out.println(count1);

        System.out.println("--------------");//因为这个求和可能为null，所以用Optional包装一下
        Optional<Integer> count2 = emps.stream()
                .map(e -> 1)
                .reduce((a, b) -> a + b);
        System.out.println(count2.get());

        System.out.println("---------------");
        Optional<Integer> count3 = emps.stream()
                .map(e -> 1)
                .reduce(Integer::sum);

        //reduce中的参数BinaryOperator 查看可以发现extends BiFunction<T,T,T>
        //所以是那种传进去T,T,返回T类型的，可以写（T,T）-> return T这种
        //而Integer中有sum方法：public static int sum(int a, int b) {
        //        return a + b;
        //    }，属于这种类型，所以我们可以用Integer::sum这种lambda的方法引用方式
        System.out.println(count3.get());


    }

测试类2：
其中Trader类和Transaction类比较简单，就不写了
	@Before
    public void before() {
        Trader raoul = new Trader("Raoul", "Cambridge");
        Trader mario = new Trader("Mario", "Milan");
        Trader alan = new Trader("Alan", "Cambridge");
        Trader brian = new Trader("Brian", "Cambridge");

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

    //1. 找出2011年发生的所有交易， 并按交易额排序（从低到高）
    @Test
    public void test1() {
        transactions.stream()
                .filter(e -> e.getYear() == 2011)
                /**
                 * 由于a.getValue是int类型，不是Integer包装类，其中不包含compareTo方法，所以不能采用这种方式写：
                 * .sorted((a,b)->a.getValue().compareTo(b.getValue()))，如果将Transaction中的value的
                 * 类型改成Integer，这样写就不会有问题了
                 */
                .sorted((a, b) -> Integer.compare(a.getValue(),b.getValue()))
                .forEach(System.out::println);

        System.out.println("-----------------");

        transactions.stream()
                .filter(e -> e.getYear() == 2011)
                .map(Transaction::getValue)
                .sorted()
                .forEach(System.out::println);
    }

    //2. 交易员都在哪些不同的城市工作过？
    @Test
    public void test2() {
        // 这样有点繁琐，不如下面第二个
        transactions.stream()
                .map(i -> i.getTrader())//传过去列表的每一个值，映射一个String <=> Transaction::getTrader
                .distinct()
                .map(Trader::getCity)
                .distinct()
                .forEach(System.out::println);

        System.out.println("---------------------------");

        transactions.stream()
                .map(i -> i.getTrader().getCity())
                .distinct()
                .forEach(System.out::println);
    }

    //3. 查找所有来自剑桥的交易员，并按姓名排序
    @Test
    public void test3() {
        //sort后面的玩意我写不出来
        /**
         * 差不多了，sorted后面的参数可以知道为Comparator，本质上只是返回了一个正负值，因此如果比较的是Integer
         * 就用Integer.compare()以及.compareTo(),因为Integer中封装了compare函数以及compareTo函数
         */
        transactions.stream()
                .map(Transaction::getTrader)
                .filter(e -> e.getCity().equals("Cambridge"))
                .sorted((a,b)->a.getName().compareTo(b.getName()))
                .distinct()
                .forEach(System.out::println);


    }

    //4. 返回所有交易员的姓名字符串，按字母顺序排序
    @Test
    public void test4() {
        transactions.stream()
                .map(e->e.getTrader().getName())
                .distinct()
                .sorted()
                .forEach(System.out::println);

    }

    public static Stream<String> filterCharacter(String str) {
        List<String> list = new ArrayList<>();

        for (Character ch : str.toCharArray()) {
            list.add(ch.toString());
        }

        return list.stream();
    }

    //5. 有没有交易员是在米兰工作的？
    @Test
    public void test5() {
//        这个返回是字符串，不符合要求
        transactions.stream()
                .filter(i -> i.getTrader().getCity().equals("Milan"))
                .map(i -> i.getTrader().getName())
                .distinct()
                .forEach(System.out::println);

        boolean milan = transactions.stream()
                .anyMatch(i -> i.getTrader().getCity().equals("Milan"));
        System.out.println(milan);

    }


    //6. 打印生活在剑桥的交易员的所有交易额
    @Test
    public void test6() {
        Optional<Integer> sum = transactions.stream()
                .filter(i -> i.getTrader().getCity().equals("Cambridge"))
                .map(Transaction::getValue)
                .reduce(Integer::sum);
        System.out.println(sum.get());

        System.out.println("------------------------");
        Integer sum2 = transactions.stream()
                .filter(i -> i.getTrader().getCity().equals("Cambridge"))
                .map(Transaction::getValue)
                .reduce(0, (a, b) -> a + b);
        System.out.println(sum2);



    }


    //7. 所有交易中，最高的交易额是多少
    @Test
    public void test7() {
        Optional<Integer> max = transactions.stream()
                .map(Transaction::getValue)
                .reduce(Integer::max);
        System.out.println(max.get());
    }

    //8. 找到交易额最小的交易
    @Test
    public void test8() {
        Optional<Transaction> min = transactions.stream()
                .min((a, b) -> Integer.compare(a.getValue(), b.getValue()));
        System.out.println(min.get());
    }