java 1.8 特性_Java 1.8 新特性

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：消费型接口

void accept(T t);

Supplier：供给型接口

T get();

Function：函数型接口

R apply(T t);

Predicate：断言型接口

boolean test(T t)

6、方法的引用

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

2、格式：

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

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

3、作用：

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

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

4、本质：

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

方法的引用

7、消费型接口 Consumer

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

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

importjava.util.function.Consumer;public classTest4 {public static voidmain(String[] args) {

Consumer con = x->System.out.println(x);

test(998,con,"大宝剑");

}public static void test(int money,Consumercon,String str) {//只需要处理数据，不需要返回值Consumer

System.out.println("花了"+money+"块钱");

con.accept(str);

}

}

消费型接口

8、供给型接口 Supplier

抽象方法：T get()

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

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

importjava.util.ArrayList;importjava.util.List;importjava.util.Random;importjava.util.function.Supplier;public classTest6 {public static voidmain(String[] args) {

Random r= newRandom();//在参数中定义Lambda函数体

List list = getNum(10,()->r.nextInt(30)+21);

System.out.println(list);

}public static List getNum(int n,Suppliersup){

List list = new ArrayList();for(int i=1;i<=n;i++) {

list.add(sup.get());//供给对象调用get()方法获取生成的数据

}returnlist;

}

}

供给型接口

9、函数型接口 Function

抽象方法：R apply(T t)

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

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

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

importjava.util.function.Function;public classTest7 {public static voidmain(String[] args) {

Function fun = x->Integer.parseInt(x);int num = parse("555",fun);

System.out.println(num);

Function 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 fun,Functionfun1) {//andThen()先执行前面的方法，再执行后面的方法，apply()给函数接口传参

returnfun.andThen(fun1).apply(str);

}public static int method(int i,Functionfun) {returnfun.apply(i);

}public static int parse(String str,Functionfun){returnfun.apply(str);

}

}

函数式接口

10、断言型接口 Predicate

抽象方法：boolean test(T t)

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

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

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

importjava.util.ArrayList;importjava.util.function.Predicate;public classTest8 {public static voidmain(String[] args) {

ArrayList 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 odds = filt(list, x -> x % 2 == 0);

System.out.println(odds);

ArrayList oddsNeg = filt(odds, x -> x < 0);

System.out.println(oddsNeg);

ArrayList oddsNegS = filt(list, x -> x % 2 == 0, x -> x < 0);

System.out.println(oddsNegS);//获得list中大于100的数字或者是偶数

ArrayList results = filtOr(list, x -> x > 100, x -> x % 2 == 0);

System.out.println(results);//取反 非偶数

ArrayList testNeg = filtNeg(list, x -> x % 2 == 0);

System.out.println(testNeg);

}public static ArrayList filt(ArrayList list, Predicatepre) {

ArrayList result = new ArrayList<>();for (inti : list) {if (pre.test(i)) {//断言型接口的对象.test()进行判断

result.add(i);

}

}returnresult;

}public static ArrayList filt(ArrayList list, Predicate pre1, Predicatepre2) {

ArrayList result = new ArrayList<>();for (inti : list) {if (pre1.and(pre2).test(i)) {//and()同时满足

result.add(i);

}

}returnresult;

}public static ArrayList filtNeg(ArrayList list, Predicatepre) {

ArrayList result = new ArrayList<>();for (inti : list) {if (pre.negate().test(i)) {//negate()相当于非 !

result.add(i);

}

}returnresult;

}public static ArrayList filtOr(ArrayList list, Predicate pre1, Predicatepre2 ) {

ArrayList result = new ArrayList<>();for (inti : list) {if (pre1.or(pre2).test(i)) {//or只要满足其中一个条件

result.add(i);

}

}returnresult;

}

}

断言型接口