关于jdk8的改变大体有对lambda表达式(紧跟函数式编程方式潮流,其实也是对设计模式的一种简化,比如函数式接口的使用你能够感受到和策略模式很相似,并且写法更加优雅)简化很多啰嗦的代码,还有就是流的操作,类似把集合当做数据库,java的流操作当做写SQL,这样方便对集合的数据进行操作,当然对JDK的升级还有很多,这里只是小结一些常用的.

Gitee https://gitee.com/zhang-xiao-xiang/all-demo-parent.git    里面的javabase包下jdk8

语法格式如下:



 语法阐述:

  ->左边：lambda形参列表的参数类型可以省略(类型推断)；如果lambda形参列表只有一个参数，其一对()也可以省略
  ->右边：lambda体应该使用一对{}包裹；如果lambda体只有一条执行语句（可能是return语句），省略这一对{}和return关键字
  Lambda表达式的本质：作为函数式接口的实例
  如果一个接口中，只声明了一个抽象方法，则此接口就称为函数式接口。我们可以在一个接口上使用 @FunctionalInterface 注解，
  这样做可以检查它是否是一个函数式接口。
 所以以前用匿名实现类表示的现在都可以用Lambda表达式来写

1:简单lambda表达式试用

package com.zhang.zxx.jdk8.lambda;


import org.junit.Test;

import java.util.Comparator;

/**
 * LambdaTest:Lambda表达式的使用举例
 *
 * @author zhangxiaoxiang
 * @date 2020/10/8
 */
public class LambdaTest {
    /**
     * 例子1  没有入参,没有返回值的一个例子=>Runnable线程的类为例子
     */
    @Test
    public void test1() {
        /**
         * 没有使用lambda表达式的写法(其实idea会提示使用)线程的匿名实现类的写法
         */
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("我执行常规写法,匿名实现的写法!");
            }
        };

        r1.run();
        Runnable r2 = () -> System.out.println("我执行jdk8提供的lambda写法");
        r2.run();
    }

    /**
     * 例子2  有入参有返回值的一个例子=>Comparator用于比较的类为例子
     */
    @Test
    public void test2() {
        Comparator<Integer> com1 = new Comparator<Integer>() {
            /**
             * compare方法比较2这个
             * @param o1 待比较的数o1
             * @param o2 待比较的数o2
             * @return o1比o2大返回1小则返回-1,相等返回0
             */
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1, o2);
            }
        };
        int compare1 = com1.compare(12, 21);
        System.out.println("原始写法***********************");
        System.out.println("常规写法的返回(12比21小,所以这里返回 -1): " + compare1);

        //Lambda表达式的写法(还可以改.idea会提示你)
        Comparator<Integer> com2 = (o1, o2) -> Integer.compare(o1, o2);
        int compare2 = com2.compare(32, 21);
        System.out.println("Lambda表达式的写法(常规一点的)***********************");
        System.out.println("常规一点的的返回(32比21大返回 1): " + compare2);

        Comparator<Integer> com3 = Integer::compare;
        int compare3 = com3.compare(32, 32);
        System.out.println("Lambda表达式的写法(方法引用的方式)***********************");
        System.out.println("Lambda表达式方法引用返回(32和32相等返回 0): " + compare3);
    }

}


2:多种lambda表达式详细写法小结

package com.zhang.zxx.jdk8.lambda;


import org.junit.Test;

import java.util.Comparator;
import java.util.function.Consumer;

/**
 * Lambda1Test:多钟Lambda写法举例
 *
 * @author zhangxiaoxiang
 * @date 2020/10/8
 */
public class Lambda1Test {
    /**
     * 语法格式一：(最简洁性)无参，无返回值
     */
    @Test
    public void test1() {
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("语法格式一：无参，无返回值");
            }
        };
        r1.run();
        System.out.println("***********************");
        Runnable r2 = () -> {
            System.out.println("语法格式一：无参，无返回值");
        };
        r2.run();
    }

    /**
     * 语法格式二：(消费型)需要一个参数，但是没有返回值。
     */
    @Test
    public void test2() {
        Consumer<String> con = new Consumer<String>() {
            /**
             *
             * @param s 待消费的参数,注意没有返回值
             */
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con.accept("我是普通写法的入参");
        System.out.println("*******************");
        //如果只有一段简单的实现代码,{}也可以不要  Consumer<String> con1 = (String s) -> {System.out.println(s);};
        // 这里idea会提示Lambda can be replaced with method reference ,可以使用方法写法引用替代,在后面会有示例,这里就保持这种写法
        Consumer<String> con1 = (String s) -> System.out.println(s);
        con1.accept("我是Lambda写法的入参,左边是形参 ->右边是实现,将参数消费");

    }

    /**
     * 语法格式三：(类型推断型)数据类型可以省略，因为可由编译器推断得出，称为“类型推断”,双冒号::写法
     */
    @Test
    public void test3() {
        //idea会建议Lambda can be replaced with method reference
        Consumer<String> con1 = (String s) -> {
            System.out.println(s);
        };
        con1.accept("数据类型可以省略,类型推断的入参");
        System.out.println("*******************");
        //这就是idea建议的Lambda的方法引用method reference 写法
        Consumer<String> con2 = System.out::println;
        con2.accept("::就是方法引用的方式,称为“类型推断”的入参");

    }


    /**
     * 语法格式四：(单参数不要括号)Lambda 若只需要一个参数时，参数的小括号可以省略
     */
    @Test
    public void test4() {
        Consumer<String> con1 = (s) -> {
            System.out.println(s);
        };
        con1.accept("Lambda还可以进一步简化的入参");
        System.out.println("*******************");
        Consumer<String> con2 = System.out::println;
        con2.accept("Lambda 若只需要一个参数时，参数的小括号可以省略的入参");
    }

    /**
     * 语法格式五：(多参数并带返回值)Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值
     */
    @Test
    public void test5() {
        Comparator<Integer> com1 = new Comparator<Integer>() {
            /**
             * compare方法比较2这个
             * @param o1 待比较的数o1
             * @param o2 待比较的数o2
             * @return o1比o2大返回1小则返回-1,相等返回0
             */
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println("两个入参分别是:" + o1 + "  " + o2);
                return o1.compareTo(o2);
            }
        };
        System.out.println("常规写法比较结果(12比21小返回-1): " + com1.compare(12, 21));
        System.out.println("*****************************");
        Comparator<Integer> com2 = (o1, o2) -> {
            System.out.println("两个入参分别是:" + o1 + "  " + o2);
            return o1.compareTo(o2);
        };
        System.out.println("Lambda写法比较结果(12比21小返回-1): " + com2.compare(12, 21));
    }

    /**
     * 语法格式六：当 Lambda 体只有一条语句时，return 与大括号若有，都可以省略
     */
    @Test
    public void test6() {
        Comparator<Integer> com1 = (o1, o2) -> {
            return o1.compareTo(o2);
        };
        System.out.println(com1.compare(12, 21));
        System.out.println("*****************************");
        //Lambda 体只有一条语句时，return 与大括号若有，都可以省略
        Comparator<Integer> com2 = (o1, o2) -> o1.compareTo(o2);
        System.out.println(com2.compare(12, 21));
        //在进一步使用方法引用(推荐)
        Comparator<Integer> com3 = Integer::compareTo;
        System.out.println(com3.compare(12, 21));
    }

}


3:java内置函数式接口(Consumer和Predicate为例子)

package com.zhang.zxx.jdk8.lambda;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;

/**
 * LambdaTest2 :内置函数式接口(Consumer和Predicate为例子)
 * <p>
 * 消费型接口 Consumer<T>     void accept(T t)
 * 供给型接口 Supplier<T>     T get()
 * 函数型接口 Function<T,R>   R apply(T t)
 * 断定型接口 Predicate<T>    boolean test(T t)
 *
 * @author zhangxiaoxiang
 * @date 2020/10/8
 */
public class Lambda2Test {
    /**
     * 消费型接口 输入参数有因无果,被消费了你说气了不气人
     *
     * @param money 金额
     * @param con   消费业务
     */
    public void happyTime(double money, Consumer<Double> con) {
        con.accept(money);
    }

    /**
     * 测试消费型
     */
    @Test
    public void test1() {
        happyTime(500, new Consumer<Double>() {
            @Override
            public void accept(Double aDouble) {
                System.out.println("消费输出:您老消费的价格是" + aDouble);
            }
        });
        System.out.println("********************");
        happyTime(400, money -> System.out.println("消费输出:您老消费的价格是：" + money));
    }

    /**
     * 断定型接口
     * 根据给定的规则，过滤集合中的字符串。此规则由Predicate的方法决定
     *
     * @param list 给定基础数据数据
     * @param pre  断定规则
     * @return
     */
    public List<String> filterString(List<String> list, Predicate<String> pre) {
        ArrayList<String> filterList = new ArrayList<>();
        for (String s : list) {
            //这个test()方法是判断是否包含:根据给定参数评估该谓词
            if (pre.test(s)) {
                filterList.add(s);
            }
        }
        return filterList;
    }

    /**
     * 测试断定型接口
     */
    @Test
    public void test2() {
        List<String> list = Arrays.asList("北京", "南京", "天津", "东京", "西京", "普京");
        List<String> filterStrS = filterString(list, new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.contains("京");
            }
        });
        System.out.println("将含有京的筛选出来:"+filterStrS);
        List<String> filterStrS1 = filterString(list, s -> s.contains("京"));
        System.out.println("将含有京的筛选出来:"+filterStrS1);
    }
}

 4:自定义函数式接口

package java1;

/**
 * MyInterface:自定义函数式接口
 * 
 * @author zhangxiaoxiang
 * @date 2019/9/8
 */
@FunctionalInterface
public interface MyInterface {

    void method1();

//    void method2();
}


 

    
JDK 8, Oracle's implementation of Java SE 8.
JDK 8 是 Oracle 对 Java SE 8 规范的实现。
本文分析 JDK 8 引入的新特性。
官方文档：http://www.oracle.com/technetwork/java/javase/8-whats-new-2157071.html。
 
1、Java programming language
在 Java 语言层面，最大的改动是：
引入了 lambda 表达式；
引入了 default method，保证了对历史代码的二进制兼容性；
引入了 method reference，和 lambda expression 配合使用。
2、Collections
集合框架最大的改动是新增了java.util.stream package，可以将 collection 作为 stream 来处理，和 lambda expression 配合使用；
对 HashMap 中的 key collision 做了性能改进。
3、Security
新增了对一些加密算法的支持。
4、Tools
新增了一些工具和功能。
5、IO and NIO
6、Concurrency
java.util.concurrent 新增了一些类；
java.util.concurrent.ConcurrentHashMap 新增了一些方法，支持 stream 和 lambda expression；
java.util.concurrent.atomic 新增了一些类；
java.util.concurrent.ForkJoinPool 新增了一些方法；
新增了java.util.concurrent.locks.StampedLock class。
 7、HotSpot
移除了 PermGen；
提供了对 default method 的字节码支持。
 

转载于:https://www.cnblogs.com/huangzejun/p/9472763.html

一  JDK8 特性


1.Lambda表达式


2.Stream函数式操作流元素集合


3.接口新增：默认方法与静态方法


4.方法引用,与Lambda表达式联合使用


5.引入重复注解


6.类型注解


7.最新的Date/Time API (JSR 310)


8.新增base64加解密API


9.数组并行（parallel）操作


10.JVM的PermGen空间被移除：取代它的是Metaspace（JEP 122）元空间


二 各版本区别


JDK7主要是提高易用性，提高性能，增加JSR 292；


JDK8主要是lambda和stream API，以及进一步提高性能；


JDK9主要是模块化（JPMS），以及进一步提高性能；还趁着模块化功能新加了jimage、jlink、jaotc等新玩意儿，以及新增jshell改善易用性；