lamdba表达式& 函数式接口& stream流 整理
lamdba,函数式接口(函数式编程) 是JDK8 的新特性,
- 在开发中,可以使得代码更加的简洁;
- 消除一定量的嵌套
- 可读性提高(方法名称 fitler ,map .distinct ,count 等)
- 大数据集合处理效率提升
java 的编程思想是一切都是对象,我们在写代码的时候也注重一个方法是有一个对象来完成的;
而函数式编程更加关注的是函数(方法)本身,关注是函数做了什么事情;
1.什么是lamdba表达式
官方释义:
A lambda expression is like a method: it provides a list of formal parameters and a body - an expression or block - expressed in terms of those parameters.
lambda表达式就像一个方法:它提供了一个形式参数列表和一个用这些参数表示的主体(表达式或块)。
lamdba 是JDK8 提供的语法糖,对匿名的内部类写法 进行 简化. 是函数式编程思想的一个体现
1.1 常用写法
格式: (参数列表)->{代码块} 其参数列表或者方法列表是推断出来的
下面就是一般的表达式的写法;
lambda表达式的求值产生函数接口的实例。Lambda表达式求值不会导致表达式正文的执行;相反,这可能在稍后调用函数接口的适当方法时发生。
//没有参数时的表达式 多行代码需要使用{
{}}
() -> {
} // No parameters; result is void 没有参数 没有返回值(或者是返回值是void)
() -> 42 // No parameters, expression body
() -> null // No parameters, expression body
() -> {
return 42; } // No parameters, block body with return
() -> {
System.gc(); } // No parameters, void block body
() -> {
// Complex block body with returns
if (true) return 12;
else {
int result = 15;
for (int i = 1; i < 10; i++)
result *= i;
return result;
}
}
//一个参数的时候 使用()包起来无所谓
(int x) -> x+1 // Single declared-type parameter
(int x) -> {
return x+1; } // Single declared-type parameter
(x) -> x+1 // Single inferred-type parameter
x -> x+1 // Parentheses optional for
// single inferred-type parameter
(String s) -> s.length() // Single declared-type parameter
(Thread t) -> {
t.start(); } // Single declared-type parameter
s -> s.length() // Single inferred-type parameter
t -> {
t.start(); } // Single inferred-type parameter
//要不全部声明参数类型 要不都不声明 声明部分在编译时会报错
(int x, int y) -> x+y // Multiple declared-type parameters
(x, y) -> x+y // Multiple inferred-type parameters
(x, int y) -> x+y // Illegal: can't mix inferred and declared types
(x, final y) -> x+y // Illegal: no modifiers with inferred types
案例一 :
// 会自动推导出类型是Runnable 方法体是run 方法
new Thread(() -> {
System.out.println("start");
}).start();
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("start");
}
}).start();
//可以看到 Runnable 是一个函数式接口
@FunctionalInterface
public interface Runnable {
public abstract void run();
}
1.2.lamdba 表达式的参数
lamdba 表达式的参数要不是声明好类型,要不是推断的类型,但是不能混用(多个参数,声明其中部分类型)
- 声明参数类型:lambda表达式称为显式类型
- 不声明参数类型:lambda表达式称为隐式类型
零参数的lambda表达式是显式类型
参数类型声明的时候注意:
- 要不全部声明参数类型 要不都不声明 声明部分在编译时会报错
- 一个参数的时候 使用()包起来无所谓
1.2 lamdba 表达式的方法体
单个表达式或块。与方法体一样,lambda体描述每当调用发生时将执行的代码;
//void 类型返回
() -> {
}
() -> {
System.out.println("done"); }
// 有返回值
() -> {
return "done"; }
() -> {
if (...) return 1; else return 0; }
lambda表达式中使用但未声明的任何局部变量、形式参数或异常参数必须声明为final或有效final,否则在尝试使用时发生编译时错误;
注: 什么是有效final ? 也叫efftive final ; 他没有final 显示的修饰,并且后面不会对它二次赋值(官方文档的描述是是不在赋值预算符的左侧,或者是递增递减的前缀和后缀[++ – ]); 并且已经初始化
1.3 lamdba 表达式的数据类型
如果 T 是一个函数接口类型;,并且该表达式与从 T 派生的地面目标类型的函数类型一致,则 lambda 表达式在赋值上下文、调用上下文或强制转换上下文中与目标类型 T 兼容。
目标类型由 T 推导如下:
如果 T 是通配符参数化的函数接口类型,并且 lambda 表达式是显式类型的,那么将按照描类型描述述断目标类型。
如果 T 是一个通配符参数化的函数接口类型,而 lambda 表达式是隐式类型的,那么 ground 目标类型是 t 的非通配符参量化;
2.函数式接口
函数式接口:任何接口,如果只包含唯一一个抽象方法(除了 Object 的 public 方法之外) ,那么它就是一个函数式接口。
2.1 案例判断
//是
interface Runnable {
void run();
}
//不是
interface NonFunc {
boolean equals(Object obj); //Object 方法
}
//是的
interface Func extends NonFunc {
int compare(String o1, String o2); //唯一的 非object 的一个抽象方法
}
//所以类似 java.util.Comparator<T> 是一个函数式接口
interface Comparator<T> {
boolean equals(Object obj); // Object 方法
int compare(T o1, T o2);
}
//两个接口 clone 是Object 的非 public 的
interface Foo {
int m();
Object clone();
}
如果有两个方法(FI5 ) ,
- m 的签名是 M 中每个方法签名的子签名
- m 方法返回值是可以替代类型 如 FI2.m 的方法返回值签名Iterable 可以替代 FI3.m() 的 Iterable
@FunctionalInterface
public interface FI2 {
Iterable m(Iterable<String> arg);
}
@FunctionalInterface
public interface FI3 {
Iterable<String> m(Iterable arg);
}
@FunctionalInterface // 也是一个函数式接口
interface FI5 extends FI2, FI3 {
/ /这个也是 FI2.m 的方法签名可以替代 Iterable<String>
}
注意:@FunctionalInterface 作用,用于编译器校验你的接口是不是函数式接口
2.2 实例化
对于函数式接口:
-
通过声明和实例化类(15.9)来创建接口实例的常规过程
-
还可以使用方法引用表达式和 lambda 表达式来创建函数接口实例。
public static void main(String[] args) {
//常规过程
FI fi = new FIDemo();
fi.fun1();
// lambda 表达式
fi = ()-> System.out.println("FIDemo2");
fi.fun1();
}
static class FIDemo implements FI{
@Override
public void fun1() {
System.out.println("FIDemo1");
}
}
public interface FI {
void fun1();
}
2.3 常用的函数式接口
java.util.function 包下面的四大种类
//供给型 生产型 没有参数 有输出的
Supplier<Integer> sup = () -> {
return 100;
};
//消费型 有输入 没有输出的 消费型(消费输入)
Consumer<String> consumer = (x) -> {
System.out.println(" return void" + x);
};
//有输入也有输出的 函数型接口 (第一个泛型是输入,第二个泛型是输出) 计算转换类型
Function<String, Integer> function = (x)-> x.length();
//判断型接口
Predicate<String> predicate = (x)->{
boolean b = x.length() > 5;
return b;
};
3.Stream流
JDK8 的Stream 使用函数式编程模式,可以使我们对集合的操作就像对流一样链式操作;简化和方便对 集合的操作;
流的操作可以氛围三大部分
- 获取流,
- 流中间操作
- 输出流中数据 也就是终结流
3.1 Stream流的创建/获取
//链表获取流
List<User> users = getUsers();
Stream<User> stream = users.stream();
//数组获取流
Integer[] arr = {
1,3,5,7,9};
Stream<Integer> stream1 = Arrays.stream(arr);
//map 可以转entryset 转流
3.2 中间操作
中间的操作是对流中数据操作,方法返回的还是Stream 意味着后面还是可以接着中间操作的函数
数据准备
public static List<User> getUsers() {
List<User> users = new ArrayList<>();
users.add(new User(1, "孙菲菲", 4, "杨浦区"));
users.add(new User(1, "孙菲菲", 4, "杨浦区"));
users.add(new User(2, "熊大", 5, "青青草原"));
users.add(new User(3, "熊二", 10, "青青草原"));
return users;
}
1.filter
数据过滤
Stream<T> filter(Predicate<? super T> predicate);
public static void filter() {
List<User> users = getUsers();
users.stream()
.filter(x -> x.getId() > 1) //中间是匿名函数 Predicate(结合2.3) 的实现 是一个判断条件
.forEach(x -> System.out.println(x));
}
//输出
User(id=2, name=熊大, age=5, address=青青草原)
User(id=3, name=熊二, age=10, address=青青草原)
2.map
数据转换
<R> Stream<R> map(Function<? super T, ? extends R> mapper);
public static void map() {
List<User> users = getUsers();
users.stream()
.map(x -> {
return "银河系,地球村 :" + x.getAddress();
}) //中间是匿名函数 Function(结合2.3) 的实现 y有输入和输出, 输入是User 对象 输出是 String
.forEach(x -> System.out.println(x));
}
//输出
银河系,地球村 :杨浦区
银河系,地球村 :杨浦区
银河系,地球村 :青青草原
银河系,地球村 :青青草原
3.distinct
数据去重
Stream<T> distinct();
public static void distinct() {
List<User> users = getUsers();
users.stream()
.distinct() //依赖于Object 的equals 方法来实现
.forEach(x -> System.out.println(x));
}
4.sorted
排序
Stream<T> sorted();
Stream<T> sorted(Comparator<? super T> comparator);
public static void sorted() {
List<User> users = getUsers();
users.stream()
.sorted()
.forEach(x -> System.out.println(x));
}
//报错
Exception in thread "main" java.lang.ClassCastException: com.common.util.User cannot be cast to java.lang.Comparable
两个方法
方法1:User 实现 Comparable 接口
方法2:sorted(Comparator<? super T> comparator) 使用带参数的
方法二实现
public static void sorted() {
List<User> users = getUsers();
users.stream()
.sorted(Comparator.comparingInt(User::getAge)) //sorted() 使用带参数的
.forEach(x -> System.out.println(x));
}
5.limit
截取前面几条数据
Stream<T> limit(long maxSize);
public static void limit() {
List<User> users = getUsers();
users.stream()
.limit(3)
.forEach(x -> System.out.println(x));
}
//输出
User(id=1, name=孙菲菲, age=4, address=杨浦区)
User(id=1, name=孙菲菲, age=4, address=杨浦区)
User(id=2, name=熊大, age=5, address=青青草原)
6.skip
跳过前面几条数据
Stream<T> skip(long n);
public static void skip() {
List<User> users = getUsers();
users.stream()
.skip(2)
.forEach(x -> System.out.println(x));
}
User(id=2, name=熊大, age=5, address=青青草原)
User(id=3, name=熊二, age=10, address=青青草原)
7.flatMap
map 对象是一对一转出 , flatMap 可以一对多转出对象
<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)
public static void flatMap() {
List<User> users = getUsers();
users.stream()
.flatMap((Function<User, Stream<?>>) user -> Arrays.asList(user.getId(), user.getAddress()).stream()) //flatMap 内是一个Function ,Function 的输出是一个 子流(可以这样理解,每个元素拆分的流)
.forEach(x -> System.out.println(x));
}
//输出
1
杨浦区
1
杨浦区
2
青青草原
3
青青草原
3.3 流的终结操作
1.foreach
遍历流中的数据
public static void foreach() {
List<User> users = getUsers();
users.stream()
.forEach(x -> System.out.println(x));
}
//输出
User(id=1, name=孙菲菲, age=4, address=杨浦区)
User(id=1, name=孙菲菲, age=4, address=杨浦区)
User(id=2, name=熊大, age=5, address=青青草原)
User(id=3, name=熊二, age=10, address=青青草原)
2.count
计算流中的数据
public static void count() {
List<User> users = getUsers();
long count = users.stream()
.filter(x -> x.getId() > 1)
.count();
System.out.println(count);
}
//输出
2
3.max&min
计算流中最大值,最小值
public static void max() {
List<User> users = getUsers();
Optional<User> max = users.stream()
.filter(x -> x.getId() > 1)
.max(Comparator.comparingInt(User::getAge));//.min(Comparator.comparingInt(User::getAge));
System.out.println(max.get()); //getAge 最大的
}
User(id=3, name=熊二, age=10, address=青青草原)
4.collect
流中的元素转变成集合
public static void collect() {
List<User> users = getUsers();
List<Integer> list = users.stream()
.map(x -> x.getId())
.collect(Collectors.toList());
System.out.println(list);
System.out.println("=========");
Set<Integer> set = users.stream()
.map(x -> x.getId())
.collect(Collectors.toSet());
System.out.println(set);
System.out.println("=========");
Map<String, User> nameToUser = users.stream()
.collect(Collectors.toMap(User::getName, Function.identity()));
System.out.println(nameToUser);
System.out.println("=========");
//这里会报错 Exception in thread "main" java.lang.IllegalStateException: Duplicate key User(id=1, name=孙菲菲, age=4, address=杨浦区)
//需要先去重 或者下面方法 重复使用哪一个
//(x, x1) -> x 使用前一个
//(x, x1) -> x1 使用后一个
Map<String, User> nameToUser = users.stream()
.collect(Collectors.toMap(User::getName, Function.identity(), (x, x1) -> x1));
System.out.println(nameToUser);
System.out.println("=========");
Map<String, List<User>> nameToUserList = users.stream()
.collect(Collectors.groupingBy(User::getName));
System.out.println(nameToUserList);
System.out.println("=========");
}
5.查询匹配
- anyMatch:是否有任意一个满足
- allMatch:是否所有元素都满足
- noneMatch: 是否都不满住
public static void matchAndSelect() {
List<User> users = getUsers();
boolean b = users.stream().map(x -> x.getAge()).allMatch(x -> x > 10);
System.out.println("所有age>10:" + b);
b = users.stream().map(x -> x.getAge()).anyMatch(x -> x > 5);
System.out.println("任意age>5:" + b);
b = users.stream().map(x -> x.getAge()).noneMatch(x -> x > 10);
System.out.println("没有一个age > 10:" + b);
}
//元素
users.add(new User(1, "孙菲菲", 4, "杨浦区"));
users.add(new User(1, "孙菲菲", 4, "杨浦区"));
users.add(new User(2, "熊大", 5, "青青草原"));
users.add(new User(3, "熊二", 10, "青青草原"));
所有age>10:false
任意age>5:true
所有都<=10:true
- findAny :或取流中任意一个;(并行流中,任意一个流的第一个,串行流都是一样)
- findFirst:获取流中第一个
public static void select() {
List<User> users = getUsers();
Optional<User> any = users.stream().findAny();
System.out.println(any);
Optional<User> first = users.stream().findFirst();
System.out.println(first);
}
//输出
Optional[User(id=1, name=孙菲菲, age=4, address=杨浦区)]
Optional[User(id=1, name=孙菲菲, age=4, address=杨浦区)]
6.reduce
对流中数据进行指定计算方式运行出结果( 聚合,缩减)
比如说求和
public static void reduce() {
List<User> users = getUsers();
Integer reduce = users.stream()
.map(x -> x.getAge())
.reduce(0, (integer, integer2) -> integer + integer2);
System.out.println(reduce);
}
3.4 并行流
大量数据的时候,可以使用并行流处理数据.
并行流的底层是把任务分配给多个线程(ForkJoinn Pool 线程池)去执行.
public static void parallelStream() {
List<User> users = getUsers();
Integer reduce = users.parallelStream()
.peek(x->{
System.out.println(Thread.currentThread().getName());
})
.map(x -> x.getAge())
.reduce(0, (integer, integer2) -> integer + integer2);
System.out.println(reduce);
}
//输出
ForkJoinPool.commonPool-worker-9
ForkJoinPool.commonPool-worker-2
ForkJoinPool.commonPool-worker-11
main
23
3.5 注意
- 流是一次性的 使用过(被终结操作终结过的 就不能在使用了)
- 流的操作一般不会影响原来数据地址(集合元素的地址)