精华内容
下载资源
问答
  • jdk8新特性
    千次阅读
    2018-06-06 11:13:14
    List<Integer> numbers = new ArrayList<>();
    
    //no.1
    numbers.forEach((Integer integer) -> {
        System.out.println(integer);
    });
    
    //no.2
    numbers.forEach(integer -> {
        System.out.println(integer);
    });
    
    //no.3
    numbers.forEach(integer -> System.out.println(integer));
    
    //no.4
    numbers.forEach(System.out::println);
    
    //no.5
    numbers.forEach(new MyConsumer());//基于MyConsumer类
    
    
    
    
    
    MyConsumer类如下,主要是接口的实现
    
    class MyConsumer implements Consumer<Integer>{
        @Override
        public void accept(Integer integer) {
            System.out.println(integer);
        }
    }

    更多相关内容
  • JDK8新特性

    千人学习 2020-01-14 10:44:01
    JDK8是Java升级变化最大的一个版本,JDK8引入很多的写法,比如函数式接口、Lambda表达式、Stream函数式操作流元素集合、接口的默认方法、接口的静态方法等。 JDK8是Java升级变化最大的一个版本,JDK8引入很多的...
  • 借鉴前人经验,在经过不断实践之后,将Strean流部分方法整理成适合于自身需要的文档,供大家借鉴分享。
  • jdk8新特性

    2017-11-22 09:26:00
    jdk8新特性,百度云盘。jdk8新特性,百度云盘。jdk8新特性,百度云盘。
  • JDK8 新特性学习.rar

    2020-01-19 16:31:28
    如果你不会JDK1.8的新特性,这部资料绝对物超所值,里面有JDK1.8新特性的入门文档,还有自己整理的性能对比等给同事学习分享笔记,看完学习稍微实践一下,就可以完成入门到上手了,纯干货,5分不贵哈。
  • JDK5,JDK8新特性.ppt .ppt

    2022-01-03 12:20:05
    参考使用,欢迎下载
  • jdk8新特性demo

    2020-01-15 15:32:51
    jdk8新特性演示demo,主要包含lambda表达式的使用,方法引用的使用,stream流式操作的使用等演示demo,然后就么有了
  • Lambda表达式主要是替换了原有匿名内部类的写法,也就是简化了匿名内部类的写法。这篇文章主要介绍了JDK8新特性之Lambda表达式,非常不错感兴趣的朋友参考下吧
  • #JDK8新特性#JDK8新特性

    2022-06-10 11:57:40
    JDK8新特性
  • jdk8新特性.zip

    2019-09-29 15:44:41
    JDK1.8已经发布很久了,在很多企业中都已经在使用。并且Spring5、SpringBoot2.0都推荐使用JDK1.8以上版本...Java8新特性如下: Lambda表达式 函数式接口 方法引用 接口的默认方法和静态方法 Optional Streams 并行数组
  • jdk8新特性例子

    2014-10-23 11:40:26
    Jdk8新特性例子,内容包含 接口默认方法, 函数引用, java.util.stream api 和java.time api map的新增方法等。例子采用记事本编写,下载者需自行下载jdk8安装并配置好环境,编译(javac)运行(java)
  • day22_JDK8新特性.pdf

    2021-11-02 11:32:36
    day22_JDK8新特性.pdf
  • 主要介绍了JDK8新特性——Lambda表达式的相关资料,帮助大家更好的理解和学习JAVA开发,感兴趣的朋友可以了解下
  • 主要介绍了JDK8新特性之判空遍历写法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • jdk8新特性,有兴趣的同学可以下载看看
  • JDK8核心新特性

    2021-06-20 20:02:08
    JDK8已经发行有几年了,在该版本中推出了不少新特性,其中比较有代表的新特性有:Lambda表达式,Stream流,方法引用。在网上也有很多关于这些新特性的介绍,但个人觉得网上的很多文字对新特性的介绍是不够全面的,...
  • jdk8新特性.md

    2020-04-15 20:41:34
    jdk8相关特性使用的说明文档
  • Java JDK8新特性Lambda表达式

    千次阅读 2022-03-14 13:38:49
    jdk8 自定义了简单的四个函数式接口: @FunctionalInterface public interface Predicate { //接收一个参数t,返回boolean boolean test(T t); //创建predicate实例, predicate.and(other), 结果为 predicate.test...

    1.Lambda表达式

    Lambd表达式可以理解为一种可传递的匿名函数。它没有名称,但有参数列表、函数主体、返回类型,还有可能会抛出异常。在package java.util中有一个接口,接着创建苹果类:

    @FunctionalInterface
    public interface Comparator<T> {
        int compare(T o1, T o2);
        ...
    }
    public class Apple {
        private int weight;
        private String color;
    
        public Apple(int weight, String color) {
            this.weight = weight;
            this.color = color;
        }
    
        public int getWeight() {
            return weight;
        }
    
        public void setWeight(int weight) {
            this.weight = weight;
        }
    
        public String getColor() {
            return color;
        }
    
        public void setColor(String color) {
            this.color = color;
        }
    }

            匿名类的表达形式:

    Comparator<Apple> appleComparator = new Comparator<Apple>() {
                @Override
                public int compare(Apple o1, Apple o2) {
                    return o1.getWeight()-o2.getWeight();
                }
    };

            Lambda表达式形式:

    Comparator<Apple> appleComparator1 = (Apple apple1, Apple apple2)->
                    apple1.getWeight()-apple1.getWeight();

             可以看到Lambda表达式更简单:

                    1. ()->{}  无参,{}做处理;

                    2.()->retrun 值; 无参,返回值;

                    3.(String s)->s 有参,返回值;

                    4.(String s)->{} 有参,做处理。

    2.函数式接口

            只定义一个抽象方法的接口。它就是函数式接口。@FuntionallInterface注解,表示会设计成一个函数接口,不符合规范,会编译报错。

            jdk8 自定义了简单的四个函数式接口:

    @FunctionalInterface
    public interface Predicate<T> {
        //接收一个参数t,返回boolean
        boolean test(T t);
        //创建predicate实例, predicate.and(other),
                             结果为 predicate.test(t) and other.test(t)
        default Predicate<T> and(Predicate<? super T> other);
        
        //创建predicate实例, predicate.or(other),
                             结果为 predicate.test(t) or other.test(t)
        default Predicate<T> or(Predicate<? super T> other);
        
        //创建predicate实例, predicate.negate()
                             结果为 !predicate.test(t)
        default Predicate<T> negate()
        
        // Predicate.isEuqal("true").test("true")    
        static <T> Predicate<T> isEqual(Object targetRef) 
    }

    对应的测试结果:

    Predicate<String>  predicate1=s->Boolean.parseBoolean(s);
    System.out.println(predicate1.test("true")); //true
    System.out.println(predicate1.and(s -> Boolean.parseBoolean(s)).test("false"));//false
    System.out.println(predicate1.or(s -> Boolean.parseBoolean(s)).test("false"));//false
    System.out.println(predicate1.negate().test("true"));//false
    System.out.println(Predicate.isEqual("true").test("true"));//true
    @FunctionalInterface
    public interface Consumer<T> {
    
        //接受一个参数t
        void accept(T t);
    
        //创建一个consumer实例, consumer.andThen(after)
                                结果 先运行consumer.accept(t) ,接着运行 after.accept(t)
        default Consumer<T> andThen(Consumer<? super T> after);
    }
    

    对应的测试结果:

    Consumer<String> consumer= s-> System.out.println(s+"1");
    consumer.accept("1");//11
    consumer.andThen(s-> System.out.println(s+"2")).accept("1");//输出11 换行12
    @FunctionalInterface
    public interface Function<T, R> {
    
        //输入t,返回r
        R apply(T t);
        
        //创建一个function实例, r= function.compose(before)
                                的结果 t = before.apply(v); r=function.apply(t)
        default <V> Function<V, R> compose(Function<? super V, ? extends T> before);
        
       //创建一个function实例, r=function.andThen(after)
                                的结果 v = function.apply(t); r=after.apply(v)
        default <V> Function<T, V> andThen(Function<? super R, ? extends V> after);
        
       //t = Function.identity().apply(t)
        static <T> Function<T, T> identity() {
            return t -> t;
        }
    }

    对应的测试结果:

    Function<String,String> function = s-> s+"1";
    System.out.println(function.apply("1"));//11
    System.out.println(function.andThen(s -> s + "2").apply("1"));//112
    System.out.println(function.compose(s -> s + "2").apply("1"));//121
    System.out.println(Function.identity().apply("1"));//1
    @FunctionalInterface
    public interface Supplier<T> {
        //返回T类型
        T get();
    }

    对应的测试结果:

    Supplier<String> supplier = ()->"1";
    System.out.println(supplier.get());//1

    3.方法引用

     3.1 类名::静态方法名

     3.2 instance::instance方法名

     3.3 类名::instance方法名

     3.4 类名::new

            

    [1]: Java8 实战 java 8 in Action Mario Fusco 著 Alan Mycroft 陆明刚 劳佳 译

    展开全文
  • 探索jdk8 JDK 8 新特性的示例代码。
  • jdk8新特性代码

    2016-06-30 16:01:36
    jdk8新特性
  • jdk8 新特性之 List 排序

    千次阅读 2020-05-10 23:02:48
    jdk8 -> Lambda 循环打印println -> list.forEach(System.out::println); 1、jdk8 -> 之前的排序(升序) Collections.sort(list, new Comparator<User>() { @Override public int com

    一、排序示例

    • 升序–> 从小到大
    • 降序–> 从大到小
    • age --> 排序字段
    • jdk8 -> Lambda 循环打印println -> list.forEach(System.out::println);

    1、jdk8 -> 之前的排序(升序)

            Collections.sort(list, new Comparator<User>() {
                @Override
                public int compare(User o1, User o2) {
                    return o1.getAge().compareTo(o2.getAge());
                }
            });
    

    2、jdk8 -> Lambda排序(升序)

    //  不带参  
    list.sort((u1, u2) -> u1.getAge().compareTo(u2.getAge()));        
    //  带参
    list.sort((User u1, User u2) -> u1.getAge().compareTo(u2.getAge()));  
    

    3、jdk8 -> Comparator 提供的静态方法排序( 升序)

     Collections.sort(list, Comparator.comparing(User::getAge));
    

    4、jdk8 -> Comparator 提供的静态方法排序( 降序).reversed()

    Collections.sort(list, Comparator.comparing(User::getAge).reversed());
    

    5、jdk8 -> 组合排序

    支持每个排序字段的结尾添加.reversed() 改为降序

    // Age-升序   Name-升序
    Collections.sort(list, Comparator.comparing(User::getAge).thenComparing(User::getName));
    
    // Age-升序   Name-降序
    Collections.sort(list, Comparator.comparing(User::getAge).thenComparing(User::getName).reversed());
    
    // Age-降序   Name-升序
    Collections.sort(list, Comparator.comparing(User::getAge).reversed() .thenComparing(User::getName));
    
    // Age-降序   Name-降序
    Collections.sort(list, Comparator.comparing(User::getAge).reversed() .thenComparing(User::getName).reversed());
    

    二、完整测试代码参考

    package com.ws.ldy.common.utils;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    
    import java.io.Serializable;
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.List;
    
    public class JDK8ListSort {
    
        public static void main(String[] args) {
    
    
            // TODO jdk8 之前的排序
            System.out.println("============jdk8 之前的排序");
            List<User> list = initList();
            Collections.sort(list, new Comparator<User>() {
                @Override
                public int compare(User o1, User o2) {
                    return o1.getAge().compareTo(o2.getAge());
                }
            });
            list.forEach(System.out::println);
    
    
            // TODO jdk8 lambda 排序-升序
            System.out.println("============jdk8 lambda排序,升序排序 --> 从小到大");
            list = initList();
            list.sort((u1, u2) -> u1.getAge().compareTo(u2.getAge()));   //不带参  带参: list.sort((User u1, User u2) -> u1.getAge().compareTo(u2.getAge()));
            list.forEach(System.out::println);
    
    
            // TODO jdk8 升序排序
            System.out.println("============jdk8 升序排序 --> 从小到大,Comparator提供的静态方法");
            list = initList();
            Collections.sort(list, Comparator.comparing(User::getAge));
            list.forEach(System.out::println);
    
    
            // TODO jdk8 降序排序
            System.out.println("============jdk8 降序排序 --> 从大到小,Comparator提供的静态方法");
            list = initList();
            Collections.sort(list, Comparator.comparing(User::getAge).reversed());
            list.forEach(System.out::println);
            System.out.println();
    
    
            // TODO jdk8 组合排序
            System.out.println("============jdk8 组合排序,Comparator提供的静态方法,先按年纪排序,年纪相同的按名称排序");
            list = initList();
            Collections.sort(list, Comparator.comparing(User::getAge).thenComparing(User::getName));
            list.forEach(System.out::println);
    
        }
    
    
        /**
         * TODO  初始化List数据
         *
         * @return java.util.List<com.ws.ldy.common.utils.JDK8ListSort.User>
         * @author ws
         * @mail 1720696548@qq.com
         * @date 2020/5/10 0010 22:49
         */
        private static List<User> initList() {
            List<User> list = new ArrayList<>();
            list.add(new User("lisa", 23));
            list.add(new User("tom", 11));
            list.add(new User("john", 16));
            list.add(new User("jennis", 26));
            list.add(new User("tin", 26));
            list.add(new User("army", 26));
            list.add(new User("mack", 19));
            list.add(new User("jobs", 65));
            return list;
        }
    
    
        /**
         * TODO  测试对象
         *
         * @author ws
         * @mail 1720696548@qq.com
         * @date 2020/5/10 0010 22:49
         */
        @Data
        @AllArgsConstructor
        public static class User implements Serializable {
            private String name;
            private Integer age;
        }
    }
    
    
    展开全文
  • JDK8新特性(二):JDK8接口增强

    千次阅读 2020-01-03 18:25:47
    JDK8之前,JDK规定接口中只能定义 ①静态常量 ②抽象方法 修饰词 interface 接口名{ 静态常量; 抽象方法; } 在JDK8之后,对接口进行了增强。我们可以在接口中定义 ①静态常量 ②抽象方法 ③默认方法 ④静态...

    1.接口增强

    在JDK8之前,JDK规定接口中只能定义 ①静态常量  ②抽象方法

    修饰词 interface 接口名{
        静态常量;
        抽象方法;
    }
    

    在JDK8之后,对接口进行了增强。我们可以在接口中定义 ①静态常量   ②抽象方法   ③默认方法    ④静态方法

    修饰词 interface 接口名{
        静态常量;
        抽象方法;
        默认方法;
        静态方法;
    }
    

    2.为什么要对接口增强

     1.为什么要引入默认方法?

            实例1:我们在接口 A 中定义了个 test1() 抽象方法,现在有类 B、类 C 都实现了接口 A 。但是现在因为要接入新的需求,而这一个抽象方法明显不能够满足新需求。那么则需要在接口 A 中重新顶一个 test2() 抽象方法,此时我们发现类 B 、类 C 都因为没有实现新的抽象方法 test2() 而报错了。。。。。

            实例2:JDK8 在 Map 接口中增加了 forEach 方法。按 JDK8 之前标准,定义 forEach() 方法如下所示:

    public interface Map<K,V>{
        ...
        abstract void forEach(BiConsumer<? super K, ? super V> action);
    }

    我们通过 API 可以查询到 Map 接口的实现类如下所示:

           此时,如果在 Map 接口中增加一个 forEach() 抽象方法,那么所有的这些实现类都需要来实现 forEach()方法,从而保证语法正确不报错,显然这工程量是巨大的,而且代码也会有很大的冗余。

           因此,在 JDK8 时为接口新增了默认方法(default修饰),效果如下:

    public interface Map<K,V>{
        ...
        default void forEach(BiConsumer<? super K, ? super V> action){
            ...
        }
    }

    特性:

        1.新增的默认方法实现类不必重写,可以直接使用;

        2.实现类也可以根据需要重写       ---->这样就方便了接口的扩展。​​​​​​

     2.接口静态方法

         为了方便接口的扩展,JDK8 同时为接口新增了静态方法

    特性:

        1.接口中的静态方法,实现类既不能调用,也不能重写;(只属于接口本身)

        2.只能通过接口名. (接口名+ .)的方式调用

    3.默认方法、静态方法的定义

    //默认方法的定义(使用 default 定义)
    修饰符 interface 接口名{
        修饰符 default 返回值类型 方法名(){
            代码部分;
        }
    }
    
    //静态方法的定义(使用 static 修饰)
    修饰符 interface 接口名{
        修饰符 static 返回值类型 方法名(){
            代码部分;
        }
    }
    

    4.默认方法 和 静态方法 的区别

    1.默认方法通过实例调用,静态方法通过接口名调用

    2.默认方法可以被继承,实现类可以直接使用接口默认方法,也可以重写接口默认方法

    3.静态方法不能被继承,实现类不能重写接口静态方法,只能使用接口名调用。

    5.Demo(这很简单,Demo就省了)

        谢谢


    附:JDK8新特性(目录)

           本目录为 JDK8新特性 学习目录,包含JDK8 新增全部特性的介绍。

           如需了解,请跳转链接查看:我是跳转链接


    博主写作不易,来个关注呗

    求关注、求点赞,加个关注不迷路 ヾ(◍°∇°◍)ノ゙

    博主不能保证写的所有知识点都正确,但是能保证纯手敲,错误也请指出,望轻喷 Thanks♪(・ω・)ノ

    展开全文
  • jdk8新特性之for循环

    千次阅读 2019-03-29 11:41:21
    jdk8新特性之for循环 1.首先遍历一个List 方式1.一开始是这样的: 1 public static void test1(List list) { 2 for (int i = 0; i < list.size(); i++) { 3 System.out.println(list.get(i)); 4 } 5 } 方式2....
  • JDK8新特性-Map遍历比较

    万次阅读 2018-11-05 13:11:30
    菜鸟教程,有很多入门教程 1、案例 ... import java.util.HashMap; import java.util.Map;...import java.util.stream.Collectors;... * JDK8新特性,stream流,Map集合遍历 * Created by Tiger o...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 274,072
精华内容 109,628
关键字:

jdk8新特性

友情链接: jQ键盘控制焦点图.rar