第八章：Java8新增特性，Lambda表达式

7.7.8函数式接口

四大内置函数式接口:java.util.function

1.Consumer<T> 消费型接口 void accept(T t) 有参数没返回值

2.Function<T,R>函数型接口 R apply(T t) 有参数有返回值

3.Supplier<T> 供给型接口 T get() 无参数无返回值

4.Predicate<T> 段言型接口 boolean test(T t) 有参数有返回值，返回布尔类型

public class Class01_Functional {public static void main(String[] args) {//Lambda表达式，消费型接口testConsumer(1000,m-> System.out.println("酒店吃饭消费"+m));//函数型接口System.out.println(testFunction("nishi"   ,s->s.trim()));//删除元素前后位置空格System.out.println(testFunction("nishi"   ,s -> s.toUpperCase()));//将元素转为大写//供给型接口System.out.println(testSupplier(10,()->(int)(Math.random()*(10-1+1)+1)));System.out.println(testSupplier(30,()->(int)(Math.random()*(20-10+1)+10)));//断言型接口System.out.println(testPredicate(List.of("nini","nin","nishi"),s -> s.length()>=4));}//消费型接口,每天固定消费，有参数无返回值public static void testConsumer(double money , Consumer<Double> com){com.accept(money);}//函数型接口，对字符串进行某种处理，返回结果，有参数有返回值public static String testFunction(String str, Function<String,String> fun){return fun.apply(str);}//供给型,生成指定个数的不同规则的整数,有返回值，没有参数public static List<Integer> testSupplier(int num, Supplier<Integer> sup){List<Integer> list = new ArrayList<>();for (int i = 1;i<num;i++){list.add(sup.get());}return list;}//断言型，有参数，有返回值，返回Boolean类型,对集合中的多个字符串进行某种规则的过滤,返回满足条件的字符串public static List<String> testPredicate(List<String> list , Predicate<String> pre){List<String> newList = new ArrayList<>();for (String str : list){if (pre.test(str)){newList.add(str);}}return newList;//存放满足条件的字符串}
}

7.7.9方法引用（：：）

方法引用是lambda表达式的另外一种表现形式可以通过方法引用简化lambda表达式
使用前提: 当lambda表达式的lambda体中的实现已经存在另外一个方法实现了,只需要在lambda体中调用另一个方法--->可以通过方法引用的写法直接引用那个方法 lambda表达式重写的抽象方法的参数列表与返回值对应内部所引用方法的参数列表与返回值 lambda返回值与内部所调用方法的方法直接对应,lambda的参数列表的第一个参数作为内部调用成员方法的对象存在,lambda的第二到多个参数直接匹配内部所调用方法的参数列表存在
分类对象::成员方法要求: lambda表达式重写的抽象方法的参数列表与返回值对应内部所引用方法的参数列表与返回值类名::静态方法 lambda表达式重写的抽象方法的参数列表与返回值对应内部所引用方法的参数列表与返回值类名::成员方法 lambda返回值与内部所调用方法的方法直接对应,lambda的参数列表的第一个参数作为内部调用成员方法的对象存在,lambda的第二到多个参数直接匹配内部所调用方法的参数列表存在

public class Class01_Quite {public static void main(String[] args) {//对象::成员方法,消费型接口PrintStream num = System.out;Consumer<Integer> com = i -> num.println(i);//考虑是否可以通过方法引用简化 : 1)lambda体的实现是否是通过调用另外一个方法实现的--> √ println  2)考虑Consumer中的抽象方法的参数列表与返回值是否对应内部引用println方法的参数列表与返回值--> √com = num::println;com = System.out::println;//List.of(1,2,3,4,5,6).forEach(com);List.of(1,2,3,4,5,6).forEach(com);//类名::静态方法//求两个小数中的最大值BiFunction<Double,Double,Double> fun = (x,y) ->Math.min(x,y);//分析是否可以通过方法引用简化: 1)lambda体的实现是否是通过调用另外一个方法实现的--> √ max  2)apply方法的参数列表与返回值是否直接匹配内部所调用方法的参数列表与返回值 -> √fun = Math::min;System.out.println(fun.apply(1.55,1.68));BiPredicate<String,String> pre = (x,y)->x.equals(y);// 2)lambda返回值与内部所调用方法的方法直接对应,lambda的参数列表的第一个参数作为内部调用成员方法的对象存在,lambda的第二到多个参数直接匹配内部所调用方法的参数列表存在 --> √  可以使用类名::成员方法名简化pre = String::equals;System.out.println(pre.test("你是","你是"));}
}

7.8Stream流

Stream : 关注流式运算,不是传输与存储 io流关注数据的传输集合与数组关注数据的存储
注意: 1.Stream是一次性的流,一旦使用过就不能重复使用 2.Stream的操作不会影响数据源中的数据 3.延迟执行|惰性加载: 当获取终止行为时候才会执行中间操作
使用步骤: 1.获取Stream流 2.中间行为 : 一系列的流式操作 3.终止行为
创建Stream的方式: 1.Collection Stream<E> stream() 2.Arrays stream() 3.Stream.of(值列表)
特点: 1.Stream本身不存储数据 2.Stream不会修改数据源中的数据,可以对根据数据源产生的数据进行一些列流式的中间操作,每次中间操作都会返回一个持有结果的新的流 3.流是一次性的流,一旦使用就被销毁,不能重复使用多次 4.惰性加载|延迟执行: 只有在获取终止行为|结果的时候才会一起执行

public class Class01_Stream {public static void main(String[] args) {//1..Collection  Stream<E> stream()List<Integer> list = List.of(1, 2, 3, 4, 5);Stream<Integer> stream = list.stream();//增强for遍历stream.forEach(System.out::println);//2.Arrays  stream()String[] srr = {"AAA", "BBB", "CCC"};Stream<String> stream1 = Arrays.stream(srr);//增强for遍历stream1.forEach(System.out::println);//3.Stream.of(值列表)Stream<Integer> stream2 = Stream.of(5,4,3,2,1);stream2.forEach(System.out::println);}
}

7.8.1Stream流中间操作

1.过滤 Stream<T> filter(Predicate<? super T> predicate); 2.去重 Stream<T> distinct() 3.截取 Stream<T> limit(long maxSize) 4.跳过 Stream<T> skip(long) 5.排序 sorted() | sorted(Comparator<? super T> comparator) 6.映射 map(Function) ：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
注意: 中间操作都会返回一个持有结果的新的流
1，Stream 中间操作映射 map() 将流操作的元素装换成另外一种形式|提取结果. ** 接收一个函数作为参数,该函数会被应用到stream操作的每一个元素上,得到结果,最终会返回一个持有所有结果的新的stream {"","",""} {19,18,17,20},{{'a','a','a'},{'b','b','b'},{'c','c','c'}} flatMap（）

2，接收一个函数作为参数,该函数会被应用到stream操作的每一个元素上,得到结果必须为一个stream,最终会把所有的stream汇总成一个流,返回 {1,2,3},{4,5,6},{7,8,9}=>{1,2,3,4,5,6,7,8,9}

public class Class01_Stream2 {public static void main(String[] args) {List<Employee> list = Arrays.asList(new Employee("老李",21,3000),new Employee("老范",22,4000),new Employee("老吴",22,5000),new Employee("老吴",22,5000));//1.获取一个streamStream<Employee> stream = list.stream();//2.中间操作延迟执行stream = stream.filter(e->{System.out.println("----过滤条件----");return e.getSal()>3000;//中间操作方法}).distinct().limit(2).skip(1)//最终过滤.filter(e->{System.out.println("----最终过滤----"+e);return true;});//排序stream = list.stream().sorted();stream = list.stream().sorted((x,y)->Double.compare(x.getSal(), y.getSal()));//映射//Stream<Double> stream2 = list.stream().map(e->e.getSal());Stream<Double> stream2 = list.stream().map(Employee::getSal);//终止行为stream2.forEach(System.out::println);}
}

7.8.2终止行为

1，查找与匹配 allMatch-检查是否匹配所有元素 anyMatch-检查是否至少匹配一个元素 noneMatch-检查是否没有匹配所有元素
findFirst-返回第一个元素 findAny-返回当前流中的任意元素 count-返回流中元素的总个数 max-返回流中最大值 min-返回流中最小值

public class Class01_Stream3 {static List<Employee> list = Arrays.asList(new Employee("老李",21,3000),new Employee("老范",22,4000),new Employee("老吴",22,6000),new Employee("老王",25,5000),new Employee("老楚",23,3900));public static void main(String[] args) {//1.获取一个streamStream<Employee> stream = list.stream();//2.中间操作,终止行为//anyMatch-检查是否至少匹配一个元素System.out.println(stream.allMatch(e->e.getAge()>=21));//需求：按工资排序，获取第一个员工信息// findFirst-返回第一个元素//1)降序排序  2)找到第一个元素Optional<Employee> op1 = list.stream().sorted((x,y)->Double.compare(y.getSal(), x.getSal())).findAny();//判断里面是否有元素if (op1.isPresent()){System.out.println(op1.get());}//并行流op1 = list.parallelStream().findAny();System.out.println(op1.get());//薪资>5000的员工个数// count-返回流中元素的总个数System.out.println(list.stream().filter(e->e.getSal()>5000).count());max-返回流中最大值min-返回流中最小值System.out.println(list.stream().min((x,y)->Double.compare(x.getSal(), y.getSal())).get());//规约 map-reduce  先加工->后处理汇总结果System.out.println(list.stream().map(Employee::getSal).reduce((x,y)->x+y).get());System.out.println(Stream.of(1,2,3,4,5,6).reduce((x,y)->{System.out.println("----->x ="+x+",y= "+y);return (x+y);}).get());//算元素的总数System.out.println(Stream.of(1,2,3,4,5,6).reduce(10,(x,y)->{System.out.println("----->x ="+x+",y= "+y);//返回元素的和return (x+y);}));// 收集(collect)//collect 主要依赖 java.util.stream.Collectors 类内置的静态方法。//Collectors.toList()，输出集合里面所有的姓名List<String> name = list.stream().distinct().map(Employee::getName).collect(Collectors.toList());//打印输出System.out.println(name);//Collectors.toSet()，输出集合里面所有的姓名Set<String> name2 = list.stream().map(Employee::getName).collect(Collectors.toSet());System.out.println(name2);Collectors.toMap()，输出集合里面所有的姓名和工资Map<String,Double> map = list.stream().distinct().collect(Collectors.toMap(Employee::getName,Employee::getSal));System.out.println(map);}
}

7.8.3终止行为约束reduce

1，规约 reduce 根据某个统一的规则对数据进行合并

  注意: map-reduce 先加工再合并public class Class005_Stream {public static void main(String[] args) {List<Employee> list = List.of(new Employee("zhangsan",18,1),new Employee("lisi",17,2),new Employee("hanjiu",19,3),new Employee("tainqi",21,4),new Employee("heiba",18,5),new Employee("wangwu",19,7654),new Employee("wangwu",19,7654),new Employee("zhaoliu",16,5321));//计算前五个员工的薪资总和//reduce(BinaryOperator) 把stream操作的前两个元素作为第一次运算的两个参数,得到的结果作为第二次运算的第一个参数,stream操作的下一个元素作为第二次运算的第二个参数,,得到的结果作为第三次运算的第一个参数.....System.out.println(list.stream().limit(5).map(Employee::getSalary).reduce((x,y)->x+y).get());;
//reduce(BinaryOperator) 把stream操作的前两个元素作为第一次运算的两个参数,得到的结果作为第二次运算的第一个参数,stream操作的下一个元素作为第二次运算的第二个参数,,得到的结果作为第三次运算的第一个参数.....System.out.println(list.stream().limit(5).map(Employee::getSalary).reduce(100.0,(x,y)->x+y));;
// -->前提要求必须为并行流才有效//U reduce(U identity, --> 其实值// BiFunction<U, ? super T, U> accumulator, 先加工:  先对流操作的每一个数据与起始值进行一次运算,得到结果// BinaryOperator<U> combiner);  合并,对上一步加工得到的结果进行合并System.out.println(list.stream().limit(5).map(Employee::getSalary).parallel().reduce(100.0,(x,y)->{System.out.println(Thread.currentThread().getName()+"----- : "+x+"----->"+y);return x+y;},(x,y)->{System.out.println(Thread.currentThread().getName()+"----- : "+x+"---+--"+y+"  =   "+(x+y));return x+y;}));;}
}

7.8.4终止行为收集

1，收集 collect(Collector) Collectors 实现各种有用的约简操作的Collector的实现，例如将元素累积到集合中，根据各种标准汇总元素等。

public class Class006_Stream {public static void main(String[] args) {List<Employee> list = List.of(new Employee("zhangsan",18,1),new Employee("lisi",17,2),new Employee("hanjiu",19,3),new Employee("tainqi",21,4),new Employee("heiba",18,5),new Employee("wangwu",19,6),new Employee("zhaoliu",16,7));
//toList()//收集所有员工得到姓名System.out.println(list.stream().map(Employee::getName).collect(Collectors.toList()));;//去重System.out.println(list.stream().map(Employee::getName).collect(Collectors.toSet()));;//toMapSystem.out.println(list.stream().filter(e->e.getAge()>18).distinct().collect(Collectors.toMap(Employee::getName,Employee::getAge)));;
//counting()System.out.println(list.stream().collect(Collectors.counting()));System.out.println(list.stream().collect(Collectors.maxBy((x,y)->Double.compare(x.getSalary(),y.getSalary()))));
//薪资平局值System.out.println(list.stream().collect(Collectors.averagingDouble(Employee::getSalary)));}
}

第八章：Java8新增特性，Lambda表达式相关推荐

Java8新特性----Lambda表达式详细探讨
Java8新特性 Lambda表达式入门演示案例1 如何解决 cannot be cast to java.lang.Comparable问题? 案例2 优化方式一 : 策略设计模式优化方式二: ...
java8新特性lambda表达式、函数式编程、方法引用和接口默认方法以及内部类访问外部变量
一提到java是一种什么语言? 大多数人肯定异口同声的说是一门面向对象的语言,这种观点从我们开始学java就已经根深蒂固了,但是学到java8新特性函数式编程的时候,我才知道java并不是纯面向对象的 ...
Java8新特性——lambda表达式
什么是lambda表达式? Lambda 表达式是Java 8 的新特性,是一种新的编程语法.lambda语义简洁明了,性能良好,是Java 8 的一大亮点.废话不多说,我们来看个例子. 从内部类到l ...
java8新特性-lambda表达式入门学习
定义 jdk8发布新特性中,lambda是一大亮点之一.lambda表达式能够简化我们对数据的操作,减少代码量,大大提升我们的开发效率.Lambda 表达式"(lambda expressi ...
java8新特性lambda表达式概述
定义 jdk8发布新特性中,lambda是一大亮点之一.lambda表达式能够简化我们对数据的操作,减少代码量,大大提升我们的开发效率.Lambda 表达式"(lambda expres ...
Java8 新特性 -- Lambda表达式：函数式接口、方法的默认实现和静态方法、方法引用、注解、类型推测、Optional类、Stream类、调用JavaScript、Base64
文章目录 1. Lambda表达式 1.1 Lambda表达式语法 1.2 Lambda表达式示例 1.3 说明:函数式接口 2. 方法的默认实现和静态方法 3. 方法引用 3.1 方法引用示例 4. ...
java8新特性-lambda表达式和stream API的简单使用
一.为什么使用lambda Lambda 是一个匿名函数,我们可以把 Lambda表达式理解为是一段可以传递的代码(将代码像数据一样进行传递).可以写出更简洁.更灵活的代码.作为一种更紧凑的代码风 ...
java compare 返回值_关于Java你不知道的那些事之Java8新特性[Lambda表达式和函数式接口]...
前言为什么要用Lambda表达式? Lambda是一个匿名函数,我们可以把Lambda表达式理解为是一段可以传递的代码,将代码像数据一样传递,这样可以写出更简洁.更灵活的代码,作为一个更紧凑的代码风 ...
Java8 新特性lambda表达式（一）初始
本篇参考Richard Warburton的 java8 Lambdas :Functional Programming for the Masses 学习lambda表达式之前,需要知道什么是函数式 ...
【Java】Java8新特性Lambda表达式和Stream API
Lambda表达式是实现支持函数式编程技术的基础. 函数式编程与面向对象编程:函数式编程将程序代码看作数学中的函数,函数本身作为另一个函数参数或返回值,即高阶函数.而面向对象编程按照真实世界客观事物的 ...