Lambda表达式
语法
//() -> {}
(String first, String second)->{first.length()-second.length()};
注: ():参数;->:指向; {}:代码体
函数式接口
对于只有一个抽象方法的接口,就可以提供一个lambda表达式。这种接口称为函数式接口
@FunctionalInterface //一个接口只能有一个lambda的函数接口
public interface lambdaInter {
void NoReturnPara();
}
public class lambdastudy {
public static void main(String[] args) {
lambdaInter lambdaInter1=() -> System.out.println("没有传参,没有输出");
lambdaInter1.NoReturnPara();
}
方法引用
//引用字符串比较方法
//String::compareToIgnoreCase
(x,y)->x.compareToIgnoreCase(y)
构造器引用
x-> new int[x]
lambda表达式能够延迟执行,从而可以节省性能
public class DemoLogger {
public static void main(String[] args) {
String msgA = "Hello ";
String msgB = "World ";
String msgC = "Java";
log(1, () -> { //当level==1时,才会执行拼接操作,否则,不执行
System.out.println("Lambada 执行!");
return msgA + msgB + msgC;
});
}
private static void log(int level, MessageBuilder mb) {
if (level == 1) {
System.out.println(mb.builderMessage());
}
}
}
java中常用的函数式接口:
Supplier接口
java.util.function.Supplier 接口仅包含一个无参的方法: T get() 。用来获取一个泛型参数指定类型的对象数据。由于这是一个函数式接口,这也就意味着对应的Lambda表达式需要“对外提供”一个符合泛型类型的对象数据。如:
import java.util.function.Supplier;
public class DemoSupplier {
public static void main(String[] args) {
String msgA = "HelloWorld ";
System.out.println(getString( () -> msgA ) );//控制台输出HelloWorld
}
private static String getString(Supplier<String> stringSupplier) {
return stringSupplier.get();
}
}
Consumer接口
java.util.function.Consumer 接口则正好与Supplier接口相反,它不是生产一个数据,而是消费一个数据, 其数据类型由泛型决定。
Consumer 接口中包含抽象方法 void accept(T t) ,意为消费一个指定泛型的数据。基本使用如:
import java.util.function.Consumer;
public class DemoConsumerAccept {
public static void main(String[] args) {
consumerString(s -> System.out.println(s));//控制台输出HelloWorld
}
private static void consumerString(Consumer<String> function) {
function.accept("HelloWorld");
}
}
如果一个方法的参数和返回值全都是 Consumer 类型,那么就可以实现效果:消费数据的时候,首先做一个操作, 然后再做一个操作,实现组合。而这个方法就是 Consumer 接口中的default方法 andThen 。
import java.util.function.Consumer;
public class DemoPrintInfo {
public static void main(String[] args) {
String[] array = { "张三,男", "李四,女", "王五,男" };
printInfo(//split(String regex) 将此字符串分割为给定的 regular expression的匹配。
s -> System.out.print("姓名:" + s.split(",")[0] + ","),
s -> System.out.println("性别:" + s.split(",")[1] + "。"),
array
);
}
private static void printInfo(Consumer<String> one, Consumer<String> two, String[] array) {
for (String info : array) {
one.andThen(two).accept(info);
}
}
}
/*程序输出:姓名:张三,性别:男。
姓名:李四,性别:女。
姓名:王五,性别:男。
*/
Predicate接口
有时候我们需要对某种类型的数据进行判断,从而得到一个boolean值结果。这时可以使用java.util.function.Predicate 接口。
boolean test(T t);
default Predicate and(Predicate<? super T> other)
default Predicate or(Predicate<? super T> other)
default Predicate negate();
static Predicate isEqual(Object targetRef)
import java.util.function.Predicate;
public class DemoPredicateOr {
public static void main(String[] args) {
boolean isValid = method(
// String.contains()方法,仅当此字符串包含指定的字符值序列时返回true。
s -> s.contains("H"),
s -> s.contains("W")
);
System.out.println("字符串符合要求吗:" + isValid);
}
private static boolean method(Predicate<String> one, Predicate<String> two) {
boolean isValid = one.or(two).test("Hello world");
return isValid;
}
}
//输出true
Function接口
java.util.function.Function<T,R> 接口用来根据一个类型的数据得到另一个类型的数据,前者称为前置条件,后者称为后置条件。
Function 接口中最主要的抽象方法为: R apply(T t) ,根据类型T的参数获取类型R的结果。 使用的场景例如:将 String 类型转换为 Integer 类型。
import java.util.function.Function;
public class DemoFunctionApply {
public static void main(String[] args) {
method(s -> Integer.parseInt(s));
}
private static void method(Function<String, Integer> function) {
int num = function.apply("10");
System.out.println(num + 20);
}
}
Function 接口中有一个默认的 andThen 方法,用来进行组合操作。该方法同样用于“先做什么,再做什么”的场景,和 Consumer 中的 andThen 差不多。