Java8 新特性 -Lambda 表达式，zookeeper+dubbo 面试题
}
interface ICar {
void drive();
}
class IcarImpl implements ICar {
@Override
public void drive() {
System.out.println("Drive Benz");
}
}
[](
)案例 2 有参有返回值
public class Demo02 {
public static void main(String[] args) {
// 1.有参无返回
IEat eat1 = (String thing) -> System.out.println("eat " + thing);
eat1.eat("apple");
// 参数数据类型可以省略
IEat eat2 = (thing) -> System.out.println("eat " + thing);
eat2.eat("banana");
// 2.多个参数
ISpeak speak1 = (who, content) -> System.out.println(who + " talk " + content);
speak1.talk("John", "hello word");
// 3.返回值
IRun run1 = () -> {
return 10;
};
run1.run();
// 4.返回值简写
IRun run2 = () -> 10;
run2.run();
}
}
interface IEat {
void eat(String thing);
}
interface ISpeak {
void talk(String who, String content);
}
interface IRun {
int run();
}
[](
)案例 3 final 类型参数
public class Demo03 {
public static void main(String[] args) {
// 全写
IAddition addition1 = (final int a, final int b) -> a + b;
System.out.println(addition1.add(1, 2));
// 简写
IAddition addition2 = (a, b) -> a+b;
System.out.println(addition2.add(2, 3));
}
}
interface IAddition {
int add(final int a, final int b);
}
[](
)Java8 内置的函数式接口
Java8 提供了一个 java.util.function 包，包含了很多函数式接口，我们来介绍最为基本的 4 个（为了节省篇幅，去掉了源码中的注释）
[](
)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 接口的唯一抽象方法是 apply，作用是接收一个指定类型的参数，返回一个指定类型的结果
public class FunctionTest1 {
public static void main(String[] args) {
FunctionTest1 ft = new FunctionTest1();
//使用 lambda 表达式实现 ap
ply 方法，返回入参+10。形式上如同传递了一个方法作为参数
int res = ft.compute(1, v -> v + 10);
System.out.println(res);//11
}
public int compute(int a, Function<Integer, Integer> function) {
//使用者在使用本方法时，需要去编写自己的 apply，
//传递的 funtion 是一个行为方法，而不是一个值
return function.apply(a);
}
}
默认方法 compose 作用是传入参数后，首先执行 compose 方法内的 Function 的 apply 方法，然后将其返回值作为本 Function 方法的入参，调用 apply 后得到最后返回值
public class FunctionTest2 {
public static void main(String[] args) {
FunctionTest2 ft = new FunctionTest2();
//调用 compose
//先+8，然后将得到的值*3
System.out.println(ft.compute(2, v -> v * 3, v -> v + 8));//30
}
public int compute(int a, Function<Integer, Integer> function1, Function<Integer, Integer> function2) {
//将 function2 先接收入参 a，调用 apply 后，将返回值作为新的入参，传入 function1，调用 apply 返回最后结果
return function1.compose(function2).apply(a);
}
}
默认方法 andThen 与 compose 正好相反，先执行本 Function 的 apply，然后将结果作为 andThen 方法参数内的 Function 的入参，调用 apply 后返回最后结果
public class FunctionTest3 {
public static void main(String[] args) {
FunctionTest3 ft = new FunctionTest3();
//调用 andThen
//先*3，然后将得到的值+8
System.out.println(ft.compute(2, v -> v * 3, v -> v + 8));//14
}
public int compute(int a, Function<Integer, Integer> function1, Function<Integer, Integer> function2) {
//将 function2 先接收入参 a，调用 apply 后，将返回值作为新的入参，传入 function1，调用 apply 返回最后结果
return function1.andThen(function2).apply(a);
}
}
静态方法 identity 的作用是传入啥返回啥，这里就不写例子了
[](
)Consumer 接口
package java.util.function;
import java.util.Objects;
@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 接口中 accept 方法的作用是接收指定参数类型，无返回值，重点在于内部消费
Consumer<String> consumer = s -> System.out.println("hello " + s);
consumer.accept("mike");// hello mike
默认方法 andThen 作用是连续消费，从本 Consumer 开始，从外到内，针对同一入参。
Consumer<String> consumer = s -> System.out.println("hello " + s);
Consumer<String> consumer2 = s -> System.out.println("nice to meet you " + s);
consumer.andThen(consumer2).accept("mike");
//hello mike
//nice to meet you mike
[](
)Predicate 接口
package java.util.function;
import java.util.Objects;
@FunctionalInterface
public interface Predicate<T> {
boolean test(T t);
default Predicate<T> and(Predicate<? super T> other) {
还未添加个人签名 2021.03.18 加入
还未添加个人简介
评论