Lambda表达式
需求分析
public static void main(String[] args) {
// 开启一个新的线程
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("新线程中执行的代码 :" + Thread.currentThread().getName());
}
}).start();
System.out.println("主线程中的代码：" + Thread.currentThread().getName());
}
代码分析
- Thread类需要一个Runnable接口作为参数，其中的抽象方法run方法是用来指定线程任务内容的核心
- 为了指定run方法体，不得不需要Runnable的实现类
- 为了省去定义一个Runnable 的实现类，不得不使用匿名内部类
- 必须覆盖重写抽象的run方法，所有的方法名称，方法参数，方法返回值不得不都重写一遍，而且不能出错
- 而实际上，我们只在乎方法体中的代码
改写成lambda
new Thread(() - >{
System.out.println("新线程Lambda表达式..." + Thread.currentThread().getName());
}).start();
lambda语法规则
(参数类型 参数名称) - >{
代码体;
}
- (参数类型 参数名称):参数列表
- {代码体;} :方法体
- -> : 箭头，分割参数列表和方法体
@FunctionalInterface注解
- 这是一个标志注解，被该注解修饰的接口只能声明一个抽象方法
Lambda表达式的原理
- 匿名内部类在编译的时候会产生一个class文件。
- Lambda表达式在程序运行的时候会形成一个类。
- 在类中新增了一个方法，这个方法的方法体就是Lambda表达式中的代码
- 还会形成一个匿名内部类，实现接口，重写抽象方法
- 在接口中重写方法会调用新生成的方法
Lambda表达式的省略写法
- 小括号内的参数类型可以省略
- 如果小括号内有且仅有一个参数，则小括号可以省略
- 如果大括号内有且仅有一个语句，可以同时省略大括号，return 关键字及语句分号。
Lambda表达式的使用前提
- 方法的参数或局部变量类型必须为接口才能使用Lambda
- 接口中有且仅有一个抽象方法(@FunctionalInterface)
Lambda和匿名内部类的对比
- 所需类型不一样
- 匿名内部类的类型可以是 类，抽象类，接口
- Lambda表达式需要的类型必须是接口
- 抽象方法的数量不一样
- 匿名内部类所需的接口中的抽象方法的数量是随意的
- Lambda表达式所需的接口中只能有一个抽象方法
- 实现原理不一样
- 匿名内部类是在编译后形成一个class
- Lambda表达式是在程序运行的时候动态生成class
函数式接口
Supplier
- 无参有返回值的接口，对于的Lambda表达式需要提供一个返回数据的类型。
@FunctionalInterface
public interface Supplier<T> {
/**
* Gets a result.
*
* @return a result
*/
T get();
}
/**
* Supplier 函数式接口的使用
*/
public class SupplierTest {
public static void main(String[] args) {
fun1(()->{
int arr[] = {22,33,55,66,44,99,10};
// 计算出数组中的最大值
Arrays.sort(arr);
return arr[arr.length-1];
}
);
}
private static void fun1(Supplier<Integer> supplier){
// get() 是一个无参的有返回值的 抽象方法
Integer max = supplier.get();
System.out.println("max = " + max);
}
}
Consumer
- 有参无返回值得接口,前面介绍的Supplier接口是用来生产数据的，而Consumer接口是用来消费数据的，使用的时候需要指定一个泛型来定义参数类型
@FunctionalInterface
public interface Consumer<T> {
/**
* Performs this operation on the given argument.
*
* @param t the input argument
*/
void accept(T t);
}
public class ConsumerTest {
public static void main(String[] args) {
test(msg -> {
System.out.println(msg + "-> 转换为小写：" + msg.toLowerCase());
}
);
}
public static void test(Consumer<String> consumer){
consumer.accept("Hello World");
}
}
- 默认方法:andThen
- 如果一个方法的参数和返回值全部是Consumer类型，那么就可以实现效果，消费一个数据的时候，首先做一个操作，然后再做一个操作，实现组合，而这个方法就是Consumer接口中的default方法andThen方法
default Consumer<T> andThen(Consumer<? super T> after) {
Objects.requireNonNull(after);
return (T t) -> {
accept(t);
after.accept(t);
}
;
}
public class ConsumerAndThenTest {
public static void main(String[] args) {
test2(msg1->{
System.out.println(msg1 + "-> 转换为小写：" + msg1.toLowerCase());
}
,msg2->{
System.out.println(msg2 + "-> 转换为大写：" + msg2.toUpperCase());
}
);
}
public static void test2(Consumer<String> c1,Consumer<String> c2){
String str = "Hello World";
//c1.accept(str); // 转小写
//c2.accept(str); // 转大写
//c1.andThen(c2).accept(str);
c2.andThen(c1).accept(str);
}
}
Function
- 有参有返回值的接口，Function接口是根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件。有参数有返回值。
@FunctionalInterface
public interface Function<T, R> {
/**
* Applies this function to the given argument.
*
* @param t the function argument
* @return the function result
*/
R apply(T t);
}
public class FunctionTest {
public static void main(String[] args) {
test(msg ->{
return Integer.parseint(msg);
}
);
}
public static void test(Function<String,Integer> function){
Integer apply = function.apply("666");
System.out.println("apply = " + apply);
}
}
- 默认方法：andThen，也是用来进行组合操作，
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
public class FunctionAndThenTest {
public static void main(String[] args) {
test(msg ->{
return Integer.parseint(msg);
}
,msg2->{
return msg2 * 10;
}
);
}
public static void test(Function<String,Integer>
f1,Function<Integer,Integer> f2){
/*Integer i1 = f1.apply("666");
Integer i2 = f2.apply(i1);*/
Integer i2 = f1.andThen(f2).apply("666");
System.out.println("i2:" + i2);
}
}
Predicate
- 有参且返回值为Boolean的接口
@FunctionalInterface
public interface Predicate<T> {
/**
* Evaluates this predicate on the given argument.
*
* @param t the input argument
* @return {@code true} if the input argument matches the predicate,
* otherwise {@code false}
*/
Boolean test(T t);
}
public class PredicateTest {
public static void main(String[] args) {
test(msg -> {
return msg.length() > 3;
}
,"HelloWorld");
}
private static void test(Predicate<String> predicate,String msg){
Boolean b = predicate.test(msg);
System.out.println("b:" + b);
}
}
- 在Predicate中的默认方法提供了逻辑关系操作 and or negate isEquals方法
package com.bobo.jdk.fun;
import java.util.function.Predicate;
public class PredicateDefaultTest {
public static void main(String[] args) {
test(msg1 -> {
return msg1.contains("H");
}
,msg2 -> {
return msg2.contains("W");
}
);
}
private static void test(Predicate<String> p1,Predicate<String> p2){
/*boolean b1 = predicate.test(msg);
boolean b2 = predicate.test("Hello");*/
// b1 包含H b2 包含W
// p1 包含H 同时 p2 包含W
Boolean bb1 = p1.and(p2).test("Hello");
// p1 包含H 或者 p2 包含W
Boolean bb2 = p1.or(p2).test("Hello");
// p1 不包含H
Boolean bb3 = p1.negate().test("Hello");
System.out.println(bb1);
// FALSE
System.out.println(bb2);
// TRUE
System.out.println(bb3);
// FALSE
}
}
方法引用
为什么要用方法引用
- 在使用Lambda表达式的时候，也会出现代码冗余的情况，比如：用Lambda表达式求一个数组的和
package com.bobo.jdk.funref;
import java.util.function.Consumer;
public class FunctionRefTest01 {
public static void main(String[] args) {
printMax(a->{
// Lambda表达式中的代码和 getTotal中的代码冗余了
int sum = 0;
for (int i : a) {
sum += i;
}
System.out.println("数组之和：" + sum);
}
);
}
/**
* 求数组中的所有元素的和
* @param a
*/
public void getTotal(int a[]){
int sum = 0;
for (int i : a) {
sum += i;
}
System.out.println("数组之和：" + sum);
}
private static void printMax(Consumer<int[]> consumer){
int[] a= {10,20,30,40,50,60};
consumer.accept(a);
}
}
- 因为在Lambda表达式中要执行的代码和我们另一个方法中的代码是一样的，这时就没有必要重写一份逻辑了，这时我们就可以“引用”重复代码
package com.bobo.jdk.funref;
import java.util.function.Consumer;
public class FunctionRefTest02 {
public static void main(String[] args) {
// :: 方法引用 也是JDK8中的新的语法
printMax(FunctionRefTest02::getTotal);
}
/**
* 求数组中的所有元素的和
* @param a
*/
public static void getTotal(int a[]){
int sum = 0;
for (int i : a) {
sum += i;
}
System.out.println("数组之和：" + sum);
}
private static void printMax(Consumer<int[]> consumer){
int[] a= {10,20,30,40,50,60};
consumer.accept(a);
}
}
方法引用的格式
- 应用场景：如果Lambda表达式所要实现的方案，已经有其他方法存在相同的方案，那么则可以使用方法引用。
- 常见的引用方式：
- instanceName::methodName 对象::方法名
- ClassName::staticMethodName 类名::静态方法
- ClassName::methodName 类名::普通方法
- ClassName::new 类名::new 调用的构造器
- TypeName[]::new String[]::new 调用数组的构造器
对象名::方法名
- 这是最常见的一种用法。如果一个类中的已经存在了一个成员方法，则可以通过对象名引用成员方法
public static void main(String[] args) {
Date now = new Date();
Supplier<long> supplier = ()->{
return now.getTime();
}
;
System.out.println(supplier.get());
// 然后我们通过 方法引用 的方式来处理
Supplier<long> supplier1 = now::getTime;
System.out.println(supplier1.get());
}
- 方法引用的注意事项：
- 被引用的方法，参数要和接口中的抽象方法的参数一样
- 当接口抽象方法有返回值时，被引用的方法也必须有返回值
ava面向对象中，类名只能调用静态方法，类名引用实例方法是用前提的，实际上是拿第一个参数作
为方法的调用者
public class FunctionRefTest04 {
public static void main(String[] args) {
Supplier<long> supplier1 = ()->{
return System.currentTimeMillis();
}
;
System.out.println(supplier1.get());
// 通过 方法引用 来实现
Supplier<long> supplier2 = System::currentTimeMillis;
System.out.println(supplier2.get());
}
}
类名::引用实例方法
- Java面向对象中，类名只能调用静态方法，类名引用实例方法是用前提的，实际上是拿第一个参数作为方法的调用者
import java.util.Date;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;
public class FunctionRefTest05 {
public static void main(String[] args) {
Function<String,Integer> function = (s)->{
return s.length();
}
;
System.out.println(function.apply("hello"));
// 通过方法引用来实现
Function<String,Integer> function1 = String::length;
System.out.println(function1.apply("hahahaha"));
BiFunction<String,Integer,String> function2 = String::substring;
String msg = function2.apply("HelloWorld", 3);
System.out.println(msg);
}
}
类名::构造器
- 由于构造器的名称和类名完全一致，所以构造器引用使用 ::new 的格式使用，
public class FunctionRefTest06 {
public static void main(String[] args) {
Supplier<Person> sup = ()->{
return new Person();
}
;
System.out.println(sup.get());
// 然后通过 方法引用来实现
Supplier<Person> sup1 = Person::new;
System.out.println(sup1.get());
BiFunction<String,Integer,Person> function = Person::new;
System.out.println(function.apply("张三",22));
}
}
数组::构造器
public static void main(String[] args) {
Function<Integer,String[]> fun1 = (len)->{
return new String[len];
}
;
String[] a1 = fun1.apply(3);
System.out.println("数组的长度是：" + a1.length);
// 方法引用 的方式来调用数组的构造器
Function<Integer,String[]> fun2 = String[]::new;
String[] a2 = fun2.apply(5);
System.out.println("数组的长度是：" + a2.length);
}
Optional
Optional对象的创建方式
/**
* Optional对象的创建方式
*/
@Test
public void test02(){
// 第一种方式 通过of方法 of方法是不支持null的
Optional<String> op1 = Optional.of("zhangsan");
//Optional<Object> op2 = Optional.of(null);
// 第二种方式通过 ofNullable方法 支持null
Optional<String> op3 = Optional.ofNullable("lisi");
Optional<Object> op4 = Optional.ofNullable(null);
// 第三种方式 通过empty方法直接创建一个空的Optional对象
Optional<Object> op5 = Optional.empty();
}
Optional.png
例子：返回男人对象女神的名字
- 女神类
Godness.png
- 旧方法
Man.png
oldway.png
- 新方法
NewMan.png
newway.png
- stream
steam.png
创建stream三步骤.png
创建途径.png
