Lambda表达式
Lambad表达式的使用
- 举例:(o1, o1) -> Integer.compare(o1, o2);
- 格式:
–>: Lambda操作符 / 箭头操作符
–>: 左边: Lambda形参列表(其实就是接口中的抽象方法的行参列表)
–>: 右边: lambda体 (其实就是重写的抽象方法的方法体) - Lambda表达式的使用:(分为6种情况)
总结:
–>左边: lambda形参列表的参数类型都可以忽略(类型推断),如果lambda形参列表只有一个参数,其一对()也可忽略
–>右边: lambda体应该使用一对{}包裹,如果只有一条语句,则可以省略{}\return
//语法格式一:无参、无返回值
Runnable r2 = () -> {System.out.println("Dreamyouth")};
//语法格式二:Lambda 需要一个参数,但是没有返回值
Cosumer<String> con1 = (String s) -> {System.out.println(s);};
//语法格式三: 数据类型可以省略,因为可由编译器推断得出,称为“类型推断”
Consumer<String> con1 = (s) -> {System.out.println(s)};
//语法格式四: 只需要一个参数的时候,参数的小括号可以省略
Consumer<String> con1 = s -> {System.out.println(s)};
//语法格式五: 需要两个或以上的参数,多条执行语句,并且可以有返回值
Comparator<Integer> com2 = (o1, o2) -> {
System.out.println(o1);
System.out.println(o2);
return o1.compareTo(o2);
}
//语法格式六: 当Lambda体只有一条语句时,return与大括号若有,都可以忽略
Comparator<Integer> com2 = (o1, o2) -> o1.compareTo(o2);
- Lambda表达式的本质: 作为接口的实例
Stream API
- Stream关注的是对数据的运算,与CPU打交到
集合关注的是数据的存储,与内存打交道 - –>Stream 自己不会存储元素
–>Stream 不会改表源对象。相反,他们会返回一个持有结果的新Stream
–>Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。 - Stream 执行流程
- Stream的实例化
- Stream一系列的中间操作(过滤、映射…)
- 终止操作
- 说明:
- 一个中间操作链,对数据源的数据进行处理
- 一旦执行终止操作,就执行中间操作链,并产生结果。之后不会再被使用。
创建Stream方式:
通过集合:
List<Employee> employees = EmployeeData.getEmployees();
//返回一个顺序流
Stream<Employee> stream = employees.stream();
//返回一个并行流
Stream<Employee> parallelStream = employees.parallelStream();
通过数组:
int[] arr = new int[]{1,2,3,4,5,6};
//调用Arrays类的static <T> Stream<T> stream(T[] array); 返回一个流
IntStream stream1 = Arrays.stream(arr);
Employee e1 = new Employee(1001, "Tom");
Employee e2 = new Employee(1002, "Jerry");
Employee[] arr1 = new Employee[]{e1, e2};
Stream<Employee> stream2 = Arrays.stream(arr1);
通过Stream的Of()
Stream<Integer> stream3 = Stream.of(1, 2, 3, 4, 5, 6);
生成无限个(仅了解)
Stream的中间操作
筛选与切片
//1.筛选与切片
List<Employee> list = EmployeeData.getEmployees();
//filter(Predicate p)--接收Lambda,从流中排除某些元素
Stream<Employee> stream = list.stream();
stream.filter(e -> e.getSalary() > 7000).forEach(System.out::println);
//limit(n)--截断流,使其元素不超过给定数量
list.stream().limit(3).forEach(System.out::println);
//skip(n)--跳过元素,返回一个扔掉前n个元素的流
list.stream().skip(3).forEach(System.out::println);
//distinct()--筛选,通过流生成元素的hashCode()和equals() 去除重复的元素
list.add(new Employee(1010, "刘强东", 40, 8000));
list.add(new Employee(1010, "刘强东", 40, 8000));
list.stream().distinct().forEach(System.out::println);
映射
@Test
public void testyingshe(){
//map(Function f)--接收一个函数作为参数,将元素转化为其他形式或提取信息,该函数会被应用到每个元素上,并将其映射成一个新的元素
List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
list.stream().map(str -> str.toUpperCase()).forEach(System.out::println);
List<Employee> employees = EmployeeData.getEmployees();
Stream<String> nameStream = employees.stream().map(Employee::getName);
nameStream.filter(name -> name.length() > 3).forEach(System.out::println);
//flatMap(Function f)--接收一个函数作为参数,将流中的每个值都换成另一个流,然后把所有流连接成一个流。
Stream<Stream<Character>> streamStream = list.stream().map(Java8NewProperties::fromStringToStream);
}
//将字符串中的多个字符构成的集合转换为对应的Stream的实例
public static Stream<Character> fromStringToStream(String str){
ArrayList<Character> list = new ArrayList<>();
for (Character c :
str.toCharArray()) {
list.add(c);
}
return list.stream();
}
排序
@Test
public void test4(){
//sorted--自然排序
List<Integer> list = Arrays.asList(12, 3, 21, 2, 32, 1, 1 2, 21);
list.stream().sorted().forEach(System.out::println);
//sorted(Comparator com)--定制排序
List<Employee> employees = EmployeeData.getEmployees();
employees.stream().sorted((e1, e2) -> {
return Integer.compare(e1.getAge(), e2.getAge());
}).forEach(System.out::println);
}
Stream的终止操作
查找与匹配
List<Employee> employees = EmployeeData.getEmployees();
boolean allMatch = employees.stream().allMatch(e -> e.getAge() > 18);
System.out.println(allMatch);
boolean anyMatch = employees.stream().anyMatch(e -> e.getSalary() > 10000);
System.out.println(anyMatch);
boolean noneMatch = employees.stream().noneMatch(e -> e.getName() == "jack");
Optional<Employee> first = employees.stream().findFirst();
Optional<Employee> any = employees.parallelStream().findAny();
employees.stream().filter(e -> e.getSalary() > 5000).count();
//最大工资
Stream<Double> salaryStream = employees.stream().map(e -> e.getSalary());
Optional<Double> max = salaryStream.max(Double::compare);
//最低工资
Optional<Employee> min = employees.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
//forEach
规约
@Test
public void testStipulations(){
List<Integer> list = Arrays.asList(1, 2, 3, 4, 12, 4);
list.stream().reduce(0,Integer::sum);
}
收集
List<Employee> employees = EmployeeData.getEmployees();
List<Employee> employeeList = employees.stream().filter(e -> e.getAge() > 10).collect(Collectors.toList());
employeeList.forEach(System.out::println);