精华内容
下载资源
问答
  • JDK8新特性

    万次阅读 2019-09-08 21:06:42
    关于jdk8的改变大体有对lambda表达式(借鉴其他语言的函数式编程方式)简化很多啰嗦的代码,还有就是流的操作,类似把集合当做数据库,java的流操作当做SQL,这样方便对集合的数据进行操作,当然对JDK的升级还有很多,这里...

    关于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();
    }
    

     

    展开全文
  • jdk8新特性

    2017-11-22 09:26:00
    jdk8新特性,百度云盘。jdk8新特性,百度云盘。jdk8新特性,百度云盘。
  • JDK 8 新特性

    2019-10-04 13:46:51
    JDK 8, Oracle's implementation of Java SE 8. ...本文分析 JDK 8 引入的新特性。 官方文档:http://www.oracle.com/technetwork/java/javase/8-whats-new-2157071.html。 1、Java progra...

    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 新特性

    2018-01-30 10:29:16
    一 JDK8 特性 1.Lambda表达式 2.Stream函数式操作流元素集合 3.接口新增:默认方法与静态方法 4.方法引用,与Lambda表达式联合使用 5.引入重复注解 6.类型注解 7.最新的Date/Time API (JSR 310...

    一  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改善易用性;


    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,810
精华内容 3,524
关键字:

jdk8新特性