Lambda
Lambda 是一个匿名函数,我们可以把Lambda表达式理解为一段可以传递的代码(将代码像数据一样进行传递),可以写出更简洁、更灵活的代码。
Lambda 表达式语法
Lambda 表达式在Java 语言中引入了一个新的语法元素和操作符。这个操作符为 ->
, 该操作符被称为 Lambda 操作符或剪头操作符。它将 Lambda 分为两个部分:
左侧:指定了 Lambda 表达式需要的所有参数
右侧:指定了 Lambda 体,即 Lambda 表达式要执行的功能。
- 语法格式一:无参,无返回值,Lambda 体只需一条语句
Runnable runnable = () -> System.out.println("aa");
- 语法格式二:Lambda 需要一个参数
Consumer<String> consumer = x -> System.out.println(x);
- 语法格式三:Lambda 需要两个参数,并且有返回值
Comparator<Integer> comparator = (x, y) -> {
System.out.println("实现函数接口方法!");
return x + y;
};
Lambda 表达式语法
上述 Lambda 表达式中的参数类型都是由编译器推断得出的。Lambda 表达式中无需指定类型,程序依然可以编译,这是因为 javac 根据程序的上下文,在后台推断出了参数的类型。Lambda 表达式的类型依赖于上下文环境,是由编译器推断出来的。这就是所谓的“类型推断”
方法引用
当要传递给Lambda体的操作,已经有实现的方法了,可以使用方法引用!(实现抽象方法的参数列表,必须与方法引用方法的参数列表保持一致!)方法引用:使用操作符 ::
将方法名和对象或类的名字分隔开来。如下三种主要使用情况:
- 对象::实例方法
- 类::静态方法
- 类::实例方法
Stream流
是数据渠道,用于操作数据源(集合、数组等)所生成的元素序列。集合讲的是数据,流讲的是计算!
注意:
- Stream 自己不会存储元素。
- Stream 不会改变源对象。相反,他们会返回一个持有结果的新Stream。
- Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。
创建Stream流
public static void main(String[] args) {
// 1.可以通过 Collection 系列集合提供 stream()串行流 或 parallelStream()并行流
List<String> list = new ArrayList<>();
Stream<String> stringStream = list.stream();
// 2.通过 Arrays 中的表态方法 stream() 获取数组流
Integer[] integers = new Integer[10];
Stream<Integer> integerStream = Arrays.stream(integers);
// 3.通过 Stream 类中的静态方法 of()
Stream<String> strStream = Stream.of("a", "b", "c");
// 4.创建无限流
// 迭代
Stream<Integer> stream = Stream.iterate(0, (x) -> x + 2);
stream.limit(10).forEach(System.out::println);
//生成
Stream.generate(Math::random)
.limit(5).forEach(System.out::println);
}
中间操作
String[] strings = new String[]{"a", "a", "b", "c", "d", "e", "f"};
//中间操作:不会执行任何操作
Stream<String> stringStream = Arrays.stream(strings)
.filter((e) -> {
System.out.println("中间操作");
return "c".equals(e);
});
//终止操作:一次性执行全部内容,即"惰性求值"
stringStream.forEach(System.out::println);
String[] strings = new String[]{"a", "a", "b", "c", "d", "e", "f"};
//中间操作:不会执行任何操作
Stream<String> stringStream = Arrays.stream(strings)
.filter((e) -> {
System.out.println("中间操作");
return !"c".equals(e);
}).limit(3).distinct();
//终止操作:一次性执行全部内容,即"惰性求值"
stringStream.forEach(System.out::println);
List<String> list = Arrays.asList("a", "b", "c", "d", "e", "f");
list.stream().map(String::toUpperCase)
.forEach(System.out::println);
public static void main(String[] args) {
List<String> list = Arrays.asList("aa", "bb", "cc", "dd", "ee");
list.stream().map(String::toUpperCase)
.forEach(System.out::println);
System.out.println("-----------");
//flatMap里面返回又是一个Stream流
list.stream().flatMap(Test::character)
.forEach(System.out::println);
}
private static Stream<Character> character(String string) {
List<Character> list = new ArrayList<>();
for (char c : string.toCharArray()) {
list.add(c);
}
return list.stream();
}
List<Integer> list = Arrays.asList(8, 4, 6, 2, 5, 1, 7);
list.stream().sorted().forEach(System.out::println);
System.out.println("-----------");
list.stream().sorted((e1, e2) -> {
return -e1.compareTo(e2);
}).forEach(System.out::println);
终止操作
List<Integer> list = Arrays.asList(8, 4, 6, 2, 5, 1, 7);
boolean b = list.stream().allMatch((e) -> {
return e == 5;
});
System.out.println(b);
boolean b1 = list.stream().anyMatch((e) -> {
return e == 5;
});
System.out.println(b1);
boolean b2 = list.stream().noneMatch((e) -> {
return e == 5;
});
System.out.println(b2);
Optional<Integer> first = list.stream().findFirst();
System.out.println(first.get());
// 在串行的流中,findAny和findFirst返回的,都是第一个对象;
// 而在并行的流中,findAny返回的是最快处理完的那个线程的数据
Optional<Integer> any = list.stream().findAny();
System.out.println(any.get());
List<Integer> list = Arrays.asList(8, 4, 6, 2, 5, 1, 7);
long count = list.stream().count();
System.out.println(count);
Optional<Integer> max = list.stream().max(Integer::compareTo);
System.out.println(max.get());
Optional<Integer> min = list.stream().min(Integer::compareTo);
System.out.println(min.get());
List<Integer> list = Arrays.asList(8, 4, 6, 2, 5, 1, 7);
Long collect = list.stream().collect(Collectors.counting());
System.out.println(collect);
Double collect1 = list.stream().collect(Collectors.averagingInt(Integer::intValue));
System.out.println(collect1);
Integer collect2 = list.stream().collect(Collectors.summingInt(Integer::intValue));
System.out.println(collect2);
Optional 类
Optional 类(java.util.Optional) 是一个容器类,代表一个值存在或不在,
原来用 null 表示一个值不存在,现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常。
常用方法:
- Optional.of(T t) : 创建一个 Optional 实例
- Optional.empty() : 创建一个空的 Optional 实例
- Optional.ofNullable(T t):若 t 不为 null,创建 Optional 实例,否则创建空实例
- isPresent() : 判断是否包含值
- orElse(T t) : 如果调用对象包含值,返回该值,否则返回t
- orElseGet(Supplier s) :如果调用对象包含值,返回该值,否则返回 s 获取的值
- map(Function f): 如果有值对其处理,并返回处理后的Optional,否则返回 Optional.empty()
- flatMap(Function mapper):与 map 类似,要求返回值必须是Optional