备注1：观察发现，函数式接口下共有
1、三种方法
1.1 唯一的抽象方法
1.2 使用default定义普通方法（默认方法），通过对象调用。
实现接口后，因为默认方法不是抽象方法，所以可以不重写，但是如果开发需要，也可以重写 。当然如果接口中的默认方法不能满足某个实现类需要，那么实现类可以覆盖默认方法。签名跟接口default方法一致,但是不能再加default修饰符。
3.使用static定义静态方法，通过接口名调用。
2、一个新注解
如果现在某一个接口就是为了函数式接口而生的，定义的时候就让其只有一个抽象方法，所以有了一个新的注解：函数式接口@FunctionInterface
备注2：关于lambda表达式
JDK8以前，通过匿名内部类可以实现接口
Function<Integer, String> fun = new Function<Integer, String>() {
@Override
public String apply(Integer t) {
return String.valueOf(t);
}
};JDK8中，通过lambda表达式实现
Function<Integer, String> fun = (x) -> String.valueOf(x);可以得出一个结论，lambda表达式就是为了优化匿名内部类而生。
String res = fun.apply(1000);
System.out.println(res); 一、Function功能型函数式接口
Function接口 接受一个输入参数T，返回一个结果R。
package java.util.function;
import java.util.Objects;
@FunctionalInterface
public interface Function<T, R> {
// 接受输入参数，对输入执行所需操作后 返回一个结果。
R apply(T t);
// 返回一个 先执行before函数对象apply方法，再执行当前函数对象apply方法的 函数对象。
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));
}
// 返回一个 先执行当前函数对象apply方法， 再执行after函数对象apply方法的 函数对象。
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
// 返回一个执行了apply()方法之后只会返回输入参数的函数对象。
static <T> Function<T, T> identity() {
return t -> t;
}
}例：apply方法使用
public class FunctionDemo {
static int modifyTheValue(int valueToBeOperated, Function<Integer, Integer> function) {
return function.apply(valueToBeOperated);
}
public static void main(String[] args) {
int myNumber = 10;
// 使用lambda表达式实现函数式接口
// (x)->(x)+20 输入一个参数x，进行加法运算，返回一个结果
// 所以该lambda表达式可以实现Function接口
int res1 = modifyTheValue(myNumber, (x)-> x + 20);
System.out.println(res1); // 30
// 使用匿名内部类实现
int res2 = modifyTheValue(myNumber, new Function<Integer, Integer>() {
@Override
public Integer apply(Integer t) {
return t + 20;
}
});
System.out.println(res2); // 30
}
}例：andThen方法使用
public static Integer modifyTheValue2(int value, Function<Integer, Integer> function1, Function<Integer, Integer> function2){
//value作为function1的参数，返回一个结果，该结果作为function2的参数，返回一个最终结果
return function1.andThen(function2).apply(value);
}
public static void main(String[] args) {
System.out.println(modifyTheValue2(3, val -> val + 2, val -> val + 3));
}二、Consumer消费型函数式接口
代表了 接受一个输入参数并且无返回的操作
例：accept方法使用
public static void modifyTheValue3(int value, Consumer<Integer> consumer) {
consumer.accept(value);
}
public static void main(String[] args) {
// (x) -> System.out.println(x * 2)接受一个输入参数x
// 直接输出，并没有返回结果
// 所以该lambda表达式可以实现Consumer接口
modifyTheValue3(3, (x) -> System.out.println(x * 2));
}输出：
6三、Predicate断言型函数式接口
接受一个输入参数，返回一个布尔值结果。
例：test方法使用1
public static boolean predicateTest(int value, Predicate<Integer> predicate) {
return predicate.test(value);
}
public static void main(String[] args) {
// (x) -> x == 3 输入一个参数x，进行比较操作，返回一个布尔值
// 所以该lambda表达式可以实现Predicate接口
System.out.println(predicateTest(3, (x) -> x == 3));
}输出：
true例：test方法使用2
public static void eval(List<Integer> list, Predicate<Integer> predicate) {
for (Integer n : list) {
if (predicate.test(n)) {
System.out.print(n + " ");
}
}
// list.forEach(n -> {
// if (predicate.test(n)) {
// System.out.print(n + " ");
// }
// });
}
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("\n输出所有偶数:");
eval(list, n -> n % 2 == 0);
// Predicate<Integer> predicate2 = n -> n > 3
// n 是一个参数传递到 Predicate 接口的 test 方法
// 如果 n 大于 3 test 方法返回 true
System.out.println("\n输出大于 3 的所有数字:");
eval(list, n -> n > 3);
}输出：
输出所有数据:
1 2 3 4 5 6 7 8 9
输出所有偶数:
2 4 6 8
输出大于 3 的所有数字:
4 5 6 7 8 9 例：test方法使用3
public static boolean validInput(String name, Predicate<String> function) {
return function.test(name);
}
public static void main(String args[]) {
String name = "冷冷";
if(validInput(name, s -> !s.isEmpty() && s.length() <= 3 )) {
System.out.println("名字输入正确");
}
}三、Supplier供给型函数式接口
无参数，返回一个结果。
例：get方法使用
public static String supplierTest(Supplier<String> supplier) {
return supplier.get();
}
public static void main(String args[]) {
String name = "冷冷";
// () -> name.length() 无参数，返回一个结果（字符串长度）
// 所以该lambda表达式可以实现Supplier接口
System.out.println(supplierTest(() -> name.length() + ""));
}输出：2
=================================================================================================
另一个解析
Predicate:
简单上一段代码:
Predicate<String> predicate = (s) -> s.length() > 0;
predicate.test("test java 1.8"); // true
predicate.negate().test("test java 1.8"); // false
Predicate<Boolean> nonNull = Objects::nonNull;
Predicate<Boolean> isNull = Objects::isNull;
Predicate<String> isEmpty = String::isEmpty;
Predicate<String> isNotEmpty = isEmpty.negate();- 1
- 2
- 3
- 4
- 5
- 6
- 7
简单说
Predicate 接口只是用来做 判断 的,提前写好判断的条件,然后传对象到test()方法里面,进行判断是否符合判断条件.
Predicate 只有一个 非defult 方法, test() ,返回值只有 boolean 类型,符合条件就是true,不符合就是 false .
个人认为更像是用来 判空 的.
Function :
简单上一段代码:
//Function <参数类型,返回值类型>
Function<String, Integer> toInteger = Integer::parseInt;
//addThen(参数类型::需要调用的方法)
toInteger.andThen(String::valueOf);
Integer apply = toInteger.apply("test java 1.8 function");- 1
- 2
- 3
- 4
- 5
简单说
Function 接口就是将需要调用的 参数 的 调用步骤 ,提前写好了,然后 返回值 也指定好了,就等着 一步步执行 了 , 非常简单的一个使用步骤.
Function 只有一个 非defult 方法, apply() ,返回值是 第二个泛型 的类型, apply 之后就会返回 值 .个人认为,他的价值,更像是充当一个 方法 的使用 .
Supplier:
简单上一段代码:
Supplier<String> strSupplier = String::new;
String str = strSupplier.get();- 1
- 2
简单说:
这个是真简单,就是 new .Supplier 接口就相当于手动new一个对象的实例出来.然后 get() 出来.
Supplier 与 直接new对象 的区别是: Supplier 不接收任何参数,不能 new 接口 与 抽象类 .
Consumer:
简单上一段代码:
Consumer<String> greeter = (s) -> System.out.println("String lenght = " + s.length());
greeter.accept(new String("test java 1.8 consumer"));- 1
- 2
简单说:
Consumer 接口也是真的非常简单,就是 提前调用对象的方法 ,然后在 accept 里将对象传递进去,与 Function 的区别,在下认为是 Consumer 没有返回值,而 Function 有 返回值.
Comparator:
简单上一段代码:
Comparator<Person> comparator = (p1, p2) -> p1.firstName.compareTo(p2.firstName);
Person p1 = new Person("John", "Doe");
Person p2 = new Person("Alice", "Wonderland");
comparator.compare(p1, p2); // > 0
comparator.reversed().compare(p1, p2); // < 0 - 1
- 2
- 3
- 4
- 5
简单说:
Comparator 接口就是用来做 比较 的.在 构造函数 中,进行编写 比较条件 ,然后在 compare 方法中,传递对象进行进去比较,返回比较的结果 boolean .
Optional:
简单上一段代码:
Optional<String> optional = Optional.of("test java 1.8 optional");
optional.isPresent(); // true
optional.get(); // "test java 1.8 optional"
optional.orElse("test java 1.8 optional"); // "test java 1.8 optional"
optional.ifPresent((s) -> System.out.println(s.charAt(0))); // "t"- 1
- 2
- 3
- 4
- 5
简单说:
Optional 就是一个容器 ,他的价值,在于他装得东西.要不是null,要不是非null.
获取 Optional 对象的实例,需要调用他的静态方法 of() ,将对象传进去.