一、概述
Lambda表达式是Java8中的新特性，编码时，我们一般尽可能轻量级的将代码封装为数据，传统的解决方案是通过接口和实现类（匿名内部类）实现，这中方式存在语法冗余，this关键字，变量捕捉，数据控制等问题
例如线程的创建：
通过lambda表达式实现:
二、基础语法
1、函数式接口（function interface）
简单来说就是只包含一个接口方法的特殊接口，通过@FunctionalInterface注解标注
注意：1、函数式接口中默认接口和静态接口可以正常使用
2、由于Java中所有的类都默认继承自Object类，所以继承自Object类中的接口也可以在函数式接口中使用
2、Lambda表达式实现函数式接口
定义一个接口
实现类：
3、Java类型系统内部的函数式接口
Java8中的java.util.function包中提供了一些常用的函数式功能接口
// java.util.function.Predicate<T>
// 接收参数T，返回一个Boolean类型的结果
Predicate<String> predicate = String::isEmpty;
// java.util.function.Consumer<T>
// 接收一个参数T，不返回结果
Consumer<String> consumer = System.out::println;
// java.util.function.Function<T，R>
// 接收参数对象T，返回结果对象R
Function<String, Integer> function = (String userName) ->{
return userName.equals("admin") ? 1 : 0;
};
// java.util.function.Supplier<T>
// 不接收参数，返回T对象创建的工厂
Supplier<String> supplier = () -> UUID.randomUUID().toString();
// java.util.UnaryOperator<T>
// 接收参数对象T，返回结果参数对象T
UnaryOperator<String> operator = (String userName) -> "Hello " + userName;
//java.util.BinaryOperator<T>
// 接收两个T对象，返回一个T对象结果
BinaryOperator<String> binary = (String userName, String userId) -> {
return userName + ":" + userId;
};
注： 1、lambda表达式 必须和接口进行绑定
2、lambda表达式，可以附带0到n个参数，括号中的参数类型可以不用指定，jvm在运行时，会自动根据绑定的抽象方法中的参数进行推导
3、lambda表达式，如果代码块只有一行，可以省略大括号，和return关键字，单行代码的执行结果会自动返回
4、Lambda表达式的类型检查
public static void main(String[] args) {
test((n, r) -> {
r.add(n);
return r;
});
}
public static void test(IInterface<String, List> iInterface) {
iInterface.compar("admin", new ArrayList());
}
@FunctionalInterface
public interface IInterface<T, R> {
R compar(T t, R r);
}
三、Lambda表达式在集合中的应用
1、方法的调用
List<Integer> list = Arrays.asList(33,44,55,33,22);
// 1、匿名内部类的方式
Collections.sort(list, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1 - o2;
}
});
// 2、lambda 表达式的方式
Collections.sort(list, (p1, p2) -> p1 - p2);
// 3、静态方法的引用
Collections.sort(list, LambdbTest::compar);
public static int compar(Integer p1, Integer p2) {
return p1-p2;
}2、获取stream对象// 1、批量数据，stream对象
Stream stream = Stream.of("admin", "ossuser");
// 2、数组
int[] array = new int[]{1,3,4};
IntStream stream1 = Arrays.stream(array);
// 2、集合
List<String> list = Arrays.asList("admin", "ossuser");
Stream<String> stream2 = list.stream();
// 3、Map
Map<String, String> map = new HashMap<>();
map.put("name", "admin");
Stream<Map.Entry<String, String>> stream3 = map.entrySet().stream();
// 3、stream对基类型类型的功能封装
IntStream intStream = IntStream.of(3);
IntStream.range(1, 5).forEach(System.out::println); // 左闭右开
IntStream.rangeClosed(1, 5).forEach(System.out::println); // 左闭又闭3、Stream对象，转为指定数据 // 1、数组
Object[] ints = stream.toArray(String[]::new);
// 2、字符串
String collect1 = stream.collect(Collectors.joining()).toString();
// 3、集合
List<String> list1 = (List<String>) stream.collect(Collectors.toList());
// 4、map
Map<String, String> map1 = (Map<String, String>) stream.collect(Collectors.toMap(x -> x, y -> "value" + y));3、常见API的操作List<String> list2 = Arrays.asList("admin", "user", "ossuser");
// 1、map() 中间操作，map()方法接收一个Function接口
List<String> strings = list2.stream().map(x -> x + "test").collect(Collectors.toList());
// 2、filter() 添加过滤条件，过滤满足条件的用户
List<String> collect = list2.stream().filter(x -> x.length() > 2).collect(Collectors.toList());
// 3、forEach 增强型循环
list2.forEach(System.out::print);
// 4、peek() 中间操作，迭代数据依次处理过程，实现数据的多次迭代
list2.stream()
.peek(x -> System.out.println(x + "1"))
.peek(x -> System.out.println(x + "2"))
.forEach(System.out::println);
// 5、skip() 中间操作，有状态，跳过部分数据
list2.stream().skip(1).forEach(System.out::println);
// 6、limit() 中间操作，有状态，限制输出数据量
list2.stream().limit(2).forEach(System.out::println);
// 7、distinct() 中间操作，有状态，去重
list2.stream().distinct().forEach(System.out::println);
- 概述
Lambda表达式是Java8中的新特性，编码是，一般尽可能轻量级的将代码封装为数据，传统的解决方案是通过接口和实现类（匿名内部类）实现，这中方式存在语法冗余，this关键字，变量捕捉，数据控制等问题
Lambda表达式，是对这块代码的一个优化
例如线程的创建：
通过lambda表达式实现:
- 基础语法
- 函数式接口（function interface）
简单来说就是只包含一个接口方法的特殊接口，通过@FunctionalInterface注解标注
注意：1、函数式接口中默认接口和静态接口可以正常使用
2、由于Java中所有的类都默认继承自Object类，所以继承自Object类中的接口也可以在函数式接口中使用
- Lambda表达式实现函数式接口
定义一个接口
实现类：
- Java类型系统内部的函数式接口
Java8中的java.util.function包中提供了一些常用的函数式功能接口 // java.util.function.Predicate<T>
// 接收参数T，返回一个Boolean类型的结果
Predicate<String> predicate = String::isEmpty;
// java.util.function.Consumer<T>
// 接收一个参数T，不返回结果
Consumer<String> consumer = System.out::println;
// java.util.function.Function<T，R>
// 接收参数对象T，返回结果对象R
Function<String, Integer> function = (String userName) ->{
return userName.equals("admin") ? 1 : 0;
};
// java.util.function.Supplier<T>
// 不接收参数，返回T对象创建的工厂
Supplier<String> supplier = () -> UUID.randomUUID().toString();
// java.util.UnaryOperator<T>
// 接收参数对象T，返回结果参数对象T
UnaryOperator<String> operator = (String userName) -> "Hello " + userName;
//java.util.BinaryOperator<T>
// 接收两个T对象，返回一个T对象结果
BinaryOperator<String> binary = (String userName, String userId) -> {
return userName + ":" + userId;
}; 注：1、lambda表达式 必须和接口进行绑定 2、lambda表达式，可以附带0到n个参数，括号中的参数类型可以不用指定，jvm在运行时，会自动根据绑定的抽象方法中的参数进行推导 3、lambda表达式，如果代码块只有一行，可以省略大括号，和return关键字，单行代码的执行结果会自动返回
- Lambda表达式的类型检查
public static void main(String[] args) {
test((n, r) -> {
r.add(n);
return r;
});
}
public static void test(IInterface<String, List> iInterface) {
iInterface.compar("admin", new ArrayList());
}
@FunctionalInterface
public interface IInterface<T, R> {
R compar(T t, R r);
}
- Lambda表达式在集合中的应用
1、方法的调用
List<Integer> list = Arrays.asList(33,44,55,33,22);
// 1、匿名内部类的方式
Collections.sort(list, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1 - o2;
}
});
// 2、lambda 表达式的方式
Collections.sort(list, (p1, p2) -> p1 - p2); // 3、静态方法的引用
Collections.sort(list, LambdbTest::compar);
public static int compar(Integer p1, Integer p2) {
return p1-p2;
}2、获取stream对象// 1、批量数据，stream对象
Stream stream = Stream.of("admin", "ossuser");
// 2、数组
int[] array = new int[]{1,3,4};
IntStream stream1 = Arrays.stream(array);
// 2、集合
List<String> list = Arrays.asList("admin", "ossuser");
Stream<String> stream2 = list.stream();
// 3、Map
Map<String, String> map = new HashMap<>();
map.put("name", "admin");
Stream<Map.Entry<String, String>> stream3 = map.entrySet().stream();
// 3、stream对基类型类型的功能封装
IntStream intStream = IntStream.of(3);
IntStream.range(1, 5).forEach(System.out::println); // 左闭右开
IntStream.rangeClosed(1, 5).forEach(System.out::println); // 左闭又闭3、Stream对象，转为指定数据 // 1、数组
Object[] ints = stream.toArray(String[]::new);
// 2、字符串
String collect1 = stream.collect(Collectors.joining()).toString();
// 3、集合
List<String> list1 = (List<String>) stream.collect(Collectors.toList());
// 4、map
Map<String, String> map1 = (Map<String, String>) stream.collect(Collectors.toMap(x -> x, y -> "value" + y));3、常见API的操作List<String> list2 = Arrays.asList("admin", "user", "ossuser");
// 1、map() 中间操作，map()方法接收一个Function接口
List<String> strings = list2.stream().map(x -> x + "test").collect(Collectors.toList());
// 2、filter() 添加过滤条件，过滤满足条件的用户
List<String> collect = list2.stream().filter(x -> x.length() > 2).collect(Collectors.toList());
// 3、forEach 增强型循环
list2.forEach(System.out::print);
// 4、peek() 中间操作，迭代数据依次处理过程，实现数据的多次迭代
list2.stream()
.peek(x -> System.out.println(x + "1"))
.peek(x -> System.out.println(x + "2"))
.forEach(System.out::println);
// 5、skip() 中间操作，有状态，跳过部分数据
list2.stream().skip(1).forEach(System.out::println);
// 6、limit() 中间操作，有状态，限制输出数据量
list2.stream().limit(2).forEach(System.out::println);
// 7、distinct() 中间操作，有状态，去重
list2.stream().distinct().forEach(System.out::println);
- 概述
Lambda表达式是Java8中的新特性，编码是，一般尽可能轻量级的将代码封装为数据，传统的解决方案是通过接口和实现类（匿名内部类）实现，这中方式存在语法冗余，this关键字，变量捕捉，数据控制等问题
Lambda表达式，是对这块代码的一个优化
例如线程的创建：
通过lambda表达式实现:
