Java8新特性(Lambda表达式、Stream流、Optional类)等

1. Lambda表达式由来

package java8;

public class EmployeeTest {
    public static void main(String[] args) {

        Employee employee1 = new EmployeeImpl();
        employee1.getSalary();
        System.out.println("****************");


        Employee employee2 = new Employee() {
            @Override
            public void getSalary() {
                System.out.println("Employee匿名内部类");
            }
        };
        employee2.getSalary();
        System.out.println("****************");

        /**
         * lambda表达式可以看作是一个接口的实例，使用lambda是有前提条件的，就是该接口必须是函数式接口。
         * 那么什么是函数式接口呢？用一句话总结就是有且仅有一个抽象方法的接口(在java提供的类库中，函数式接口上面都有@FunctionalInterface注解)
         *
         * lambda表达式可以总结为：一个(), 一个 ->, 一段代码{}
         * 一个()：参数
         * 一段代码{}：具体业务逻辑
         */
        Employee employee3 = () -> {
            System.out.println("将上述匿名内部类转为使用lambda表达式");
        };
        employee3.getSalary();
    }

    interface Employee {
        public void getSalary();
    }

    static class EmployeeImpl implements Employee {

        @Override
        public void getSalary() {
            System.out.print("Employee的普通实现类");
        }
    }
}

2. Stream流

2.1 函数型接口Function定义

package java8;

import java.util.function.Function;

/**
 * 1. 函数型接口Function<T,R>：有输入，有输出
 * 核心抽象方法为 抽象方法 R apply(T t);
 */
public class FunctionInterface1 {

    public static void main(String[] args) {
        // 通过lambda实例化一个接口，实现抽象方法R apply(T t);
        Function<String, Integer> function = (s) -> {
            if (s == null) {
                return 0;
            }
            return s.length();
        };
        Integer result = testFunction("hello", function);
        System.out.println(result);

        System.out.println("****************");
        System.out.println(testFunction("hello", s -> {
            return "更简化的写法".length();
        }));
    }


    // interface Function<T, R> 抽象方法 R apply(T t);
    private static Integer testFunction(String str, Function<String, Integer> function) {
        // str作为第13行的参数s进行传递
        return function.apply(str);
    }
}

 结果

5
****************
6

2.1 函数型接口Function类型

• 函数型接口Function<T,R>

  • 抽象方法 R apply(T t)

• 消费型接口Consumer<T>
  • 　抽象方法：void accept(T t)
• 供给型接口Supplier<T>
  • 　抽象方法：T get()
• 断言型接口Predicate<T>
  • 　抽象方法：boolean test(T t)

package java8;

import java.util.function.Function;

/**
 * 1. 函数型接口Function<T,R>：有输入，有输出
 * 核心抽象方法为 抽象方法 R apply(T t);
 */
public class FunctionInterface1 {

    public static void main(String[] args) {
        // 通过lambda实例化一个接口，实现抽象方法R apply(T t);
        Function<String, Integer> function = (s) -> {
            if (s == null) {
                return 0;
            }
            return s.length();
        };
        Integer result = testFunction("hello", function);
        System.out.println(result);

        System.out.println("****************");
        System.out.println(testFunction("hello", s -> {
            return "更简化的写法".length();
        }));
    }


    // interface Function<T, R> 抽象方法 R apply(T t);
    private static Integer testFunction(String str, Function<String, Integer> function) {
        // str作为第13行的参数s进行传递
        return function.apply(str);
    }
}

package java8;

import java.util.function.Consumer;

/**
 * Consumer<T> 消费性接口有输入，但是没有返回值
 *     抽象方法：void accept(T t);
 */
public class ConsuerFunctionInterface {

    public static void main(String[] args) {
        // s是实例化方法accept的参数，{}内部是accept的方法体
        testConsumer(s -> {System.out.println(s);}, "消费性接口抽象方法accept实现");
    }

    private static void testConsumer(Consumer<String> consumer, String str) {
        consumer.accept(str);
    }
}

package java8;


import java.util.function.Supplier;

/**
 * Supplier<T> 供给型接口：无输入、有输出
 *     抽象方法：T get();
 */
public class SupplierFunctionInterface {

    public static void main(String[] args) {

        // ()是实例化方法T get()参数：即无参数，{}是get的方法体
        testSupplier(()-> {
            String name = "Supplier<Person>的抽象方法get实现";
            System.out.println(name);
            return new Person(name);
        });
    }

    private static Person testSupplier(Supplier<Person> supplier) {
        return supplier.get();
    }

}

class Person {
    private static String name;

    Person(String name) {
        this.name = name;
    }
}

package java8;

import java.util.function.Predicate;

/**
 * 断言型接口Predicate<T>
 *     抽象方法：boolean test(T t);
 */
public class PredicateFunctionInterface {

    public static void main(String[] args) {
        // b是test方法的参数, {}内部是test方法体
        boolean res = testPredicate((b) -> {
            System.out.println("断言型接口Predicate抽象方法boolean test(T t)的实例化");
            return b > 99;
        }, 99);

        System.out.println("b>99, res=" + res);
    }


    private static boolean testPredicate(Predicate<Integer> predicate, int a) {
        return predicate.test(a);
    }
}

2.3 reduce

https://www.cnblogs.com/flydean/p/java-8-stream-reduce.html

https://www.liaoxuefeng.com/wiki/1252599548343744/1322402971648033

https://blog.csdn.net/qq_33351091/article/details/82494855

package mtee3rule;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;

public class ReduceTest {

    public static void main(String[] args) {
        List<Integer> intList = Arrays.asList(1,2,3,4);

        Optional<Integer> result1 = intList.stream().reduce(Integer::sum);
        System.out.println("result1=" + result1 + ", sum=" + result1.get());

        Integer result2=intList.stream().reduce(100, Integer::sum);
        System.out.println("result2=" + result2 + ", sum=" + result2);

        // 每个线程的初始累加值都是100，最后4个线程加出来的结果就是406
        // 这里sum方法的identity只能是0。所以这里我们传入100是不对的，因为sum（100+1）！= 1。
        // 如果我们用0作为identity,则stream和parallelStream计算出的结果是一样的。这就是identity的真正意图。
        Integer result3=intList.parallelStream().reduce(100, Integer::sum);
        System.out.println("result3=" + result2 + ", sum=" + result3);

        testMultiReduce1();
    }

    private static void testMultiReduce1() {
        List<String> strings = Arrays.asList("1", "2", "4", "5");

        System.out.println("********in testMultiReduce1()************");

        // 非并行流
        Integer reduce1 = strings.stream().reduce(0,
                (acc, e) -> acc + Integer.valueOf(e), (u, t) -> {
                    // 非并行流，不会执行第三个参数
                    System.out.println("u----:" + u);
                    // 这里的返回值并没有影响返回结果
                    return null;
                });
        System.out.println("reduce1:" + reduce1);

        // 并行流
        //System.out.println("out_thread=" + Thread.currentThread().getName());
        Integer reduce2 = strings.parallelStream().reduce(0,
                (acc, e) -> acc + Integer.valueOf(e), (u, t) -> {
                    // u，t分别为并行流每个子任务的结果
                    System.out.println("inner_thread=" + Thread.currentThread().getName() + ", u=" + u + ", t=" + t);

                    return u + t;
                });
        System.out.println("out_thread=" + Thread.currentThread().getName());
        System.out.println("reduce2:" + reduce2);
    }

}

结果：

result1=Optional[10], sum=10
result2=110, sum=110
result3=110, sum=410
********in testMultiReduce1()************
reduce1:12
inner_thread=ForkJoinPool.commonPool-worker-2, u=1, t=2    // 第一个线程执行
inner_thread=main, u=4, t=5                                // 第二个线程执行
inner_thread=main, u=3, t=9                                // u为第6行执行结果3，t为第7行执行结果9
out_thread=main
reduce2:12                                                 // 第8行执行结果 = 3 + 9

2.4 创建Stream流的方式

 2.4.1 ::（双冒号）使用

https://www.jianshu.com/p/96b4815d629e

package java8;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;

public class DoubleMaoHao {

    public static void main(String[] args) {
        List<String> listStr = Arrays.asList("adnm", "p", "admmt", "pot", "xbangd", "weoujgsd");

        // 最大的串：实例化Comparator的抽象方法int compare(T o1, T o2)
        // (o1, o2)有两个参数，o1作为当前对象，o2作为参数，都是String；返回值为int —— 其它方法满足这样条件的也可以
        Optional<String> optionalMax1 = listStr.stream().max(((o1, o2) -> { return o1.compareTo(o2);} ));

        // 简写
        // 而String::compareTo方法是指int compareTo(String anotherString)--即参数为string,返回值为int的
        // 其它方法 public int indexOf(String str) --即参数为string,返回值为int的 也可以，但是int length() 无参数的方法就不行
        Optional<String> optionalMax2 = listStr.stream().max(String::compareTo);  // String::length报错

        System.out.println("optionalMax1=" + optionalMax1.get() + ", optionalMax2=" + optionalMax2.get());  // optionalMax3=adnm, optionalMax4=w3


        List<String> listStr3 = Arrays.asList("adnm", "dn", "n");
        List<String> listStr4 = Arrays.asList("adnm", "w3", "3");
        Optional<String> optionalMax3 = listStr3.stream().max(String::indexOf);  // adnm.indexOf("dn")>0, "dn".indexOf("n")>0
        Optional<String> optionalMax4 = listStr4.stream().max(String::indexOf); // adnm.indexOf("w3")<0, "w3".indexOf("3")>0
        System.out.println("optionalMax3=" + optionalMax3.get() + ", optionalMax4=" + optionalMax4.get());  // optionalMax3=adnm, optionalMax4=w3

        Optional<String> optionalMax5 = listStr.stream().max((o1,o2) -> {return 1;});  // >=0：adnm 即两两比较 前面最大； <0，则最后一个最大
        System.out.println("optionalMax5=" + optionalMax5.get());  // max=adnm （第0个）

        Optional<String> optionalMax6 = listStr.stream().max((o1,o2) -> {return -1;});  // >=0：adnm 即两两比较 前面最大； <0，则最后一个最大
        System.out.println("optionalMax6=" + optionalMax6.get());  // max=weoujgsd （最后一个）


        /**
         * max()方法中需要一个函数式接口Comparator<T>
         * comparing方法中需要一个函数型接口Function<T, R>，唯一的抽象方法为R apply(T t);
         * x作为Function方法的参数，到了Function方法体里 x作为对象来调用 无参数方法（这里x是String类型，则可以调用String的所有无参方法且返回值为int）
         */
        Optional<String> max1 = listStr.stream().max(Comparator.comparing((x) -> {
            return x.length();
        }));
        Optional<String> max2 = listStr.stream().max(Comparator.comparing((x) -> {
            return 1;
        }));
        Optional<String> max3 = listStr.stream().max(Comparator.comparing((x) -> {
            return -1;
        }));
        // 要看comparing内部的实现Function keyExtractor  (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
        System.out.println("max1=" + max1.get() + ", max2=" + max2.get() + ", max3=" + max3.get());  // max1=weoujgsd, max2=adnm, max3=adnm

        // 简写形式——使用了静态方法Comparator.comparing，比较的是length属性，
        Optional<String> max1_1 = listStr.stream().max(Comparator.comparing(String::length));  // String::compareTo报错
        System.out.println("简写_最长的字符串 max1_1：" + max1_1.get());
    }
}

结果：

optionalMax1=xbangd, optionalMax2=xbangd
optionalMax3=adnm, optionalMax4=w3
optionalMax5=adnm
optionalMax6=weoujgsd
max1=weoujgsd, max2=adnm, max3=adnm
简写_最长的字符串 max1_1：weoujgsd

参考文献：

1.https://zhuanlan.zhihu.com/p/340538961

2.https://blog.csdn.net/yczz/article/details/50896975

3.https://blog.csdn.net/love905661433/article/details/86422169