JDK8的三个新特性(Lambda表达式,Stream流,Optional类)

JDK8的三个新特性(Lambda表达式,Stream流,Optional类) Lambda表达式

在使用Lambda表达式之前必须了解函数式接口,因为它式在此基础上使用的

public class Lambda02 {
    public static void main(String[] args) {
        Consumer con = (a) -> System.out.println(a);
        con.accept("hello");

        Supplier sub = () -> {
            int a = 0;
            for (int i = 0; i < 10; i++) {
              a += i;
            }
            return a;
        };
        System.out.println(sub.get());


        Function fun = (a) -> {
            return a;
        };
        System.out.println(fun.apply(100));


        Predicate pre = (a) -> a<100;
        System.out.println(pre.test(99));
        List strList = Arrays.asList("北京","南京","普京","上海");
        List stringList = filterStr(strList, a -> a.contains("京"));
        System.out.println(stringList);

    }
    //函数作为一个对象传进去 --- Predicate pre 函数对象
    public  static List filterStr(List list, Predicate pre){
        List filterList = new ArrayList<>();
        for (String str: list) {
            if(pre.test(str)){
                filterList.add(str);
            }
        }
        return filterList;
    }
}

编写规则

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


        
        GreetingService greetingService = new GreetingService(){
            @Override
            public void sayMessage(String message) {
                System.out.println(message);
            }
        };
        greetingService.sayMessage("之前写法");

      
        GreetingService greetingService1 = message -> System.out.println(message);
        greetingService1.sayMessage("Lambda写法");

        //1.无参,无返回值
        Runnable runnable = () -> {
            System.out.println("1.无参,无返回值");
        };
        runnable.run();
        //2.一个参数,无返回值
        Consumer con = (String a) -> {
            System.out.println(a);
        };
        con.accept("2.一个参数,无返回值");
        //3.数据类型省略-类型推断
        Consumer con1 = (a) -> {
            System.out.println(a);
        };
        con.accept("3.数据类型省略-类型推断");
        //4.一个参数时,小括号可以省略
        Consumer con2 = a -> {
            System.out.println(a);
        };
        con.accept("4.一个参数时,小括号可以省略");
        //5.两个或以上的参数,多条语句,有返回值
        Comparator com = (o1,o2) ->{
            System.out.println(o1);
            System.out.println(o2);
            System.out.println("5.两个或以上的参数,多条语句,有返回值");
            return o1.compareTo(o2);
        };
        //6.若只有一条执行语句,return 和 大括号都可以省略
        Comparator com2 = (o1,o2) -> o1.compareTo(o2);
        int compare = com2.compare(1, 2);
        System.out.println("若只有一条执行语句,return 和 大括号都可以省略");
    }

   
    interface GreetingService {
        void sayMessage(String message);
    }

方法引用

public class MethodRef {
    public static void main(String[] args) {
        //对象::实例方法
        Consumer con = str -> System.out.println(str);
        con.accept("bbb");
//        PrintStream out = System.out;
        Consumer con1 =  System.out::println;
        con1.accept("aaaa");

        //类::静态方法
        Comparator com = (t1,t2) -> Integer.compare(t1,t2);
        System.out.println(com.compare(12, 3));

        Comparator com2 = Integer::compare;
        System.out.println(com2.compare(3,12));

        //类::实例方法
        Comparator cor = (t1,t2) -> t1.compareTo(t2);
        System.out.println(cor.compare("a", "b"));

        Comparator cor2 = String::compareTo;
        System.out.println(cor2.compare("b", "a"));


        //数组引用(参考)
        Function fun = length -> new String[length];
        String[] apply = fun.apply(5);
        System.out.println(Arrays.toString(apply));

        Function fun2 = String[]::new;
        String[] apply1 = fun.apply(5);
        System.out.println(Arrays.toString(apply1));
    }

Stream流

创建方式

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