云烟阁--Java8系列之函数式接口和Lambda表达式(一)

新的一周又开始了，这周小宋也有了新的计划，最近几个月有点懈怠，因为新的公司早上10点才上班导致我也习惯了晚睡晚起，今天决定开始恢复良好的作息早睡早起，第二天6点半起来去楼下的健身房运动，然后回来学习一下再去上班。会在接下来的博客中和各位同学一起见证我们各自的改变。

目录

Java8新特性

为了方便接下java8的学习先列举一下java8的新特性。、

Java8新特性：

  1. Lambda 表达式
  2. 函数式接口
  3. java8 方法引用
  4. java8 默认方法
  5. java8 Stream
  6. java8 Optional类
  7. Nashorn，JavaScript引擎
  8. java8 日期时间 API
  9. Java8 Base64

1. lambda表达式

Lambda 表达式，也可称为闭包，它是推动 Java 8 发布的最重要新特性。
Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。
使用Lambda 表达式可以使我们的代码变的更加简洁紧凑。

1.1 语法

Lambda表达式语法规则主体分为两个部分，中间用“->”右箭头连接，左边代表参数，右边代表函数主体。
在这里插入图片描述
语法格式如下：
(parameters) -> expression或(parameters) ->{statements; }

<函数式接口> <变量名> = (参数1，参数2…) -> {
//方法体
}

lambda表达式的重要特征:

  • 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。

  • 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。

  • 可选的大括号：如果主体包含了一个语句，就不需要使用大括号。

  • 可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指明表达式返回了一个数值。

1.2 实例

public class Java8Tester {
    public static void main(String args[]) {
        Java8Tester tester = new Java8Tester();
        // 参数类型声明
        MathOperation addition = (int a, int b) -> a + b;
        // 参数不用类型声明
        MathOperation subtraction = (a, b) -> a - b;
        // 大括号中的返回语句
        MathOperation multiplication = (int a, int b) -> {
            return a * b;
        };
        // 没有大括号及返回语句
        MathOperation division = (int a, int b) -> a / b;
        
        System.out.println("10 + 5 = " + tester.operate(10, 5, addition));
        System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));
        System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));
        System.out.println("10 / 5 = " + tester.operate(10, 5, division));
        // 不用括号
        GreetingService greetService1 = message ->
                System.out.println("Hello " + message);
        // 用括号
        GreetingService greetService2 = (message) ->
                System.out.println("Hello " + message);
        greetService1.sayMessage("Runoob");
        greetService2.sayMessage("Google");
    }
    interface MathOperation {
        int operation(int a, int b);
    }
    interface GreetingService {
        void sayMessage(String message);
    }
    private int operate(int a, int b, MathOperation mathOperation) {
        return mathOperation.operation(a, b);
    }
}

执行输出如下:
10+5=15
10-5=5
10 x 5=50
10/5=2
HelloRunoob
HelloGoogle

注意：

  1. Lambda 表达式主要用来定义行内执行的方法类型接口，例如，一个简单方法接口，函数式接口。在上面例子中，我们使用各种类型的Lambda表达式来定义MathOperation接口的方法。然后我们定义了sayMessage的执行。

  2. Lambda 表达式免去了写匿名内部类去使用匿名方法的麻烦，并且给予Java简单但是强大的函数化的编程能力。

1.3 变量作用域

lambda 表达式只能引用标记了 final 的外层局部变量，这就是说不能在lambda 内部修改定义在域外的局部变量，否则会编译错误。

public class Java8Tester {
    final static String salutation = "Hello! ";
	public static void main(String args[]){
	    GreetingService greetService1 = message ->
	            System.out.println(salutation + message);
	    greetService1.sayMessage("Runoob");
		//====================上面lambda表达式相当于下面的匿名内部类=======================
	    GreetingService g = new GreetingService() {
	        @Override
	        public void sayMessage(String message) {
	            System.out.println(salutation + message);
	        }
	    };
	    g.sayMessage("jack");
	　　}
	interface GreetingService {
   		void sayMessage(String message);
	}　
}

执行以上脚本，输出结果为：
Hello! Runoob
Hello! jack

lambda 表达式的局部变量可以为final，也可以不用声明为 final，但是必须不可被后面的代码修改（即隐性的具有final 的语义）

public class Java8Tester {
    public static void main(String args[]) {
        final int num = 1;
        Converter<Integer, String> s = (param) -> System.out.println(String.valueOf(param + num));
        s.convert(2);  // 输出结果为 3
    }
 
    public interface Converter<T1, T2> {
        void convert(int i);
    }
}

下面这段代码因为声明的局部变量不是final，然后在后面被修改了会报错。

public class Java8Tester {
    public static void main(String args[]) {
        int num = 1;
        Converter<Integer, String> s = (param) -> System.out.println(String.valueOf(param + num));
        s.convert(2);
        num = 5;
    }
    public interface Converter<T1, T2> {
        void convert(int i);
    }
}

报错信息

Local variable num defined in an enclosing scope must be final or effectively final

去掉num = 5;解决

2. 函数式接口

2.1 @FunctionalInterface

我们在函数式接口上面加上此注解后，里面就只能够有一个抽象方法了，但是可以有多个非抽象方法。当然不加此注解且只有一个抽象方法的接口也是函数式接口，只是没有限定提示而已。

函数式接口可以被隐式转换为lambda表达式。
eg.
在这里插入图片描述

2.2 java8函数式接口

JDK 1.8之前已有的函数式接口:

  • java.lang.Runnable
  • java.util.concurrent.Callable
  • java.security.PrivilegedAction
  • java.util.Comparator
  • java.io.FileFilter
  • java.nio.file.PathMatcher
  • java.lang.reflect.InvocationHandler
  • java.beans.PropertyChangeListener
  • java.awt.event.ActionListener
  • javax.swing.event.ChangeListener

JDK 1.8 新增加的函数接口：

  • java.util.function

2.3 java.util.function

java.util.function 它包含了很多类，用来支持 Java的函数式编程，该包中的函数式接口有：
在这里插入图片描述
BiConsumer<T,U>
代表了一个接受两个输入参数的操作，并且不返回任何结果

BiFunction<T,U,R>
代表了一个接受两个输入参数的方法，并且返回一个结果

BinaryOperator
代表了一个作用于于两个同类型操作符的操作，并且返回了操作符同类型的结果

BiPredicate<T,U>
代表了一个两个参数的boolean值方法

BooleanSupplier
代表了boolean值结果的提供方

Consumer< T >
代表了接受一个输入参数并且无返回的操作

DoubleBinaryOperator
代表了作用于两个double值操作符的操作，并且返回了一个double值的结果。

DoubleConsumer
代表一个接受double值参数的操作，并且不返回结果。

DoubleFunction< R >
代表接受一个double值参数的方法，并且返回结果

DoublePredicate
代表一个拥有double值参数的boolean值方法

DoubleSupplier
代表一个double值结构的提供方

DoubleToIntFunction
接受一个double类型输入，返回一个int类型结果。

DoubleToLongFunction
接受一个double类型输入，返回一个long类型结果

DoubleUnaryOperator
接受一个参数同为类型double,返回值类型也为double。

Function<T,R>
接受一个输入参数，返回一个结果。

IntBinaryOperator
接受两个参数同为类型int,返回值类型也为int 。

IntConsumer
接受一个int类型的输入参数，无返回值。

IntFunction< R >
接受一个int类型输入参数，返回一个结果。

IntPredicate
接受一个int输入参数，返回一个布尔值的结果。

IntSupplier
无参数，返回一个int类型结果。

IntToDoubleFunction
接受一个int类型输入，返回一个double类型结果。

IntToLongFunction
接受一个int类型输入，返回一个long类型结果。

IntUnaryOperator
接受一个参数同为类型int,返回值类型也为int 。

LongBinaryOperator
接受两个参数同为类型long,返回值类型也为long。

LongConsumer
接受一个long类型的输入参数，无返回值。

LongFunction< R >
接受一个long类型输入参数，返回一个结果。

LongPredicate
R接受一个long输入参数，返回一个布尔值类型结果。

LongSupplier
无参数，返回一个结果long类型的值。

LongToDoubleFunction
接受一个long类型输入，返回一个double类型结果。

LongToIntFunction
接受一个long类型输入，返回一个int类型结果。

LongUnaryOperator
接受一个参数同为类型long,返回值类型也为long。

ObjDoubleConsumer< T >
接受一个object类型和一个double类型的输入参数，无返回值。

ObjIntConsumer< T >
接受一个object类型和一个int类型的输入参数，无返回值。

ObjLongConsumer< T >
接受一个object类型和一个long类型的输入参数，无返回值。

Predicate< T >
接受一个输入参数，返回一个布尔值结果。

Supplier< T >
无参数，返回一个结果。

ToDoubleBiFunction<T,U>
接受两个输入参数，返回一个double类型结果

ToDoubleFunction< T >
接受一个输入参数，返回一个double类型结果

ToIntBiFunction<T,U>
接受两个输入参数，返回一个int类型结果。

ToIntFunction< T >
接受一个输入参数，返回一个int类型结果。

ToLongBiFunction<T,U>
接受两个输入参数，返回一个long类型结果。

ToLongFunction< T >
接受一个输入参数，返回一个long类型结果。

UnaryOperator< T >
接受一个参数为类型T,返回值类型也为T。

2.4实例

Predicate 接口是一个函数式接口，它接受一个输入参数 T，返回一个布尔值结果。

该接口包含多种默认方法来将Predicate组合成其他复杂的逻辑（比如：与，或，非）。

该接口用于测试对象是 true 或 false。

通过下面的实例来了解函数式接口 Predicate 的使用：

public class Java8Tester {
    public static void main(String args[]){
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
 
        // Predicate<Integer> predicate = n -> true
        // n 是一个参数传递到 Predicate 接口的 test 方法
        // n 如果存在则 test 方法返回 true
 
        System.out.println("输出所有数据:");
 
        // 传递参数 n
        eval(list, n->true);
 
        // Predicate<Integer> predicate1 = n -> n%2 == 0
        // n 是一个参数传递到 Predicate 接口的 test 方法
        // 如果 n%2 为 0 test 方法返回 true
 
        System.out.println("输出所有偶数:");
        eval(list, n-> n%2 == 0 );
 
        // Predicate<Integer> predicate2 = n -> n > 3
        // n 是一个参数传递到 Predicate 接口的 test 方法
        // 如果 n 大于 3 test 方法返回 true
 
        System.out.println("输出大于 3 的所有数字:");
        eval(list, n-> n > 3 );
    }
 
    public static void eval(List<Integer> list, Predicate<Integer> predicate) {
        for(Integer n: list) {
 
            if(predicate.test(n)) {
                System.out.println(n + " ");
            }
        }
    }
}

输出:
1 2 3 4 5 6 7 8 9
输出所有偶数:
2 4 6 8
输出大于3的所有数字:
4 5 6 7 8 9

讲到这里本章对java8函数式接口和Lambda表达式的讲解也就结束了，如果想了解更多知识可以在对应的专栏中看系列文章，谢谢大家的观看，希望能给各位同学带来帮助。如果觉得博主写的还可以的，可以点赞收藏。 😉

posted @ 2020-12-21 14:23  奋斗的小宋  阅读(24)  评论(0)    收藏  举报