码迷,mamicode.com
首页 > 编程语言 > 详细

Java 1.8 新特性

时间:2019-07-28 21:26:11      阅读:128      评论:0      收藏:0      [点我收藏+]

标签:获取   cat   rgs   hello   integer   add   重写   none   interface   

Lambda表达式

1、本质上是对匿名内部类对象的一种格式的简化

2、Lambda运算符 "->",也称箭头运算符,作用 分隔前后两部分

3、运算符左边是Lambda的参数列表(接口中定义的抽象方法的参数)

  右边是Lambda的方法体

4、语法格式:

  1、没有参数和返回值  () -> System.out.println(“Hello Lambda”);

  2、有一个参数,没有返回值 (x)-> System.out.println(x * x);  当只有一个参数时,参数的括号可以省略

  3、有多个参数,没有返回值,格式和语法格式2相同 (x, y) -> System.out.println(x + y);

  4、接口中需要重写的方法,方法内容有多句,需要给多句话加上大括号 

    (x, y) -> {int result = x + y; return result;}

    如果Lambda体中语句只有一句,那么大括号可以省略不写;如果大括号中只有一条语句,并且是return语句,

  那么return关键字也可以省略不写(如果要省略return关键字,就必须省略大括号)

      例如:(x, y) -> x + y

函数式接口

1、Lambda表达式使用的前提,就是接口必须是一个函数式接口

2、如果在接口中,只有一个抽象方法,那么这个接口就是函数式接口

3、使用注解来检查当前接口是否是一个函数式接口

    @FunctionalInterface     如果不是函数式接口,则编译报错

4、本质: 

  想表达的是一个方法的内容,由于方法不在任何类中,所以称为函数

  接口其实想表达的就是一个函数的声明

  将来使用这个接口的实现类对象,来表达一个函数的实现

  Java中不支持将函数作为一个数据,也就不能将这个函数进行各种传递,也就不能作为对象的成员变量存在

  只能在方法外加一层接口的声明,将来可以传递方法所在接口的实现类对象,来间接的传递方法内容

5、常用内置函数式接口

  1.8中提供了一些常用的函数式接口,在使用类似功能的时候,不需要额外定义接口,直接使用jdk中提供的即可。  

  Consumer<T>:消费型接口

      void accept(T t);

  Supplier<T>:供给型接口

    T get();

  Function<T, R>:函数型接口

    R apply(T t);

  Predicate<T>:断言型接口

    boolean test(T t)

6、方法的引用

  1、写一个函数式接口时,方法的实现(lambda体),已经被某个其他的对象实现了,就不需要在Lambda体中,再次调用这个实现,而可以直接使用那个已经定义好的方法。

  2、格式:

      函数式接口 名称 = 对象名 :: 方法名称

      函数式接口 名称 = 类名 :: 静态方法名

  3、作用:

      把已经实现的方法,作为一个数据,作为一个引用,赋值给某个函数式接口的引用

      可以把这个引用当做方法的返回值,也可以作为方法的实际参数进行传递

  4、本质:

      可以把任意一个方法,作为函数式接口的一个实现类对象

技术图片方法的引用

7、消费型接口 Consumer<T>

  抽象方法:void accept(T t);

  某个函数可以接收一个数据,并且处理这个数据,处理完成之后,不需要返回任何数据,这个函数需要当做数据来进行传递,就使用消费型接口。

技术图片
import java.util.function.Consumer;

public class Test4 {

    public static void main(String[] args) {
        Consumer<String> con = x->System.out.println(x);
        test(998,con,"大宝剑");
    }
    public static void test(int money,Consumer<String> con,String str) {
        //只需要处理数据,不需要返回值Consumer<T>
        System.out.println("花了"+money+"块钱");
        con.accept(str);
    }
}
消费型接口

8、供给型接口 Supplier<T>

  抽象方法:T get()

  如果需要定义函数,可以生产一个需要的数据,这个函数需要当做数据来进行传递,那么就可以使用供给型接口。

  以前我们只能传递数据,现在可以传递生产数据的方式。

技术图片
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.function.Supplier;

public class Test6 {

    public static void main(String[] args) {
        Random r = new Random();
        //在参数中定义Lambda函数体
        List<Integer> list = getNum(10,()->r.nextInt(30)+21);
        System.out.println(list);

    }
    public static List<Integer> getNum(int n,Supplier<Integer> sup){
        List<Integer> list = new ArrayList<Integer>();
        for(int i=1;i<=n;i++) {
            list.add(sup.get());//供给对象调用get()方法获取生成的数据
        }
        return list;    
    }
}
供给型接口

9、函数型接口 Function<T, R>

  抽象方法:R apply(T t)  

  如果需要定义一个函数,接收一个数据,将数据进行处理,完成之后,还能返回一个结果,就可以使用函数型接口

  以前我们只能传递处理好之后的数据,或者将原始数据传入方法

  现在可以传入原始数据,并且还可以传入处理方式

技术图片
import java.util.function.Function;

public class Test7 {

    public static void main(String[] args) {
        Function<String,Integer> fun = x->Integer.parseInt(x);
        int num = parse("555",fun);
        System.out.println(num);
        
        Function<Integer,Integer> fun1 = x->x*x;
        int result = method(6,fun1);
        System.out.println(result);
        
        int result1 = method01("5",Integer::parseInt,x->x*x);
        System.out.println(result1);
    }
    public static int method01(String str,Function<String,Integer> fun,Function<Integer,Integer> fun1) {
        //andThen()先执行前面的方法,再执行后面的方法,apply()给函数接口传参
        return fun.andThen(fun1).apply(str);
    }
    
    public static int method(int i,Function<Integer,Integer> fun) {
        return fun.apply(i);    
    }
    public static int parse(String str,Function<String,Integer> fun){
        return fun.apply(str);
    }
}
函数式接口

10、断言型接口 Predicate<T>

  抽象方法:boolean test(T t)

  如果需要定义一个函数,接收一个数据,判断数据是否合法,返回一个boolean结果,就可以使用断言型接口

  以前我们只能传入处理好的数据到方法中

  现在可以将原始数据传入,将过滤的条件也传入

技术图片
import java.util.ArrayList;
import java.util.function.Predicate;

public class Test8 {

    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(10);
        list.add(66);
        list.add(666);
        list.add(35);
        list.add(-20);
        list.add(0);
        list.add(33);
        
        ArrayList<Integer> odds = filt(list, x -> x % 2 == 0);
        System.out.println(odds);
        
        ArrayList<Integer> oddsNeg = filt(odds, x -> x < 0);
        System.out.println(oddsNeg);
        
        ArrayList<Integer> oddsNegS = filt(list, x -> x % 2 == 0, x -> x < 0);
        System.out.println(oddsNegS);
        
        //获得list中大于100的数字或者是偶数
        ArrayList<Integer> results = filtOr(list, x -> x > 100, x -> x % 2 == 0);
        System.out.println(results);
        //取反  非偶数
        ArrayList<Integer> testNeg = filtNeg(list, x -> x % 2 == 0);
        System.out.println(testNeg);
    
    }

    

    public static ArrayList<Integer> filt(ArrayList<Integer> list, Predicate<Integer> pre) {
        ArrayList<Integer> result = new ArrayList<>();
        for (int  i : list) {
            if (pre.test(i)) {//断言型接口的对象.test()进行判断
                result.add(i);
            }
        }
        return result;
    }

    public static ArrayList<Integer> filt(ArrayList<Integer> list, Predicate<Integer> pre1, Predicate<Integer> pre2) {
        ArrayList<Integer> result = new ArrayList<>();
        for (int  i : list) {
            if (pre1.and(pre2).test(i)) {//and()同时满足
                result.add(i);
            }
        }
        return result;
    }

    public static ArrayList<Integer> filtNeg(ArrayList<Integer> list, Predicate<Integer> pre) {
        ArrayList<Integer> result = new ArrayList<>();
        for (int  i : list) {
            if (pre.negate().test(i)) {//negate()相当于非 !
                result.add(i);
            }
        }
        return result;
    }

    public static ArrayList<Integer> filtOr(ArrayList<Integer> list, Predicate<Integer> pre1, Predicate<Integer> pre2 ) {
        ArrayList<Integer> result = new ArrayList<>();
        for (int  i : list) {
            if (pre1.or(pre2).test(i)) {//or只要满足其中一个条件
                result.add(i);
            }
        }
        return result;
    }
}
断言型接口

 

Java 1.8 新特性

标签:获取   cat   rgs   hello   integer   add   重写   none   interface   

原文地址:https://www.cnblogs.com/xfdhh/p/11260927.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!