目录
Lambda表达式
()->{}
lambda的jdk8的新特性，可以取代大部分匿名内部类，优化代码
所有的Lambda的类型都是一个接口，也就是这个接口的实现，
Lambda表达式本身就是接口的实现
函数式接口：接口中只有一个接口函数需要被实现的接口类型
接口要求： Lambda 规定接 接口中只能有一个需要被实现的方法，不是规定接口中只能有一个方法。 jdk 8 中有另一个新特性： default ， 被 default 修饰的方法会有默认实现，不是必须被实现的方法，所以不影响 Lambda 表达式的使用。@FunctionalInterface标记在接口上，指明这是一个函数式接口
Lamabda表达式语法
（）->{}
() 用来描述参数列表，如果有多个参数，参数之间用逗号隔开，如果没有参数，留空即可； -> 读作 (goes to) ，为 lambda 运算符 ，固定写法，代表指向动作； {} 代码块，具体要做的事情，也就是方法体内容；语法重要特征
可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。 可选的参数圆括号： 一个参数 无需定义圆括号，但多个参数需要定义圆括号。 可选的大括号：如果主体包含了一个语句，就不需要使用大括号。 可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表 达式返回了一个数值。代码示例
//无参数无返回值接口
@FunctionalInterface
interface NoParamNoReturn{
void method();
}
//一个参数，无返回值接口
@FunctionalInterface
interface OneParamNoReturn{
void method(int a);
}
//两个/多个参数无返回值接口
@FunctionalInterface
interface ManyParamNoReturn{
void method(int a,int b);
}
//有返回值无参数接口
@FunctionalInterface
interface NoParamHaveReturn{
int method();
}
//一个参数有返回值接口
@FunctionalInterface
interface OneParamHaveReturn{
int method(int a);
}
//多个参数有返回值接口
@FunctionalInterface
interface ManyParamHaveReturn{
int method(int a,int b);
}
public class Test03 {
public static void main(String[] args) {
//无参数无返回值接口
NoParamNoReturn noParamNoReturn = ()->{
System.out.println("没有参数也没有返回值");
};
noParamNoReturn.method();
//一个参数，无返回值接口
OneParamNoReturn oneParamNoReturn = (int a) -> {
System.out.println("一个参数，没有返回值接口"+a*10);
};
oneParamNoReturn.method(2);
//两个/多个参数无返回值接口
ManyParamNoReturn manyParamNoReturn =(int a,int b)->{
System.out.println("//两个/多个参数无返回值接口:"+(a+b));
};
manyParamNoReturn.method(45,23);
//有返回值无参数接口
NoParamHaveReturn noParamHaveReturn = ()->{
System.out.println("有返回值无参数接口");
return 100;
};
int value = noParamHaveReturn.method();
System.out.println(value);
//一个参数有返回值接口
OneParamHaveReturn oneParamHaveReturn =(int a )->{
System.out.println("一个参数有返回值接口");
return a*20;
};
System.out.println(oneParamHaveReturn.method(33));
//多个参数有返回值接口
ManyParamHaveReturn manyParamHaveReturn =(int a,int b)->{
System.out.println("多个参数有返回值接口");
return a+b;
};
System.out.println(manyParamHaveReturn.method(20,78));
}
}代码简写：
//无参数无返回值接口
// NoParamNoReturn noParamNoReturn = ()->{
// System.out.println("没有参数也没有返回值");
// };
NoParamNoReturn noParamNoReturn=()->System.out.println("没有参数也没有返回值");
noParamNoReturn.method();
System.out.println("-----------------------------------------------");
//一个参数，无返回值接口
// OneParamNoReturn oneParamNoReturn = (int a) -> {
// System.out.println("一个参数，没有返回值接口"+a*10);
// };
OneParamNoReturn oneParamNoReturn =a -> System.out.println("一个参数，没有返回值接口"+a*10);
oneParamNoReturn.method(2);
System.out.println("-------------------------------------------------");
//两个/多个参数无返回值接口
// ManyParamNoReturn manyParamNoReturn =(int a,int b)->{
// System.out.println("//两个/多个参数无返回值接口:"+(a+b));
// };
ManyParamNoReturn manyParamNoReturn = (a,b)->System.out.println("//两个/多个参数无返回值接口:"+(a+b));
manyParamNoReturn.method(45,23);
System.out.println("-----------------------------");
//有返回值无参数接口
// NoParamHaveReturn noParamHaveReturn = ()->{
// System.out.println("有返回值无参数接口");
// return 100;
// };
NoParamHaveReturn noParamHaveReturn =()->100;
int value = noParamHaveReturn.method();
System.out.println(value);
//一个参数有返回值接口
// OneParamHaveReturn oneParamHaveReturn =(int a )->{
// System.out.println("一个参数有返回值接口");
// return a*20;
// };
OneParamHaveReturn oneParamHaveReturn =a->{
System.out.println("一个参数有返回值接口");
return a*20;
};
System.out.println(oneParamHaveReturn.method(33));
//多个参数有返回值接口
// ManyParamHaveReturn manyParamHaveReturn =(int a,int b)->{
// System.out.println("多个参数有返回值接口");
// return a+b;
// };
ManyParamHaveReturn manyParamHaveReturn=(a,b)->a+b;
System.out.println(manyParamHaveReturn.method(20,78));Lambda表达式引用方法
使用 lambda表达式指向一个已经存在的方法作为抽象方法的实现。
要求：
1.参数的个数以及类型需要与函数接口中的抽象方法一致。 2.返回值类型要与函数接口中的抽象方法的返回值类型一致。 语法： 方法归属者 :: 方法名 静态方法的归属者为类名， 非静态方法归属者为该对象的引用。 以上面代码里面的接口，完成的示例代码public class Test04 {
public static void main(String[] args) {
//无参数无返回值
NoParamNoReturn noParamNoReturn=Test04::show;
noParamNoReturn.method();
//有参数无返回值
OneParamNoReturn oneParamNoReturn = Test04::show;
oneParamNoReturn.method(99);
//有参数有返回值
Test04 test04 = new Test04();
OneParamHaveReturn oneParamHaveReturn =test04::get;
int value = oneParamHaveReturn.method(66);
System.out.println(value);
}
//静态方法
public static void show(){
System.out.println("lambda表达式引用方法");
}
//静态方法
public static void show(int a){
System.out.println("lambda表达式引用方法"+a);
}
//非静态方法
public int get(int a){
return a*10;
}
}Lambda表达式创建线程
因为Runnable是一个函数式接口
public class Test05 {
public static void main(String[] args) {
Runnable runnable=()->{
for (int i=0;i<=10;i++){
System.out.println("打印"+i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
};
Thread thread = new Thread(runnable);
thread.start();
}
}Lambda表达式中的闭包问题
闭包的本质就是代码片段
java中的匿名内部类也是闭包的一种实现方式
在闭包中访问外部的变量时，外部变量必须是 final 类型，虚拟机会帮我们加上 final 修饰关键字。常用的函数式接口
Consumer接口的使用
调用集合的 public void forEach(Consumer<? super E> action) 方法，通过 lambda 表达式的方式遍历集合中的元素。public class Test01 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("java");
list.add("python");
list.add("c++");
list.add("vue");
// list.forEach((value)->{
// System.out.println(value);
// });
list.forEach(System.out::println);
}
}调用的是Consumer接口中的这个抽象方法void accept(T t)：在给定的参数上执行此操作。
第二种打印方式：是Lambda表达式引用PrintStream类中的方法，但是由于这个print不是静态方法，所以需要PrintStream对象来绑定，这个方法与Consumer接口中的void accept(T t)抽象方法的参数个数，类型以及返回值都一致因此可以引用
public void print(String s)打印一个字符串。如果参数是 null然后串 "null"印刷。否则，该字符串的字符是根据平台的默认字符编码转换成字节，这些字节的方法完全 write(int)
Predicate接口的使用
Predicate 是 JDK 为我们提供的一个函数式接口，可以简化程序的编写。public class Test01 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("java");
list.add("python");
list.add("c++");
list.add("vue");
list.removeIf(ele->ele.equals("java"));
list.forEach(System.out::println);
}
}Comparator接口的使用
Comparator 是 JDK 为我们提供的一个函数式接口，该接口为比较器接口。public class Test01 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("c");
list.add("a");
list.add("d");
list.add("b");
list.sort((o1,o2)->o1.compareTo(o2));
list.forEach(System.out::println);
}
} Stream流
Stream 是数据渠道，用于操作数据源所生成的元素序列，它可以实现对集合的复杂操作，例如过 滤、排序和映射等。Stream 不会改变源对象，而是返回一个新的结果集。Stream流的生成方式
生成流：通过数据源（集合、数组等）创建一个流。 中间操作：一个流后面可以跟随零个或者多个中间操作，其目的主要是打开流，做出某种程度的数 据过滤 / 映射，然后返回一个新的流，交给下一个操作使用。 终结操作：一旦执行终止操作，就执行中间的链式操作，并产生结果。常用方法
数据过滤
import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;
public class Test02 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("javaScript");
list.add("python");
list.add("java");
list.add("mysql");
list.add("scala");
// 数据过滤
// 多条件和的关系
list.stream().filter(ele->ele.startsWith("j")).filter(ele->ele.endsWith("a")).collect(Collectors.toList()).forEach(System.out::println);
// 多条件或的关系
Predicate<String> predicate = ele->ele.startsWith("j");
Predicate<String> predicate1 = ele->ele.endsWith("a");
list.stream().filter(predicate.or(predicate1)).collect(Collectors.toList()).forEach(System.out::println);
}
}数量限制
limit(long maxSize)返回一个包含该流的元素流，截断长度不超过 maxSize。
public class Test03 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("javaScript");
list.add("python");
list.add("java");
list.add("mysql");
list.add("scala");
list.stream().limit(3).forEach(System.out::println);
}
}数据排序
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
public class Test04 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("d");
list.add("e");
list.add("c");
list.add("s");
list.add("a");
// 第一种方式升序
list.stream().sorted().forEach(System.out::print);
System.out.println();
System.out.println("=========================");
// 第二种升序方式
list.stream().sorted(Comparator.naturalOrder()).forEach(System.out::print);
System.out.println();
System.out.println("=======================");
// 降序方式
list.stream().sorted(Comparator.reverseOrder()).forEach(System.out::print);
System.out.println();
System.out.println("=======================");
}
}