一、Lambda表达式
Lambda表达式的使用
1、举例：
Comparator<Integer> com2 = (o1, o2) -> Integer.compare(o1, o2);
2、格式：
- ->：lambda操作符或箭头操作符；
- ->左边：lambda形参列表（其实就是接口中的抽象方法的形参列表）；
- ->右边：lambda体（其实就是重写接口的抽象方法的方法体）
3、Lambda表达式的使用（分为6种情况）
语法一：无参数，无返回值
@Test
public void test1() {
Runnable r1 = new Runnable() {
@Override
public void run() {
System.out.println("Lambda表达式第一个例子");
}
};
r1.run();
System.out.println("--------------------------------------");
Runnable r2 = () -> System.out.println("Lambda表达式第一个例子");
r2.run();
}
语法二：有一个参数，无返回值
@Test
public void test2() {
Consumer<String> con1 = new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
};
con1.accept("有一个参数，无返回值");
System.out.println("--------------------------------------");
Consumer<String> con2 = (String s) -> {
System.out.println(s);
};
con2.accept("有一个参数，无返回值");
}
语法三：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”
@Test
public void test3() {
Consumer<String> con1 = (String s) -> {
System.out.println(s);
};
con1.accept("有一个参数，无返回值");
System.out.println("--------------------------------------");
Consumer<String> con2 = (s) -> {
System.out.println(s);
};
con2.accept("有一个参数，无返回值");
}
语法四：如果有一个参数时，参数的小括号也可以省略
@Test
public void test4() {
Consumer<String> con1 = (s) -> {
System.out.println(s);
};
con1.accept("有一个参数，无返回值");
System.out.println("--------------------------------------");
Consumer<String> con2 = s -> {
System.out.println(s);
};
con2.accept("有一个参数，无返回值");
}
语法五：如果有两个或以上参数时，多条语句执行，并且可以有返回值
@Test
public void test5() {
Comparator<Integer> com1 = new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
System.out.println(o1);
System.out.println(o2);
return Integer.compare(o1, o2);
}
};
System.out.println(com1.compare(12, 22));
System.out.println("--------------------------------------");
Comparator<Integer> com2 = (o1, o2) -> {
System.out.println(o1);
System.out.println(o2);
return Integer.compare(o1, o2);
};
System.out.println(com2.compare(12, 22));
}
语法六：Lambda体只有一条执行语句时，return和大括号都可以省略
@Test
public void test6() {
Comparator<Integer> com1 = (o1, o2) -> {
return Integer.compare(o1, o2);
};
System.out.println(com1.compare(12, 22));
System.out.println("--------------------------------------");
Comparator<Integer> com2 = (o1, o2) -> Integer.compare(o1, o2);
System.out.println(com2.compare(12, 22));
}
总结：
->左边（lambda形参列表）：
lambda形参列表的参数类型可以省略（类型推断）
如果lambda形参列表只有一个参数，那么小括号也可以省略
->右边（lambda体）：
如果lambda体只有一条执行语句（可能是return语句），那么大括号和return也可以省略
4、Lambda表达式的本质：作为函数式接口的实例
二、函数式接口
定义
如果一个接口只声明一个抽象方法，那么它就是一个函数式接口（@FunctionalInterface可以检验接口是否是函数式接口）。
java内置四大核心函数式接口
| 函数式接口 | 参数类型 | 返回值类型 | 作用 |
|---|---|---|---|
| Consumer<T>：消费性接口 | T | 无 | 对类型为T的对象应用操作，包含方法：void accept(T t); |
| Supplier<T>：供给型接口 | 无 | T | 返回类型为T的对象，包含方法：T get(); |
| Function<T, R>：函数型接口 | T | R | 对类型为T的对象应该用操作，并返回结果，结果是类型为R的对象，包含方法：R apply(T t); |
| Predicate<T>：断定型接口 | T | boolean | 确定类型为T的对象是否满足某种约束，并返回boolean值，包含方法：boolean test(T t); |
举例：
@Test
public void test1() {
happyTime(500, new Consumer<Double>() {
@Override
public void accept(Double money) {
System.out.println("本次消费: " + money);
}
});
System.out.println("--------------------------------------");
happyTime(1000, money -> System.out.println("本次消费: " + money));
}
private void happyTime(double time, Consumer<Double> consumer) {
consumer.accept(time);
}
@Test
public void test2() {
List<String> list = Lists.newArrayList("北京", "南京", "天津", "东京", "普京");
List<String> filterList = filterString(list, new Predicate<String>() {
@Override
public boolean test(String s) {
return s.contains("京");
}
});
System.out.println(filterList);
System.out.println("--------------------------------------");
List<String> filterList1 = filterString(list, s -> s.contains("京"));
System.out.println(filterList1);
}
//根据给定的规则，过滤集合中的字符串，规则由Predicate的方法提供
public List<String> filterString(List<String> list, Predicate<String> pre) {
List<String> filterList = Lists.newArrayList();
for (String s : list) {
if (pre.test(s)) {
filterList.add(s);
}
}
return filterList;
}
三、方法引用与构造器引用
方法引用
1、使用场景：当要传递给lambda体的操作，已经有实现方法了，就可以使用方法引用
2、本质：方法引用本质上就是lambda表达式，是函数式接口的实例
3、使用格式：类（或对象） :: 方法名
4、具体分为三种情况：
情况1：对象 :: 非静态方法
//例子1
@Test
public void test1() {
Consumer<String> con1 = str -> System.out.println(str);
con1.accept("哈哈");
System.out.println("--------------------------------------");
PrintStream ps = System.out;
Consumer<String> con2 = ps ::println;
con2.accept("呵呵");
}
//例子2
@Test
public void test2() {
Emplyee emp = new Emplyee(1001, "Tom", 23, 5600);
Supplier<String> sup1 = () -> emp.getName();
System.out.println(sup1.get());
System.out.println("--------------------------------------");
Supplier<String> sup2 = emp::getName;
System.out.println(sup2.get());
}
情况2：类 :: 静态方法
//例子1
@Test
public void test3() {
Comparator<Integer> com1 = (t1, t2) -> Integer.compare(t1, t2);
System.out.println(com1.compare(23, 43));
System.out.println("--------------------------------------");
Comparator<Integer> com2 = Integer::compare;
System.out.println(com2.compare(23, 43));
}
//例子2
@Test
public void test4() {
Function<Double, Long> fun1 = d -> Math.round(d);
System.out.println(fun1.apply(33.33));
System.out.println("--------------------------------------");
Function<Double, Long> fun2 = Math::round;
System.out.println(fun2.apply(33.33));
}
情况3：类 : :非静态方法（难）
//例子1
@Test
public void test5() {
Comparator<String> com1 = (s1, s2) -> s1.compareTo(s2);
System.out.println(com1.compare("abc", "bcd"));
System.out.println("--------------------------------------");
Comparator<String> com2 = String::compareTo;
System.out.println(com2.compare("abc", "bcd"));
}
//例子2
@Test
public void test6() {
BiPredicate<String, String> pre1 = (s1, s2) -> s1.equals(s2);
System.out.println(pre1.test("abc", "bcd"));
System.out.println("--------------------------------------");
BiPredicate<String, String> pre2 = String::equals;
System.out.println(pre2.test("abc", "bcd"));
}
//例子3
@Test
public void test7() {
Emplyee emp = new Emplyee(1001, "Jerry", 23, 5600);
Function<Emplyee, String> fun1 = e -> e.getName();
System.out.println(fun1.apply(emp));
System.out.println("--------------------------------------");
Function<Emplyee, String> fun2 = Emplyee::getName;
System.out.println(fun2.apply(emp));
}
5、方法引用的使用要求：要求接口中抽象方法的参数列表和返回值类型与方法引用的形参列表和返回值类型相同
构造器引用
//例子1
@Test
public void test1() {
Supplier<Emplyee> sup1 = () -> new Emplyee();
sup1.get();
System.out.println("--------------------------------------");
Supplier<Emplyee> sup2 = Emplyee::new;
sup2.get();
}
//例子2
@Test
public void test2() {
Function<Integer, Emplyee> fun1 = id -> new Emplyee(id);
System.out.println(fun1.apply(12));
System.out.println("--------------------------------------");
Function<Integer, Emplyee> fun2 = Emplyee::new;
System.out.println(fun2.apply(34));
}
//例子3
@Test
public void test3() {
BiFunction<Integer, String, Emplyee> fun1 = (id, name) -> new Emplyee(id, name);
System.out.println(fun1.apply(22, "Jack"));
System.out.println("--------------------------------------");
BiFunction<Integer, String, Emplyee> fun2 = Emplyee::new;
System.out.println(fun2.apply(33, "Zhou"));
}
数组引用
@Test
public void test4() {
Function<Integer, String[]> fun1 = length -> new String[length];
String[] arr1 = fun1.apply(10);
System.out.println(Arrays.toString(arr1));
System.out.println("--------------------------------------");
Function<Integer, String[]> fun2 = String[]::new;
String[] arr2 = fun2.apply(5);
System.out.println(Arrays.toString(arr2));
}
四、强大的Stream API
一、Stream是干嘛的？
可以理解为使用StreamAPI操作集合中的数据，就类似于使用sql执行的数据库查询。
二、Stream与Collection的区别？
Stream关注的是对数据的运算，与cpu打交道；
Collection关注的是数据的存储，与内存打交道。
三、Stream注意事项
- Stream自己不会存储元素；
- Stream不会改变源对象。相反，他们会返回一个持有结果的新Stream；
- 操作是延时执行的。这意味着他们会等到需要结果是才执行。
四、StreamAPI的执行流程
1、Stream的实例化
方式一：通过集合
@Test
public void test1() {
List<Emplyee> employees = EmplyeeData.getEmployees();
//default Stream<E> stream()：返回一个顺序流
Stream<Emplyee> stream = employees.stream();
//default Stream<E> parallelStream()：返回一个并行流
Stream<Emplyee> parallelStream = employees.parallelStream();
}
方式二：通过数组
@Test
public void test2() {
//调用Arrays类的static IntStream stream(T[] array)方法：返回一个流
int[] arr1 = new int[]{1, 2, 3, 4, 5};
IntStream stream = Arrays.stream(arr1);
Emplyee e1 = new Emplyee(1, "Tom");
Emplyee e2 = new Emplyee(2, "Jerry");
Emplyee[] arr2 = new Emplyee[]{e1, e2};
Stream<Emplyee> stream1 = Arrays.stream(arr2);
}
方式三：通过Stream的of()
@Test
public void test3() {
Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5);
}
方式四：创建无限流
@Test
public void test4() {
//迭代
//public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
//遍历前10个偶数
Stream.iterate(0, t -> t+2).limit(10).forEach(System.out::println);
//生成
//public static<T> Stream<T> generate(Supplier<T> s)
Stream.generate(Math::random).limit(10).forEach(System.out::println);
}
2、一系列的中间操作
筛选与切片
@Test
public void test1() {
List<Emplyee> list = EmplyeeData.getEmployees();
//Stream<T> filter(Predicate<? super T> predicate); --接受lambda，从流中排除某些元素
//练习：查询员工中薪资大于7000的员工信息
list.stream().filter(emplyee -> emplyee.getSalary() > 7000).forEach(System.out::println);
System.out.println("--------------------------------------");
//Stream<T> limit(long maxSize); --截断流，使其元素不超过给定数量
list.stream().limit(3).forEach(System.out::println);
System.out.println("--------------------------------------");
//Stream<T> skip(long n); --跳过元素，返回一个扔掉了前n个元素的流。若流中的元素不足n个，则返回一个空的流
list.stream().skip(5).forEach(System.out::println);
System.out.println("--------------------------------------");
//Stream<T> distinct(); --筛选，通过流锁生成元素的hashCode()和equals()去除重复元素
list.add(new Emplyee(1010, "刘强东", 34, 6000.23));
list.add(new Emplyee(1010, "刘强东", 34, 6000.23));
list.stream().distinct().forEach(System.out::println);
}
映射
@Test
public void test2() {
//map(Function f); --接受一个函数作为参数，该函数会被应用到每一个元素上，并将其映射成一个新的元素
List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
List<String> strings = list.stream().map(String::toUpperCase).collect(Collectors.toList());
System.out.println(strings);
System.out.println("--------------------------------------");
//练习：获取员工姓名长度大于3的员工的姓名
List<Emplyee> employees = EmplyeeData.getEmployees();
List<String> stringList = employees.stream().map(emplyee -> emplyee.getName()).filter(name -> name.length() > 3).collect(Collectors.toList());
System.out.println(stringList);
System.out.println("--------------------------------------");
//flatMap(Function f); --接受一个函数作为参数，将流中的每一个值都换成另一个流，然后把所有的流链接成一个流
List<Character> collect = list.stream().flatMap(StreamAPITest1::strToStream).collect(Collectors.toList());
System.out.println(collect);
}
private static Stream<Character> strToStream(String str) {
List<Character> list = Lists.newArrayList();
for (Character c : str.toCharArray()) {
list.add(c);
}
return list.stream();
}
排序
@Test
public void test3() {
//sorted(); --自然排序
List<Integer> list = Arrays.asList(12, 34, 23, 54, 56, 34, 76, 23);
List<Integer> collect = list.stream().sorted().collect(Collectors.toList());
collect.forEach(System.out::println);
System.out.println("--------------------------------------");
//sorted(Comparator com); --定制排序
List<Emplyee> employees = EmplyeeData.getEmployees();
List<Emplyee> collect1 = employees.stream().sorted((e1, e2) -> {
int compare = Integer.compare(e1.getAge(), e2.getAge());
if (compare == 0) {
return Double.compare(e1.getSalary(), e2.getSalary());
} else {
return compare;
}
}).collect(Collectors.toList());
collect1.forEach(System.out::println);
}
3、终止操作
匹配与查找
@Test
public void test1() {
List<Emplyee> employees = EmplyeeData.getEmployees();
//allMatch(Predicate p); --检查是否匹配所有元素
//练习：是否所有员工年龄都大于18岁？
boolean allMatch = employees.stream().allMatch(emplyee -> emplyee.getAge() > 18);
System.out.println(allMatch);
System.out.println("--------------------------------------");
//anyMatch(Predicate p); --检查是否至少匹配一个元素
//练习：是否存在工资大于10000的员工？
boolean anyMatch = employees.stream().anyMatch(emplyee -> emplyee.getSalary() > 10000);
System.out.println(anyMatch);
System.out.println("--------------------------------------");
//noneMatch(Predicate p); --检查是否没有匹配的元素
//是否不存在"雷"姓员工?
boolean noneMatch = employees.stream().noneMatch(emplyee -> emplyee.getName().contains("雷"));
System.out.println(noneMatch);
System.out.println("--------------------------------------");
//findFirst(); --返回第一个元素
Emplyee emplyee = employees.stream().findFirst().get();
System.out.println(emplyee);
System.out.println("--------------------------------------");
//findAny(); --返回当前流中的任意元素
Emplyee emplyee1 = employees.parallelStream().findAny().get();
System.out.println(emplyee1);
System.out.println("--------------------------------------");
//count(); --放回当前流中的总个数
long count = employees.stream().filter(e -> e.getSalary() > 5000).count();
System.out.println(count);
System.out.println("--------------------------------------");
//max(Comparator c); --返回流中最大值
//练习：返回最高工资的员工
Emplyee max = employees.stream().max(Comparator.comparingDouble(Emplyee::getSalary)).get();
System.out.println(max);
System.out.println("--------------------------------------");
//min(Comparator c); --返回流中最小值
//练习：返回最低工资的员工
Emplyee min = employees.stream().min(Comparator.comparingDouble(Emplyee::getSalary)).get();
System.out.println(min);
System.out.println("--------------------------------------");
//forEach(Consumer c); --内部迭代
employees.stream().forEach(System.out::println);
}
归约
@Test
public void test2() {
//reduce(T id, BinaryOperator b); --可以将流中的元素反复结合起来，得到一个值。返回T
//练习：计算1-10的自然数的和
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
Integer sum = list.stream().reduce(0, Integer::sum);
System.out.println(sum);
System.out.println("--------------------------------------");
//reduce(BinaryOperator b); --可以将流中的元素反复结合起来，得到一个值。返回Optional<T>
//练习：计算公司所有员工工资的总和
List<Emplyee> employees = EmplyeeData.getEmployees();
Double sum1 = employees.stream().map(Emplyee::getSalary).reduce(Double::sum).get();
System.out.println(sum1);
System.out.println("--------------------------------------");
Double sum2 = employees.stream().map(Emplyee::getSalary).reduce((d1, d2) -> d1 + d2).get();
System.out.println(sum2);
}
收集
@Test
public void test3() {
//collect(Collector c); --将流装换为其他形式。接受一个Collector接口的实现，用于给Stream中元素做汇总的方法
//练习：查找工资大于6000的员工，结果返回一个List或Set
List<Emplyee> employees = EmplyeeData.getEmployees();
List<Double> collect = employees.stream().map(Emplyee::getSalary).filter(d -> d > 6000).collect(Collectors.toList());
System.out.println(collect);
System.out.println("--------------------------------------");
Set<Double> collect1 = employees.stream().map(Emplyee::getSalary).filter(d -> d > 6000).collect(Collectors.toSet());
System.out.println(collect1);
}
五、Optional类
为了避免在程序中存在空指针异常而创建的
常用方法
创建Optional类对象的方法：
//创建一个Optional实例，value必须非空
public static <T> Optional<T> of(T value) {
return new Optional<>(value);
}
//创建一个空的Optional实例
public static<T> Optional<T> empty() {
@SuppressWarnings("unchecked")
Optional<T> t = (Optional<T>) EMPTY;
return t;
}
////创建一个Optional实例，value可以为空
public static <T> Optional<T> ofNullable(T value) {
return value == null ? empty() : of(value);
}
判断Optional容器中是否包含对象
//判断是否包含对象
public boolean isPresent() {
return value != null;
}
//如果存在值，则使用该值调用指定的Consumer，否则什么都不做。
public void ifPresent(Consumer<? super T> consumer) {
if (value != null)
consumer.accept(value);
}
获取Optional容器的对象
//如果调用对象包含值，返回该值，否则抛异常
public T get() {
if (value == null) {
throw new NoSuchElementException("No value present");
}
return value;
}
//如果有值则将其返回，否则返回指定的other对象
public T orElse(T other) {
return value != null ? value : other;
}
//如果有值则将其返回，否则返回由Supplier接口实现提供的对象
public T orElseGet(Supplier<? extends T> other) {
return value != null ? value : other.get();
}
//如果有值则将其返回，否则返回由Supplier接口实现提供的异常
public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
if (value != null) {
return value;
} else {
throw exceptionSupplier.get();
}
}
