Lamdba 表达式
当一个接口只有一个形象办法，称为函数式接口，这种接口能够以 lamdba 表达式来实现，目标是为了更简洁的代码
//1. 无参数无返回值
Runnable runnable = new Runnable() {
@Override
public void run() {System.out.println("hello lamdba");
}
};
Runnable r1 = () -> {System.out.println("hello lamdba");};
//lamdba 只有一条语句，可省大括号
Runnable r2 = () -> System.out.println("hello lamdba");
//2. 一个参数无返回值
Consumer<String> consumer = new Consumer<String>() {
@Override
public void accept(String s) {System.out.println("hello lamdba");
}
};
Consumer<String> consumer1 = (String s) ->System.out.println("hello lamdba");
// 可省参数类型
Consumer<String> consumer2 = (s) ->System.out.println("hello lamdba");
// 一个参数可省括号
Consumer<String> consumer3 = s ->System.out.println("hello lamdba");
//3. 多参数有返回值
Comparator<Integer> comparator = new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {return Integer.compare(o1, o2);
}
};
// 多参数括号不可省，只有一条 return 语句，可省 return
Comparator<Integer> comparator1 = (o1,o2) -> Integer.compare(o1, o2);总结
-> 右边：lambda 形参的参数类型能够省略，当 lambda 形参只有一个参数能够省略括号
-> 左边：如果 lambda 体只有一条执行语句省略{}，这条语句是 return 时省略 return
办法援用
办法援用是 lamdba 表达式的一种更简洁的模式
当满足 lambda 体只有一条执行语句且
1. 函数式接口办法中的形象办法的形参列表和返回值类型与援用办法的形参列表和返回值类型雷同
2. 函数式接口办法的第一个参数是须要援用办法的调用者，并且第二个参数是须要援用办法的参数
// 对象:: 实例办法
Consumer<String> consumer = s ->System.out.println("hello lamdba");
PrintStream ps = System.out;
Consumer<String> consumer1 = ps::print;
// 类:: 静态方法
Comparator<Integer> comparator = (o1,o2) -> Integer.compare(o1, o2);
Comparator<Integer> comparator1 = Integer::compare;
// 类:: 实例办法
Comparator<String> comp = (s1,s2) -> s1.compareTo(s2);
Comparator<String> comp1 = String::compareTo;
// 结构器援用相似办法援用
Supplier<Test> supplier1 = () -> new Test();
Supplier<Test> supplier2 = Test::new;
// 数组援用相似办法援用
Function<Integer, String[]> func = integer -> new String[integer];
Function<Integer, String[]> func1 = String[]::new;StreamAPI
Collection 关注的是数据的存储,Stream 关注的是数据的运算
Java8 提供了一套 Stream api，应用这套 api 能够对内存中的数据进行过滤、排序、映射、归约等操作
Stream 本人不会存储元素
Stream 不会扭转源对象。相同，他们会返回一个持有后果的新 Stream
Stream 操作是提早执行的。这意味着他们会等到须要后果的时候才执行
创立 Stream
//1. 应用汇合创立
List<Integer> list = new ArrayList<>();
Stream<Integer> stream = list.stream();
//2. 应用数组创立
Arrays.stream(new int[]{1,2,3});
//3. 应用 Stream 静态方法
Stream.of(1,2,3);两头操作
1. 筛选和切片
//1.1 filter，从流中排除元素
list.stream().filter(n -> n>=2).forEach(System.out::println);
//1.2 distinct，从流中去重元素
list.stream().distinct().forEach(System.out::println);
//1.3 limit，从流中截断元素
list.stream().limit(1).forEach(System.out::println);
//1.4 skip，从流中跳过元素
list.stream().skip(1).forEach(System.out::println);2. 映射
//2.1 map，对 Integer,String 汇合, 间接对汇合的元素做映射
list.stream().map(n -> n+1).forEach(System.out::println);
//2.2 flatMap，对汇合中又有汇合，先对汇合中的元素映射为流，再去对流中的元素做操作，最初会将所有的流合并为一个流
List<List<Integer>> listForMap = Arrays.asList(Arrays.asList(1,2),Arrays.asList(2,3));
listForMap.stream().flatMap(n -> n.stream()).map(n -> n+1).forEach(System.out::println);3. 排序
//3.1 sorted，对流中元素排序
list.stream().sorted().forEach(System.out::println);
//3.2 sorted()，自定义排序
list.stream().sorted((x,y) -> Integer.compare(y,x)).forEach(System.out::println);终止操作
1. 匹配和查找
allMatch(),anyMatch(),noneMath(),findFirst(),findAny(),count(),max(),min(),forEach()2. 规约
//2.1 reduce, 累加
System.out.println(list.stream().reduce(Integer::sum).get());3. 收集
//3.1 collect, 转换流到汇合
List<Integer> collectList = list.stream().filter(n -> n >= 2).collect(Collectors.toList());
collectList.stream().forEach(System.out::println);Option 类
ofNullable() 和 orElse() 搭配应用，不确定对象非空
String str ="hello java";
str = null;
Optional<String> optional = Optional.ofNullable(str);
System.out.println(optional);
//orElse(T t1): 如果 Optional 外部的 value 非空，则返回此 value 值。如果 value 为空，则返回 t1.
String str2 = optional.orElse("hello lamdba");
System.out.println(str2);