java8学习：Lambda表达式

Lambda表达式

Lambda是一个匿名函数，我们可以baLambda表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。可以写出更简洁，更灵活的代码。作为一种更紧凑得代码风格，使得java得语言表达能力得到提升。Lambda表达式需要函数式接口的支持，接口中只有一个抽象方法得接口叫做函数式接口。可以使用@FunctionalInterface修饰，可以检查是否是函数式接口。

1. lambda表达式格格式

(参数列表) -> {lambda主体}

• (参数列表)：参数列表，可以有参数，也可以无参
• -> : 箭头-> 把参数列表和lambda主体分开。
• lambda主体：主体中编写操作逻辑。

2. 表达式举例

• (String s)->s.length()：有参数，有返回值。参数为String类型的s,返回值为s的长度。隐藏{}和return。当lambda主体中只有一句代码时，可以省略{}和return，也可以省略参数类型。
• (String s)->{return s.length();}： 有参数，有返回值。参数为String类型的s,返回值为s的长度。显示{}和return，也可以省略参数类型。
• (String s)->System.out.println(s):有参数无返回值。
• (String s)->{System.out.println(s);}:有参数无返回值。
• ()->return true：无参数，有返回值。隐藏{}和return
• ()->{return true;}：无参数，有返回值。显示{}和return。
• ()-> System.out.println(“Hello World”)：无参数，无返回值。隐藏{}和return
• ()->{ System.out.println(“Hello World”);}：无参数，无返回值。显示{}和return。

示例代码：

有参数有返回值

 BinaryOperator<Long> add1 = new BinaryOperator<Long>() {
            @Override
            public Long apply(Long a, Long b) {
                return a+b;
            }
        };

BinaryOperator<Long> add2 = (x,y)->x+y;

有参数无返回值

ActionListener listener1 = new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("listener1 button click");
            }
        };

        ActionListener listener12 = (ActionEvent event) ->{
            System.out.println("listener12 button click");
        };
        //当参数列表中参数为1个时，可以省略（）和参数的类型
        ActionListener listener13 = event ->{
            System.out.println("listener12 button click");
        };

无参数有返回值

@FunctionalInterface
public interface TimeInterface {

    Date getCorrectDate();
}

TimeInterface timeInterface = new TimeInterface() {
            @Override
            public Date getCorrectDate() {
                return new Date();
            }
        };
        
TimeInterface timeInterface1 = ()->new Date();

无参数无返回值

 Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello World");
            }
        });

 Thread thread1 = new Thread(()->{System.out.println("Hello World");});

3. 函数式接口

Lambda表达式需要“函数式接口”的支持 。 函数式接口：接口中只有一个抽象方法时，那么这个接口叫做函数式接口。函数式接口可以使用@FunctionalInterface修饰，jvm会自动检查该接口是否为函数式接口。

java8提供4大类“函数式接口”。在java.util.function包下。

接口	描述
Consumer	消费型接口(void accept(T t))
Supplier	供给型接口(T get())
Function	函数型接口(R apply(T t))
Predicate	断言型接口(boolean test(T t))

Consumer类型

@FunctionalInterface
public interface Consumer<T> {

    void accept(T t);
    
    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

//消费型 函数式接口 有参数无返回值
Consumer<String> consumer = (x)-> System.out.println(x);
consumer.accept("Hello World");

Supplier类型

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

//供给型接口 无参数，有返回值
Supplier<String> supplier  = ()->{return "Hello World";};
String s = supplier.get();
System.out.println(s);

Function类型

@FunctionalInterface
public interface Function<T, R> {

    R apply(T t);

    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

//函数型接口 有参数有返回值
Function<Integer,String> function = (i)->{return i.toString();};
String s = function.apply(50);
System.out.println(s);

Predicate类型

@FunctionalInterface
public interface Predicate<T> {

    boolean test(T t);

    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

    default Predicate<T> negate() {
        return (t) -> !test(t);
    }

    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

//断言型接口 有参数有返回值，返回值为boolean型。
//判断传入的参数是否比100大
Predicate<Integer> predicate = (i)->{return i>100;};
System.out.println(predicate.test(50));
System.out.println(predicate.test(120));

4. 方法引用

方法引用：若lambda 体中得内容已经有方法实现了，我们可以使用方法引用（可以理解为方法引用为lambda表达式得另一种表现形式）

方法引用主要有三类

• 指向静态方法的引用
• 指向任意类型实例方法的方法引用
• 指向现有对象的实例方法的方法引用

4.1 指向静态方法的引用

//将String类型值转换为Integer类型
Function<String, Integer> function1 = s -> Integer.parseInt(s);

Function<String, Integer> function2 = Integer::parseInt;

System.out.println(function1.apply("123"));
System.out.println(function2.apply("456"));

//Integer类中的parseInt是静态方法
public static int parseInt(String s) throws NumberFormatException {
        return parseInt(s,10);
}

4.2 指向任意类型实例方法的方法引用

//输入字符串，返回字符串长度
Function<String, Integer> function3 = s -> s.length();

Function<String, Integer> function4 = String::length;

System.out.println(function3.apply("Hello World!"));
System.out.println(function4.apply("Hello Java"));
//输入路径，创建File对象
Function<String,File> function5 = s -> new File(s);
Function<String,File> function6 = File::new;

File file1 = function5.apply("d:/a.txt");
File file2 = function6.apply("d:/b.txt");

//String类中的求长度方法
public int length() {
   return value.length;
}

4.3 指向现有对象的实例方法的方法引用

List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
//根据下标查询list中数据
Function<Integer,String> function1 = i -> list.get(i);
Function<Integer,String> function2 = list::get;

System.out.println(function1.apply(1));
System.out.println(function2.apply(2));