Lambda表达式初步与函数式接口

何为Lambda表达式

Lambda : In programming languages such as Lisp, Python and Ruby lambda is an operator used to denote anonymous functions or closures,following the usage of lambda calculus.

为何需要Lambda表达式

  • 在Java中，我们无法将函数作为参数传递给一个方法，也无法声明返回一个函数的方法
  • 在JavaScript中，函数参数是一个函数，返回值是另一个函数的情况是非常常见的；JavaScript是一门非常典型的函数式语言
SwingTest.java
package cn.acyco.jdk8;

import javax.swing.*;

/**
 * @author Acyco
 * @create 2019-12-18 14:27
 */
public class SwingTest {
    public static void main(String[] args) {
        JFrame jFrame = new JFrame("My JFrame");
        JButton jButton = new JButton("My JButton");
/*        jButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("ButtonPressed!");
            }
        });*/
//        jButton.addActionListener(e -> System.out.println("ButtonPressed!"));
        jButton.addActionListener(e -> {
            System.out.println("ButtonPressed!");
            System.out.println("ButtonPressed!");
            System.out.println("ButtonPressed!");
        });


        jFrame.add(jButton);
        jFrame.pack();
        jFrame.setVisible(true);
        jFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}

Lambda表达式的基本结构

（param1,param2,param3)->{}
Test1.java
package cn.acyco.jdk8;

import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;

/**
 * @author Acyco
 * @create 2019-12-18 14:33
 */
public class Test1 {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7,8);

        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));

        }
        System.out.println("-------------------------");
        for (Integer i : list) {
            System.out.println(i);
        }
        System.out.println("-------------------------");

        list.forEach(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                System.out.println(integer);
            }
        });
        System.out.println("-------------------------");
        list.forEach(e-> System.out.println(e));

        System.out.println("-------------------------");
        list.forEach(System.out::println);
    }
}
函数式接口

Note that instances of functional interfaces can be created with lambda expressions, method references, or constructor references.

  1. 如果在一个接口只有一个抽象方法，那么该接口就是一个函数式接口
  2. 如果在某个接口上声明了FunctionalInterface注解，那么编译器就分按照函数式接口的定义来要求该这个接口
  3. 如果某个接口只有一个抽象方法， 但我们并没给该接口声明FunctionalInterface注解，那么编译器依旧会将该接口看作是函数式接口（就是说不加也可以，但最好还是加上注解那样会更好）

Test2.java




@FunctionalInterface
interface MyInterface {
    void test();
    String toString();//继承Ojbect父类 他复写了Object类的方法 他不会在向抽象接口方法数量加1 所有抽象方法还是只有一个
    //String MyString(); //这个就会在抽象接口
}

public class Test2 {

    public void myTest(MyInterface myInterface) {

        System.out.println(1);
        myInterface.test();
        System.out.println(1);
    }

    public static void main(String[] args) {
        Test2 test = new Test2();
       /* test.myTest(new MyInterface() {
            @Override
            public void test() {
                System.out.println("mytest");
            }
        });*/

        test.myTest(() -> {
            System.out.println("mytest. lambda..");
        });
        System.out.println("-------------------------");
        MyInterface myInterface = () -> {
            System.out.println("helo");
        };
     /*   System.out.println(myInterface.getClass()); //lambda表达式是对象 class cn.acyco.jdk8.Test2$$Lambda$2/1078694789
        System.out.println(myInterface.getClass().getSuperclass());
        System.out.println(myInterface.getClass().getInterfaces()[0]);
        */
    }
}

深入函数式接口与方法调用

Test1.java
package cn.acyco.jdk8;

import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;

/**
 * @author Acyco
 * @create 2019-12-18 14:33
 */
public class Test1 {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7,8);
        list.forEach(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                System.out.println(integer);
            }
        });
        System.out.println("-------------------------");
        list.forEach(e-> System.out.println(e));

        System.out.println("-------------------------");
        list.forEach(System.out::println);
    }
}

list.forEach（内部迭代）

default void forEach(Consumer<? super T> action) {
    Objects.requireNonNull(action);
    for (T t : this) {
        action.accept(t);
    }
}

forEach方法特殊之处是前面有一个default，接口里面但凡JDK8开始也可以拥有方法实现了，但凡 接口定义方法实现，我们称这样的接口为默认方法 （有点像入抽象类那样）

list.forEach(System.out::println); 方法引用 method reference

Lambda表达式作用

  • Lambda表达式为Java添加了缺失的函数式编程特性，便我们能将函数当作一等公民看待
  • 在将函数作为一等公民的语言中，Lambda表达式的类型是函数，但在Java中，Lambda表达式是对象，他们必须依附于一类特别的对象类型——函数式接口（functional interface)
  • 传递行为，而不仅仅是值
  • 提升抽象层次
  • API重用性更好
  • 更加灵活

Lambda表达式深入与流初步

Test3.java
package cn.acyco.jdk8;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Function;

/**
 * @author Acyco
 * @create 2019-12-18 15:50
 */
public class Test3 {
    public static void main(String[] args) {
        TheInterFace i1 = () -> {};
//        System.out.println(i1.getClass().getInterfaces()[0]);
        TheInterFace i2 = () -> {};
//        System.out.println(i1.getClass().getInterfaces()[0]);

//        new Thread(()-> System.out.println("heeeell")).start();

        List<String> list = Arrays.asList("hello", "world", "hello world");

//        list.forEach(item->System.out.println(item.toUpperCase()));

        List<String> list2 = new ArrayList<>();
//        list.forEach(item -> list2.add(item.toUpperCase()));
//        list2.forEach(item->System.out.println(item));

//        list.stream().map(item -> item.toUpperCase()).forEach(item-> System.out.println(item));
//        list.stream().map(String::toUpperCase).forEach(item-> System.out.println(item));
        Function<String, String> function = String::toUpperCase;
        System.out.println(function.getClass().getInterfaces()[0]); //interface java.util.function.Function
    }
}

@FunctionalInterface
interface TheInterFace{
    void myMethod();
}
@FunctionalInterface
interface TheInterFace2{
    void myMethod2();
}

   default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }

类似Linux Pipeline 返回串行流

spliterator() split iterator 分割迭代器 把流所在对应目标数据进行了一次分割

function接口详解

  Function<String, String> function = String::toUpperCase;
        System.out.println(function.getClass().getInterfaces()[0]); //interface java.util.function.Function
StringComparator.java
package cn.acyco.jdk8;

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * @author Acyco
 * @create 2019-12-18 18:36
 */
public class StringComparator {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("zhangshan", "lisi", "wangwu", "zhaoliu");
/*        Collections.sort(names, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o2.compareTo(o1);
            }
        });
        System.out.println(names);*/


       /* Collections.sort(names, (String o1, String o2) -> {
            return o2.compareTo(o1);
        });*/
//        Collections.sort(names, Comparator.reverseOrder());
        Collections.sort(names, (String o1, String o2) -> o2.compareTo(o1));
        System.out.println(names);
    }
}

Java Lambda基本语法

  • Java中的Lambda表达式基本语法

（argument) -> {body}

​ (arg1,arg2) -> {body}

​ (type1 arg1, type2 arg2) -> }{body}

  • 示例说明

    • (int a, int b) -> { return a + b; }
    • () -> System.out.println("Hello, Acyco");
    • (String s) -> { System.out.println(s) }
    • () -> 43 ;
    • () -> { return 3.1415};

Java Lambda结构

  • 一个Lambda表达式可以有零个或多个参数
  • 参数的类型既可以明确声明，也可以根据上下文来判断。例如： （int a）和 （a）效果相同
  • 所有参数需包含在圆括号内，参数之间用逗号相隔。例如 :(a, b) 或(int a, int b) 或(String a, int b, float c)
  • 空圆括号代表参数集为空。例如： () -> 43 ; () -> { return 3.1415};
  • 当只有一个参数，且类型可推导时，圆括号()可以省略。 例如： a-> return a*a
  • Lambda表达式的主体可包含零条或多条语句。
  • 如果Lambda表达式的主体只有一条语句， 花括号{}也可以省略的。匿名函数的返回与该主体表达式一致。
  • 如果Lambda表达式的主体包含一条以上的语句，则表达式必须包含在花括号{}中(形成代码块)。 匿名函数的返回类型与代码块的返回类型一致，或没有返回则为空。
最后修改：2019 年 12 月 24 日 03 : 34 PM
© 允许规范转载
如果觉得我的文章对你有用，请随意赞赏