java lambda表达式

815 字

4 分钟

java lambda表达式

2020-05-30

java

/

lambda

Lambda表达式：引入函数式编程的风格，不是所有的引用数据类型都可以使用lambda表达式
只有SAM接口（函数式接口）类型的形参，变量才可以赋值为Lambda表达式。
函数式接口：SAM(Single Abstract Method)表示该接口只有一个抽象方法的接口。当然这个接口可以有默认方法和静态方法等成员。如Runnable、Callable、Comparable、Comparator、FileFilter

JDK1.8建议，这样的接口加一个注解标记@FunctionalInterface

一、消费型接口，特点：有参无返回值#

1、最基本的代表： Consumer : void accept(T t)
2、其他变形 BiConsumer: void accept(T t, U u)
例如：集合java.util.Collection系列的集合在JDK1.8之后增加的方法
default void forEach(Consumer<? super T> action)

1
public class TestConsumer{
2
    @Test
3
    public void test(){
4
        ArrayList<String> list = new ArrayList<>();
5
        list.add("hello");
6
        list.add("hello world");
7
        list.add("hello java");
8
        list.add("hello lambda");
9
        // foreach循环
10
        for (String str:list){
11
            System.out.println(str);
12
        }
13
        // forEach 方法就是等价于foreach循环
14
        list.forEach(t -> System.out.println(t));
15
    }
16
}

二、供给型接口抽象方法：无参有返回值#

1、最基本的代表

1
Supplier<T>： T get()

2、其他变型：

1
BooleanSupplier  boolean  getAsBoolean()
2
DoubleSupplier   double   getAsDouble()
3
IntSupplier         int         getAsInt()
4
LongSupplier       long       getAsLong()

StreamAPI: Stream是一个数据流
javc.util.stream包Stream类型

1
static<T> Stream<T> generate(Supplier<T> s)

1
class TestSupplier{
2
    @Test
3
    public void test(){
4
        // 产生generate, 产生随机数
5
        Stream<Double> stream = Stream.generate(() -> Math.random());
6
        stream.forEach(t-> System.out.println(t));
7
    }
8
}

三、判断型（断定型）接口 , 返回值都为布尔值#

抽象方法：boolean test(参数)
1、最基本的代表

1
Predicate<T> boolean test(T t)

2、其他的变形

1
BiPredicate<T,U>  boolean        test(T t,U u)
2
DoublePredicate  boolean         test(double value)
3
IntPredicate        boolean         test(int value)
4
LongPredicate      boolean         test(long value)

1
例如： java.util.Collection<E>
2
default boolean removeIf(Predicate<? super E>filter)

1
class TestPredicate{
2
    @Test
3
    public void test(){
4
        ArrayList<Integer> list = new ArrayList<>();
5
        for (int i = 1; i <= 10; i++) {
6
            list.add(i);
7
        }
8
        // 删除3的倍数元素
9
        //第一种
10
//        Iterator<Integer> iterator = list.iterator();
11
//        while (iterator.hasNext()){
12
//            Integer next = iterator.next();
13
//            if (next%3 ==0){
14
//                iterator.remove();
15
//            }
16
//        }
17
        // 第二种
18
        list.removeIf(t-> t%3 ==0);
19
        list.forEach(t -> System.out.println(t));
20
    }
21
}

四、功能型接口抽象方法：有参有返回值#

1、最基本的代表：Function<T, R> R apply(T t)
Lambda表达式是给函数式接口的形参或变量赋值用的，为了给这个函数式接口的抽象方法传递代码用
语法格式：
（形参列表） ->{lambda体} 解释：
（形参列表）就是函数式接口的抽象方法的形参列表。
{lambda体}就是函数式接口的抽象方法的方法体。
说明：1、当（形参列表）是空参时，那么（）是不能省略的
2、当（形参列表）是非空参的，并且类型是确定的或者可以推断的，那么形参的数据类型可以省略
3、当（形参列表）是非空参的，并且只有一个形参，并且类型也省略了，那么此时()也可以省略，如果类型没有省略，那么()也不能省略。
4、如果{lambda体} 不止一个语句，那么{}不能省略，并且每一个语句都要；结束
5、如果{lambda体}只有一个语句，那么{}和；可以省略且同时省略
6、如果有返回值，用return返回,且只有一个return语句时，return、{}、；都同时省略

1
public void test(){
2
       ArrayList<String> list = new ArrayList<>();
3
       list.add("hello");
4
       list.add("hello world");
5
       list.add("hello java");
6
       list.add("hello lambda");
7
      //用匿名内部类给Consumer接口的形参赋值
8
       list.forEach(new Consumer<String>() {
9
           @Override
10
           public void accept(String s) {
11
               System.out.println(s);
12
           }
13
       });
14
       // forEach 方法就是等价于foreach循环
15
       //  list.forEach((t) -> {System.out.println(t)};); 省略后
16
       list.forEach(t -> System.out.println(t));
17
   }