精华内容
下载资源
问答
  • JDK8特性之流计算

    2020-04-26 09:04:15
    JDK8特性之流计算 1.什么是jdk? jdk就是我们的开发工具包,里面有封装好的很多类,今天讲的Stream就是其中一个工具类 流非常重要,对于我们看懂别人的代码阿,简化计算阿,计算速度提升都有很大帮助 2.普通的数据...

    JDK8特性之流计算

    1.什么是jdk?

    jdk就是我们的开发工具包,里面有封装好的很多类,今天讲的Stream就是其中一个工具类
    流非常重要,对于我们看懂别人的代码阿,简化计算阿,计算速度提升都有很大帮助

    2.普通的数据结构集合怎么转换成流

    Stream<Integer> stream=Stream.of(1,2,3);
    ArrayList<String> list=new ArrayList<>();
    list.add("你好")
    Stream<Integer> stream=Stream.of(list);  //集合转换为流
    //set和map也是一样,map要先转换成Collection对象
    
    //经常用的转换方式
    list.stream();
    int[] arr={1,2,3};
    arr.stream();

    第二种比较方便,直接简单

    3.流的API


    3.1 终结方法

    一旦用了下面两个方法,那么链式编程就不能再点下去了,会出异常,因为流关闭了

    list.stream().foreach(name->system.out.println(name))//遍历输出名字
    list.stream().count();//计数

    3.2 链式方法

    list.stram().skip(2);//跳过前面2个
    list.stram().skip(2).limit(1);//跳过前面2个后取新的最前面的第一个
    list.stream().map((name)-> new Person(name))//转换成一个person对象,map方法就是转换类型的
    list.stream().filter((name)-> name.length()==2)//过滤器,过滤出自己想要的结果

    以上是列举最重要的出来

    3.3 完整实例

    要求输出person对象前两个人

    import java.util.ArrayList;
    
    class Person{
        String name;
        Person(){
            this.name=null;
        }
        Person(String name){
            this.name=name;
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }
    public class Stream {
        public static void main(String[] args) {
            ArrayList<String> list=new ArrayList<>();
            list.add("李白");
            list.add("张三");
            list.add("李四");
            list.add("王五");
            list.add("赵六");
          //  list.stream().forEach((name)-> System.out.println(name));
          //  list.stream().filter((String name)->{return name.startsWith("李");});
            list.stream().filter((name)-> name.length()==2).map((name)-> new Person(name)).limit(2).forEach(name-> System.out.println(name));
        }
    }

    多练一练,花个半小时就学会了

    展开全文
  • JDK8特性(Lambda表达式+StreamAPI的简单使用示例代码)
  • 概述接口,是Java语言中一种引用类型,接口中只定义了方法,如果说类的内部封装了成员变量、构造方法和成员方法,那么接口的内部主要就是封装了方法,包含抽象方法(JDK 7及以前),默认方法和静态方法(JDK 8),...

    概述

    接口,是Java语言中一种引用类型,接口中只定义了方法,如果说类的内部封装了成员变量、构造方法和成员方法,那么接口的内部主要就是封装了方法,包含抽象方法(JDK 7及以前),默认方法和静态方法(JDK 8),私有方法(JDK 9)。

    接口的定义,它与定义类方式相似,和类是同等级别的。但是使用 interface 关键字。它也会被编译成.class文件,但一定要明确它并不是类,而是另外一种引用数据类型。

    引用数据类型:数组,类,接口。

    接口的使用,它不能创建对象,但是可以被实现(implements ,类似于被继承)。一个实现接口的类(可以看做是接口的子类或者叫做实现类),需要实现接口中所有的抽象方法,创建该类对象,就可以调用方法了,否则它必须是一个抽象类。


    定义格式

    public interface 接口名称 {
        // 抽象方法
        // 默认方法
        // 静态方法
        // 私有方法

    }

    含有抽象方法(jdk7之前)

    抽象方法:使用abstract 关键字修饰,可以省略,没有方法体。该方法供子类实现使用。

    代码如下:

    public interface InterFaceName {
        public abstract void method();

    }

    含有默认方法和静态方法(jdk8)

    默认方法:使用 default 修饰,不可省略,供子类调用或者子类重写。默认权限修饰符是public。

    静态方法:使用 static 修饰,供接口名直接调用。不用在使用子类对象间接调用,这样调用的方式更为简单些。权限修饰符可以是public private。

    说明:可以使用private修饰的原因是源于静态的思想。在接口中的其他静态方法中是可以调用私有的静态方法。而使用private修饰的方法更为安全。

    代码如下:

    public interface InterFaceName {
        public default void method() {
            // 执行语句
        }
        public static void method2() {
            // 执行语句    
        }

    }

    含有私有方法和私有静态方法(jdk9)

    jdk9诞生这个新的技术主要是用来提高代码的复用性。

    举例:如果本类中默认方法和静态方法有重复的内容我们需要书写很多遍。而我们把共性的内容放到私有方法中,这样减少代码的书写,并且只能在本类中使用。更加安全。

    私有方法:使用 private 修饰,只供接口中的默认方法或者静态方法调用。

    代码如下:

    public interface InterFaceName {
        private void method() {
            // 执行语句
        }

    }

    基本的实现

    实现的概述

    类与接口的关系为实现关系,即类实现接口,该类可以称为接口的实现类,也可以称为接口的子类。实现的动作类似继承,格式相仿,只是关键字不同,实现使用 implements关键字。

    非抽象子类实现接口:

    1. 必须重写接口中所有抽象方法。

    2. 继承了接口的默认方法,即可以直接调用,也可以重写。

    实现格式:

    class 类名 implements 接口名 {
        // 重写接口中抽象方法【必须】
      // 重写接口中默认方法【可选】

    私有方法的使用

    • 私有方法:只有默认方法可以调用。

    • 私有静态方法:默认方法和静态方法可以调用。

    如果一个接口中有多个默认方法,并且方法中有重复的内容,那么可以抽取出来,封装到私有方法中,供默认方法去调用。从设计的角度讲,私有的方法是对默认方法和静态方法的辅助。同学们在已学技术的基础上,可以自行测试。

    接口的多实现

    之前学过,在继承体系中,一个类只能继承一个父类。而对于接口而言,一个类是可以实现多个接口的,这叫做接口的多实现。并且,一个类能继承一个父类,同时实现多个接口。

    class 类名 [extends 父类名] implements 接口名1,接口名2,接口名3... {
        // 重写接口中抽象方法【必须】
      // 重写接口中默认方法【不重名时可选】

    其他成员特点

    • 接口中,无法定义成员变量,但是可以定义常量,其值不可以改变,默认使用public static final修饰。

    • 接口中,没有构造方法,不能创建对象。

    • 接口中,没有静态代码块。


    展开全文
  • JDK8特性之LocalDateTime

    2020-10-12 14:28:06
    JDK1.8除了新增了lambda表达式、stream流之外,它还新增了全新的日期时间API。 在JDK1.8之前,Java处理日期、日历和时间的方式一直为社区所诟病,将 java.util.Date设定为可变类型,以及SimpleDateFormat的非线程...

    JDK1.8除了新增了lambda表达式、stream流之外,它还新增了全新的日期时间API。
    在JDK1.8之前,Java处理日期、日历和时间的方式一直为社区所诟病,将 java.util.Date设定为可变类型,以及SimpleDateFormat的非线程安全使其应用非常受限。因此推出了java.time包,该包下的所有类都是不可变类型而且线程安全。

    • LocalDate:本地日期,不包含具体时间, 格式 yyyy-MM-dd。
    • LocalTime:本地时间,不包含日期. 格式 yyyy-MM-dd HH:mm:ss.SSS 。
    • LocalDateTime:组合了日期和时间,但不包含时差和时区信息。

    LocalDateTime代码示例:
    LocalDate\LocalTime\LocalDateTime的使用

    public class LocalDateTimeDemo {
        public static void main(String[] args) {
            //本地日期,不包括时分秒
            LocalDate nowDate = LocalDate.now();
            //本地日期,包括时分秒
            LocalDateTime nowDateTime = LocalDateTime.now();
            System.out.println("当前是:" + nowDate);
            System.out.println("当前是:" + nowDateTime);
            //当前是:2020-10-12
            //当前是:2020-10-12T14:03:12.829
    
            System.out.println("当前年:" + nowDateTime.getYear());
            System.out.println("当前年份天数:" + nowDateTime.getDayOfYear());
            System.out.println("当前月:" + nowDateTime.getMonthValue());
            System.out.println("当前时:" + nowDateTime.getHour());
            System.out.println("当前分:" + nowDateTime.getMinute());
            System.out.println("当前时间:" + nowDateTime.toString());
            //当前年:2020
            //当前年份天数:286
            //当前月:10
            //当前时:14
            //当前分:7
            //当前时间:2020-10-12T14:07:53.685
    
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS");
            LocalDateTime ldt = LocalDateTime.now();
            System.out.println("格式化时间:" + ldt.format(formatter));
            //格式化时间:2020-10-12 14:10:51.062
    
            LocalDate ld1 = LocalDate.parse("2017-11-17");
            LocalDate ld2 = LocalDate.parse("2018-01-05");
            Period period = Period.between(ld1, ld2);
            System.out.println("相差年:" + period.getYears() + "相差月:" + period.getMonths() + "相差天:" + period.getDays());
            System.out.println("相差月份:" + ChronoUnit.MONTHS.between(ld1,ld2));
            System.out.println("相差总天数:" + ChronoUnit.DAYS.between(ld1,ld2));
            //相差年:0相差月:1相差天:19
            //相差月份:1
            //相差总天数:49
    
            LocalDateTime ldt1 = LocalDateTime.now();
            LocalDateTime ldt2 = ldt1.plusMinutes(10);
            System.out.println("当前时间是否大于:" + ldt1.isAfter(ldt2));
            System.out.println("当前时间是否小于:" + ldt1.isAfter(ldt2));
            //当前时间是否大于:false
            //当前时间是否小于:false
    
            Clock clock = Clock.systemUTC();
            System.out.println("当前时间戳:" + clock.millis());
            Clock clock2 = Clock.system(ZoneId.of("Asia/Shanghai"));
            System.out.println("亚洲上海此时的时间戳:" + clock2.millis());
            Clock clock3 = Clock.system(ZoneId.of("America/New_York"));
            System.out.println("美洲纽约此时的时间戳:" + clock3.millis());
            //当前时间戳:1602483959576
            //亚洲上海此时的时间戳:1602483959576
            //美洲纽约此时的时间戳:1602483959580
        }
    }
    

    在此记录jdk1.8中时间的用法,后续加强练习。

    展开全文
  • Jdk8特性lambda

    2019-03-17 12:00:16
    文章目录1、让方法参数具备行为能力1.1、找绿色的苹果1.2、找红色的苹果1.3、根据颜色又根据重量去查找1.3.1、策略模式的应用,方法参数具备了行为1.3.2、直接使用匿名内部类来调用2、使用lamda表达式改写2.1、优点:...


    在这里插入图片描述
    在这里插入图片描述
    在java的历史中,java8的变化举重若轻

    1、让方法参数具备行为能力

    1.1、找绿色的苹果

    在这里插入图片描述
    其中apple类是一个实体类它有颜色、重量等属性
    上面的例子是遍历参数中的apple集合找到颜色为绿色的苹果
    用下面的这个方法创建出需要的apple集合

    List<Apple> list = Arrays.asList(new Apple("green", 150), new Apple("yellow", 120), new Apple("green", 170));
    

    1.2、找红色的苹果

    最初级的办法就是另外再写一个方法。
    高级一点的就是在上面方法上加一个参数为我们需要找的颜色

    在这里插入图片描述

    1.3、根据颜色又根据重量去查找

    1.3.1、策略模式的应用,方法参数具备了行为

    这种仓促的变化代表着需求的不断变化,对于我们写程序的来说如何让调用者察觉不到这种变化?

    public class FilterApple {
       定义一个接口作为作为方法的参数,具体的业务算法作为他的实现类
        public interface AppleFilter {
            boolean filter(Apple apple);
        }
        public static List<Apple> findApple(List<Apple> apples, AppleFilter appleFilter) {
            List<Apple> list = new ArrayList<>();
            for (Apple apple : apples) {
                if (appleFilter.filter(apple))
                    list.add(apple);
            }
            return list;
        }
        实现我们定义的接口,写我们的业务逻辑
        public static class GreenAnd160WeightFilter implements AppleFilter {
            @Override
            public boolean filter(Apple apple) {
                return (apple.getColor().equals("green") && apple.getWeight() >= 160);
            }
        }
         public static void main(String[] args) throws InterruptedException {
             List<Apple> list = Arrays.asList(new Apple("green", 150), new Apple("yellow", 120), new Apple("green", 170));
             List<Apple> result = findApple(list, new GreenAnd160WeightFilter());
            System.out.println(result);、
         }
       }
    

    1.3.2、直接使用匿名内部类来调用

    对于上一节的策略模式,如果我们每一个业务逻辑都要写一个filter来实现这个业务的具体算法,是很麻烦的

     List<Apple> yellowList = findApple(list, new AppleFilter() {
                @Override
                public boolean filter(Apple apple) {
                    return "yellow".equals(apple.getColor());
                }
            });
    System.out.println(yellowList);
    

    2、使用lamda表达式改写

    2.1、优点:相比较上面的例子

    1. 一个是代码量比较大
    2. 另一个是this的混淆(这个理由有点牵强)
      如下在这个匿名类中输出的是多少
      在这里插入图片描述
      当然是5了
    3. 最重要的是java8内存的变化
      在这里插入图片描述

    在这里插入图片描述
    可以看出jdk8比jdk6少了一个P,多了M、CCS
    具体后面再说

    2.2、详细使用

    当一个接口中有且只有一个抽象方法我们就可以使用lamda表达式(default、static方法除外)
    接口上可以标上注解@FunctionalInterface(也可以不写这个注解,它起到标识验证的作用)

     @FunctionalInterface
        public interface AppleFilter {
            boolean filter(Apple apple);
        }
    

    在这里插入图片描述
    还可以继续简写

    参数类型可以推导,所以不用写参数类型
    如果只有一个参数,可以去掉参数两边的括号
    在这里插入图片描述

    2.3、其他例子

    线程的对比

           new Thread(new Runnable() {
    
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());
                }
            }).start();
    
            new Thread(() -> System.out.println(Thread.currentThread().getName())  ).start();
            Thread.currentThread().join();
    

    以及
    在这里插入图片描述在这里插入图片描述
    这些接口

    3、lambda表达式语法

    在这里插入图片描述
    方法引用、类型推导、组合
    他可以被定义、有传递参数、可以有返回值、可以抛出一系列异常

    3.1、参数传递

    在这里插入图片描述
    在这里插入图片描述
    红色语句两边没有加花括号,它的返回类型可以自动推导
    如果加了花括号就必须写return
    在这里插入图片描述

    3.2、被定义(function接口)

    在这里插入图片描述
    lambda是一个最基本的东西,它主要是为我们 的function接口来服务的

      Function<String,Integer> flambda = s->s.length();
      Integer hello = flambda.apply("hello");
      System.out.println(hello);//5
    

    Function源码

    @FunctionalInterface
    public interface Function<T, R> {
    
        /**
         * Applies this function to the given argument.
         *
         * @param t the function argument
         * @return the function result
         */
        R apply(T t);
    
        /**
         * Returns a composed function that first applies the {@code before}
         * function to its input, and then applies this function to the result.
         * If evaluation of either function throws an exception, it is relayed to
         * the caller of the composed function.
         *
         * @param <V> the type of input to the {@code before} function, and to the
         *           composed function
         * @param before the function to apply before this function is applied
         * @return a composed function that first applies the {@code before}
         * function and then applies this function
         * @throws NullPointerException if before is null
         *
         * @see #andThen(Function)
         */
        default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
            Objects.requireNonNull(before);
            return (V v) -> apply(before.apply(v));
        }
    
    

    Function 接口中还有default static方法

    3.3、Predicate接口

    可以看出,它是给一个参数返回一个boolean值
    源码

    @FunctionalInterface
    public interface Predicate<T> {
    
        /**
         * Evaluates this predicate on the given argument.
         *
         * @param t the input argument
         * @return {@code true} if the input argument matches the predicate,
         * otherwise {@code false}
         */
        boolean test(T t);
    
    

    使用

            Predicate<String> b = s->s.length()>2;
            System.out.println(b.test("hello")); //true
            System.out.println(b.test("h"));     //false
    

    3.4、其他合法的lambda表达式及语法总结

    在这里插入图片描述
    在这里插入图片描述
    #### 3.5lambda语法总结

    4、Lambda使用深入解析

           Runnable r1 = () -> System.out.println("Hello");
    
            Runnable r2 = new Runnable() {
                @Override
                public void run() {
                    System.out.println("Hello");
                }
            };
    
            process(r1);
            process(r2);
            process(() -> System.out.println("Hello"));*/
    

    这三个打印完全一致

    4.1、Predicate<`T>

    在这里插入图片描述

           private static List<Apple> filter(List<Apple> source, Predicate<Apple> predicate) {
    	        List<Apple> result = new ArrayList<>();
    	        for (Apple a : source) {
    	            if (predicate.test(a))
    	                result.add(a);
    	        }
    	        return result;
    	    }
    
            List<Apple> list = Arrays.asList(new Apple("green", 120), new Apple("red", 150));
            List<Apple> greenList = filter(list, (apple) -> apple.getColor().equals("green"));
            System.out.println(greenList);
    

    在这里插入图片描述可以接受两个参数
    在这里插入图片描述只接受一个int参数
    在这里插入图片描述
    在这里插入图片描述

    4.2、Consumer<`T>

    在这里插入图片描述

    private static void simpleTestConsumer(List<Apple> source, Consumer<Apple> consumer) {
            for (Apple a : source) {
                consumer.accept(a);
            }
        }
    
    simpleTestConsumer(list, a -> System.out.println(a));
    

    在这里插入图片描述两个参数

     BiConsumer<String,Integer> bc = (s,i)-> System.out.println(s.concat(i.toString()));
     bc.accept("hello",3000);//hello3000
    

    4.3、Function<T,R>

    在这里插入图片描述

     private static String testFunction(Apple apple, Function<Apple, String> fun) {
            return fun.apply(apple);
        }
    
     String result3 = testFunction(new Apple("yellow", 100), (a) -> a.toString());
            System.out.println(result3);
    

    BiFunction<T, U, R>
    在这里插入图片描述
    IntFunction
    在这里插入图片描述

    4.4、Supplier<`T>

    在这里插入图片描述

    Supplier<String> s = String::new;   //method inference.
    System.out.println(s.get().getClass());
    
    
      private static Apple createApple(Supplier<Apple> supplier) {
            return supplier.get();
        }
    
    Apple a2 = createApple(() -> new Apple("Green", 100));
    System.out.println(a2);
    

    4.5、Runnable

    在这里插入图片描述
    在这里插入图片描述
    lambda表达式实际也是一个匿名函数,和内部类一样,
    如果在匿名函数里操作外面的变量,则这个变量必须是final
    如果仅仅是引用则不需要

    5、Lambda方法推导详细解析

    //这个方法是将一个字符串输出两遍
        private static <T> void useConsumer(Consumer<T> consumer, T t) {
            consumer.accept(t);
            consumer.accept(t);
        }
        
        public static void main(String[] args) {
         Consumer<String> consumer = (s) -> System.out.println(s);
         useConsumer(consumer, "Hello Alex");
     }
    

    上面是正常方法调用
    下面说方法推导
    可以省略Consumer的定义

      useConsumer(s -> System.out.println(s), "Hello Alex");
      useConsumer(System.out::println, "Hello Wangwenjun");
    

    再看 list.sort的方法推导

           List<Apple> list = Arrays.asList(new Apple("abc", 123), new Apple("Green", 110), new Apple("red", 123));
            System.out.println(list);
            list.sort((a1, a2) -> {return a1.getColor().compareTo(a2.getColor());};
            
            list.sort((a1, a2) -> a1.getColor().compareTo(a2.getColor()));
    
            System.out.println(list);
    

    list.stream().forEach的函数推导

             list.stream().forEach(a -> System.out.println(a));
            System.out.println("==========================");
            list.stream().forEach(System.out::println);  //推导之后更加简洁
    

    什么情况下可以进行方法推导(函数推导)呢
    下面分小节细说

    5.1、可以通过类的静态方法推断 ::

    在这里插入图片描述

            int value = Integer.parseInt("123");
    
            Function<String, Integer> f = Integer::parseInt;//方法推导
            Integer result = f.apply("123");
            System.out.println(result);
    

    5.2、实例方法推断 ::

    在这里插入图片描述

            String  s = new String("hello");
            char c1 = s.charAt(2);
            
            BiFunction<String, Integer, Character> f2 = String::charAt;
            Character c = f2.apply("hello", 2);
            System.out.println(c);
    

    5.3、已有对象的实例方法 ::

    在这里插入图片描述

            String str = new String("Hello");
            Function<Integer, Character> f3 = str::charAt;
            Character c2 = f3.apply(4);
            System.out.println(c2);
    

    可以看看与实力方法的区别

    5.4、构造函数的推导::

    一个参数

            Supplier<String> supplier = String::new;
    
            String s = supplier.get();
            System.out.println(s);
    

    两个参数

            BiFunction<String, Long, Apple> appleFuntion = Apple::new;
    
            Apple apple = appleFuntion.apply("red", 100L);
            System.out.println(apple);
    

    三个参数(自己构造)

    @FunctionalInterface
    public interface ThreeFunction<T, U, K, R> {
    
        R apply(T t, U u, K k);
    
    }
    
    
            ThreeFunction<String, Long, String, ComplexApple> threeFunction = ComplexApple::new;
            ComplexApple complexApple = threeFunction.apply("Green", 123L, "FuShi");
            System.out.println(complexApple);
    

    5.5、list.sort优化

    优化

            List<Apple> list2 = Arrays.asList(new Apple("abc", 123), new Apple("Green", 110), new Apple("red", 123));
    
            System.out.println(list2);
            list2.sort(Comparator.comparing(Apple::getColor));//方法推导
            System.out.println(list2);
    

    推导过程
    将前面的sort与这个进行对比发现简洁了很多
    在这里插入图片描述
    看它源码
    java.util.List#sort 方法源码

        @SuppressWarnings({"unchecked", "rawtypes"})
        default void sort(Comparator<? super E> c) {
            Object[] a = this.toArray();
            Arrays.sort(a, (Comparator) c);
            ListIterator<E> i = this.listIterator();
            for (Object e : a) {
                i.next();
                i.set((E) e);
            }
        }
    

    再看java.util.Comparator.comparing源码

       public static <T, U> Comparator<T> comparing(
                Function<? super T, ? extends U> keyExtractor,
                Comparator<? super U> keyComparator)
        {
            Objects.requireNonNull(keyExtractor);
            Objects.requireNonNull(keyComparator);
            return (Comparator<T> & Serializable)
                (c1, c2) -> keyComparator.compare(keyExtractor.apply(c1),
                                                  keyExtractor.apply(c2));
        }
    

    它返回值中使用了一个 & 这个有什么用
    在这里插入图片描述
    在这里插入图片描述
    对比

    list.sort((a1, a2) -> a1.getColor().compareTo(a2.getColor()));
              (c1, c2) -> keyComparator.compare(keyExtractor.apply(c1), keyExtractor.apply(c2));
    


    Function<T, R> keyExtractor.apply(c1)
    返回 Function 接口

    展开全文
  • jdk8特性例子

    2018-05-03 14:41:44
    package com; import java.util.Arrays; import java.util.IntSummaryStatistics; import java.util.List; import java.util.function.Predicate; import java.util.stream.Collectors;...import org.junit.
  • Java深入 - jdk8特性

    千次阅读 2017-04-27 14:03:42
    1. 接口提供默认方法Java 8允许我们给接口添加一个非抽象的方法实现,只需要使用 default关键字即可public interface Test { int get(); /* JAVA8 接口默认方法*/ default int getVal(int a) { return a * 2;...
  • jdk8特性之方法引用

    2019-10-25 22:49:08
    方法引用:当在使用lambda表达式书写时,如果只是调用一个方法,就可以用方法应用代替,可以使代码更加简洁 ... import lombok.Builder; import lombok.Data; import org.junit.Test; ...import java.util.ArrayList;...
  • jdk8特性例子 流 Streams

    千次阅读 2017-02-15 20:34:26
    A java.util.Stream represents a sequence of elements on which one or more operations can be performed. Stream operations are either intermediate or terminal. While terminal operations return a ...
  • 这样的写法,看得我一脸懵逼,查了一下才知道这事JDK8提供的新特性,lambda表达式,在一定程度上可以简化某些代码的写法,下面我们就来一起看一下。1.对匿名内部实现的支持: 在java中使用多线程,一般会添加一个...
  • 我们都知道JDK 8最重要的新特性是Lambda表达式,这个可以让我们简化非常多的代码编写,不知道大家会使用了没有。这里我简单跟大家来回顾一下~ 1.1Lambda简化代码例子 下面就以几个例子来看看Lambda表达式是怎么简化...
  • public class ComparatorTest { public static void test() { List names = Arrays.asList("peter", "anna", "mike", "xenia"); ...Collections.sort(names, new Comparator() { ...public int compare
  • 1.过滤List(根据自己的需要修改) public static AchivePo getTrAllLimit(List<AchivePo> list,String periodType){ if(list==null) { } List<AchivePo> selectList=list.stream() ...
  • jdk8特性例子 内置函数式接口

    千次阅读 2017-02-13 23:04:54
    Predicates Predicates are boolean-valued functions of one argument. The interface contains various default methods for composing predicates to complex logical terms (and, or, negate) ...
  • Functional Interfaces How does lambda expressions fit into Javas type system? Each lambda corresponds to a given type, specified by an interface. A so called functional interface must contain exa
  • List<属性值类型> 属性List = 对象List.stream().map(对象::get方法()).collect(Collectors.toList()); 例如: List<Integer> idList = list.stream().map(User::getId).collect(Collectors.toList()...
  • 1 default method 默认方法。在接口的方法前增加default关键字,匿名类无需实现默认方法。 public class DefaultMethod { interface Formula { double calculate(int a); default double sqrt(int a) { ...
  • JDK8特性--Stream(求和,过滤,排序)

    千次阅读 2019-10-18 11:18:53
    Java 8 API添加了一个新的抽象称为流Stream,可以让你以一种声明的方式处理数据。 Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。 元素流在管道中经过...
  • public static List<Map<String, Object>> merge(List<Map<String, Object>> m1, List<Map<String, Object>> m2){ m1.addAll(m2); Set<String> set...

空空如也

空空如也

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

jdk8特性