java8 array、list操作 汇【2】）- （Function,Consumer,Predicate,Supplier）应用

    static class UserT {
        String name;

        public UserT(String zm) {
            this.name=zm;
        }

        public String getName() {
            return name;
        }

        public  void setName(String name) {
            this.name = name;
        }
    }
    static class Student {
        String firstName;
        String lastName;
        Double grade;
        Double feeDiscount = 0.0;
        Double baseFee = 2000.0;
        public Student(String firstName, String lastName, Double grade) {
            this.firstName = firstName;
            this.lastName = lastName;
            this.grade = grade;
        }
        public void printFee(){
            Double newFee = baseFee - ((baseFee * feeDiscount)/100);
            System.out.println("The fee after discount: " + newFee);
        }
    }

    public static void main(String[] args){

        System.out.println("一、Consumer: ");
    /* 来源： https://www.cnblogs.com/lijingran/p/8708037.html
     //一、Consumer
        描述：Consumer< T>接口接受一个T类型参数，没有返回值。
        源代码： public interface Consumer<T> { void accept(T t); }
        java8以前的实现如下：
        UserT userT = new UserT("zm");
        this.change(userT);
        private void change(UserT userT){
            userT.setName("zmChange");
        }
    */
        UserT userT = new UserT("zm");
        //接受一个参数
        Consumer<UserT> userTConsumera = userT1 -> userT1.setName("zmChange");
        userTConsumera.accept(userT);
        System.out.println(userT.getName());//输出zmChange

        System.out.println("二、Predicate应用: ");
    /*  来源： http://www.importnew.com/16436.html
     //二、Predicate应用
        Predicate和Consumer接口的test()和accept()方法都接受一个泛型参数。不同的是test()方法进行某些逻辑判断并返回一个boolean值，
        而accept()接受并改变某个对象的内部值。updateStudentFee方法的调用如下所示：
    */
        Student stu1 = new Student("Ashok","Kumar", 9.5);
        stu1 = updateStudentFee(
                stu1,
                student -> student.grade > 8.5,       //Lambda expression for Predicate interface
                student -> student.feeDiscount = 30.0 //Lambda expression for Consumer inerface
        );
        stu1.printFee(); //The fee after discount: 1400.0

        Student stu2 = new Student("Rajat","Verma", 8.0);
        stu2 = updateStudentFee(stu2,
                                    student -> student.grade >= 8,
                                    student -> student.feeDiscount = 20.0);
        stu2.printFee();//The fee after discount: 1600.0

        System.out.println("100、java.util.function.Predicate: ");

        List<String> listTest = Arrays.asList("Java", "Scala", "C++", "Haskell", "Lisp");

        System.out.println("Languages which starts with J :");

        Predicate<String> startsWithJ   = (n) -> n.startsWith("J");
        Predicate<String> endsWitha     = (n) -> n.endsWith("a");
        Predicate<String> lengthGrater4 = (n) -> n.length() > 4;
        Predicate<String> length4       = (n) -> n.length() == 4;

        System.out.println("Languages which starts with J :");
        filter(listTest, startsWithJ);
        System.out.println("Languages which ends with a ");
        filter(listTest, endsWitha);
        System.out.println("Print all listTest :");
        filter(listTest, (str)->true);
        System.out.println("Print no language : ");
        filter(listTest, (str)->false);
        System.out.println("Print language whose length greater than 4:");
        filter(listTest, lengthGrater4);

        System.out.println("三、如何在lambda表达式中加入Predicate: ");
    /*
     //三、如何在lambda表达式中加入Predicate
        甚至可以用and()、or()和xor()逻辑函数来合并Predicate， 例如要找到所有以J开始，长度为四个字母的名字，你可以合并两个Predicate并传入
    */
        listTest.stream()
                .filter(startsWithJ.and(length4))
                .forEach((n) -> System.out.print("nName, which starts with 'J' and four letter long is : " + n));

        System.out.println("四、lambda表达式的Map和Reduce示例: ");
    /*
     //四、lambda表达式的Map和Reduce示例
        Predicate和Consumer接口的test()和accept()方法都接受一个泛型参数。不同的是test()方法进行某些逻辑判断并返回一个boolean值，
        而accept()接受并改变某个对象的内部值。updateStudentFee方法的调用如下所示：
    */

        // 不使用lambda表达式为每个订单加上12%的税
        List<Integer> costBeforeTax = Arrays.asList(100, 200, 300, 400, 500);
        for (Integer cost : costBeforeTax) {
            double price = cost + .12*cost;
            System.out.println(price);
        }

        // 使用lambda表达式
        /*
        函数式编程概念map 允许你将对象进行转换。例如在本例中，我们将 costBeforeTax 列表的每个元素转换成为税后的值。
        我们将 x -> x*x lambda表达式传到 map() 方法，后者将其应用到流中的每一个元素。然后用 forEach() 将列表元素打印出来。使用流API的收集器类，
        可以得到所有含税的开销。有 toList() 这样的方法将 map 或任何其他操作的结果合并起来。由于收集器在流上做终端操作，因此之后便不能重用流了。
        你甚至可以用流API的 reduce() 方法将所有数字合成一个，下一个例子将会讲到。
        */
        List costBeforeTax1 = Arrays.asList(100, 200, 300, 400, 500);
                        costBeforeTax.stream().map((cost) -> cost + .12*cost).forEach(System.out::println);

        // 新方法：
        /*
        在上个例子中，可以看到map将集合类（例如列表）元素进行转换的。还有一个 reduce() 函数可以将所有值合并成一个。Map和Reduce操作是函数式编程的核心操作，
        因为其功能，reduce 又被称为折叠操作。另外，reduce 并不是一个新的操作，你有可能已经在使用它。SQL中类似 sum()、avg() 或者 count() 的聚集函数，
        实际上就是 reduce 操作，因为它们接收多个值并返回一个值。流API定义的 reduceh() 函数可以接受lambda表达式，并对所有值进行合并。IntStream这样的类有
        类似 average()、count()、sum() 的内建方法来做 reduce 操作，也有mapToLong()、mapToDouble() 方法来做转换。这并不会限制你，你可以用内建方法，也可以自己定义。
        在这个Java 8的Map Reduce示例里，我们首先对所有价格应用 12% 的VAT，然后用 reduce() 方法计算总和。
        */
        List costBeforeTax2 = Arrays.asList(100, 200, 300, 400, 500);
        double bill =   costBeforeTax.stream().map((cost) -> cost + .12*cost).reduce((sum, cost) -> sum + cost).get();
        System.out.println("Total : " + bill); //1680.0

        System.out.println("五、通过过滤创建一个String列表: ");
    /*
     //五、通过过滤创建一个String列表
    */
        // 创建一个字符串列表，每个字符串长度大于2

        List<String> filtered = listTest.stream().filter(lengthGrater4).collect(Collectors.toList());
        System.out.printf("Original_0 List : %s,   filtered_1 list : %s %n",   listTest,  filtered);

        System.out.println("六、对列表的每个元素应用函数: ");
        //六、对列表的每个元素应用函数
        // 将字符串换成大写并用逗号链接起来
        List<String> G7 = Arrays.asList("USA", "Japan", "France", "Germany", "Italy", "U.K.","Canada");
        String G7Countries = G7.stream().map(x -> x.toUpperCase()).collect(Collectors.joining(", "));
        System.out.println(G7Countries);

        System.out.println("九、复制不同的值，创建一个子列表: ");
        //九、复制不同的值，创建一个子列表
        // 用所有不同的数字创建一个正方形列表
        List<Integer> numbers = Arrays.asList(9, 10, 3, 4, 7, 3, 4);
        List<Integer> distinct = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());
        System.out.printf("Original List : %s,  Square Without duplicates : %s %n", numbers, distinct);

        System.out.println("10、计算集合元素的最大值、最小值、总和以及平均值: ");
        //10、计算集合元素的最大值、最小值、总和以及平均值
        //获取数字的个数、最小值、最大值、总和以及平均值
        List<Integer> primes = Arrays.asList(2, 3, 5, 7, 11, 13, 17, 19, 23, 29);
        IntSummaryStatistics stats = primes.stream().mapToInt((x) -> x).summaryStatistics();
        System.out.println("Highest prime number in List : " + stats.getMax());
        System.out.println("Lowest prime number in List : " + stats.getMin());
        System.out.println("Sum of all prime numbers : " + stats.getSum());
        System.out.println("Average of all prime numbers : " + stats.getAverage());

    }

    //二、Predicate应用
    public static void filter(List<String> names, Predicate condition) {
        for(String name: names)  {
            if(condition.test(name)) {
                System.out.println(name + " ");
            }
        }
    }
//    // 更好的办法:简化成lambda表达式：
//    public static void filter(List<String> names, Predicate condition) {
//        names.stream().filter((name) -> (condition.test(name))).forEach((name) -> {
//            System.out.println(name + " ");
//        });
//    }

    //声明一个接受Student对象的Predicate接口以及Consumer接口的实现类。
    public static Student updateStudentFee(Student student, Predicate<Student> predicate, Consumer<Student> consumer){
        if (predicate.test(student)){   //断输入的Student对象是否拥有费用打折的资格
            consumer.accept(student);   //更新输入的Student对象的折扣
        }
        return student;
    }