1、函数式接口(Functional Interface)@FunctionalInterface
函数式接口就是一个有且仅有一个抽象方法,但是可以有多个非抽象方法的接口;
可以被隐式转换为lambda表达式;
可以现有的函数友好地支持 lambda。
2、Lambda表达式
lambda表达式的重要特征:
- 可选类型声明:不需要声明参数类型,编译器可以统一识别参数值。
- 可选的参数圆括号:一个参数无需定义圆括号,但多个参数需要定义圆括号。
- 可选的大括号:如果主体包含了一个语句,就不需要使用大括号。
- 可选的返回关键字:如果主体只有一个表达式返回值则编译器会自动返回值,大括号需要指定明表达式返回了一个数值。
Lambda 表达式实例
Lambda 表达式的简单例子:
// 1. 不需要参数,返回值为 5
() -> 5
// 2. 接收一个参数(数字类型),返回其2倍的值
x -> 2 * x
// 3. 接受2个参数(数字),并返回他们的差值
(x, y) -> x – y
// 4. 接收2个int型整数,返回他们的和
(int x, int y) -> x + y
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
(String s) -> System.out.print(s)
package Lambda;
public class Java8Tester {
public static void main(String args[]) {
Java8Tester java8Tester = new Java8Tester();
Math m1 = (a, b) -> (int) a + (int) b;
System.out.println(m1.operation(1, 2));
Math m2 = (a, b) -> a + (String) b;
System.out.println(m2.operation("hello ", "world"));
Math m3 = (Object a, Object b) -> a.equals(b);
System.out.println(m3.operation("hello", "hello"));
Math.method1();
Test t1 = () -> {
System.out.println(3123);
};
t1.test();
int a = 2018;
/*
* 没有方法体要写大括号
* 正确写法: Test t2 = () -> {};
* 错误写法: Test t2 = () -> ;
*/
Test t2 = () -> {
System.out.println(a);
};
/*
* 如果在lambda中引用了变量,不允许在其他地方修改a的值,变量默认为final
* 错误信息Local variable a defined in an enclosing scope must be final or effectively
*/
// a = 2;
t2.test();
}
// 函数式接口
@FunctionalInterface
interface Math<T> {
/*
* 只能定义一个public abstract或默认方法
* 可以定义多个 static方法 和 default方法
*/
// T operation();
public abstract T operation(T a, T b);
static void method1() {
System.out.println("static method1()");
}
static void method2() {
System.out.println("static method2()");
}
default String method3() {
return "default method3()";
}
default String method4() {
return "default method4()";
}
}
interface Test {
void test();
}
}
3、方法引用 ::
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Supplier;
public class Java8Tester {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("ss");
list.add("1");
list.add("3123");
list.add("31321");
list.forEach(System.out::println);
// 构造器引用:它的语法是Class::new,或者更一般的Class< T >::new实例如下:
final Car car = Car.create( Car::new );
final List< Car > cars = Arrays.asList( car );
// 静态方法引用:它的语法是Class::static_method,实例如下:
cars.forEach( Car::collide );
// 特定类的任意对象的方法引用:它的语法是Class::method实例如下
cars.forEach( Car::repair );
// 特定对象的方法引用:它的语法是instance::method实例如下:
final Car police = Car.create( Car::new );
cars.forEach( police::follow );
}
}
class Car {
//Supplier是jdk1.8的接口,这里和lamda一起使用了
public static Car create(final Supplier<Car> supplier) {
return supplier.get();
}
public static void collide(final Car car) {
System.out.println("Collided " + car.toString());
}
public void follow(final Car another) {
System.out.println("Following the " + another.toString());
}
public void repair() {
System.out.println("Repaired " + this.toString());
}
}
package java.util.function;
/**
* Represents a supplier of results.
*
* <p>There is no requirement that a new or distinct result be returned each
* time the supplier is invoked.
*
* <p>This is a <a href="package-summary.html">functional interface</a>
* whose functional method is {@link #get()}.
*
* @param <T> the type of results supplied by this supplier
*
* @since 1.8
*/
@FunctionalInterface
public interface Supplier<T> {
/**
* Gets a result.
*
* @return a result
*/
T get();
}