推导lambda表达式

匿名函数，用于接口

  1. public class TestLambda {
  3.     public void test1() {
  4.       /*  Comparator<Integer> comparator = new Comparator<Integer>(){
  6.             @Override
  7.             public int compare(Integer o1, Integer o2) {
  8.                 return Integer.compare(o1,o2);
  9.             }
  10.         };
  11.         TreeSet<Integer> set =new TreeSet<Integer>(comparator);*/
  12.         TreeSet<Integer> set = new TreeSet<>((x,y)->Integer.compare(x, y));
  13.     }
  15. }
  1. package Dome;
  2. /*
  3. 推导lambda表达式
  4. */
  5. /**
  6.  * @author dafran
  7.  * @version 1.0
  8.  * @date 2020-05-24 17:18
  9.  */
  10. public class TestLambda01 {
  11.     //3.静态内部类
  12.     static class Like2 implements ILike {
  13.         @Override
  14.         public void lambda() {
  15.             System.out.println("This is Lambda2");
  16.         }
  17.     }
  19.     public static void main(String[] args) {
  20.         ILike like = new Like();
  21.         like.lambda();
  23.         like = new Like2();
  24.         like.lambda();
  27.         //4.局部内部类
  28.         class Like3 implements ILike {
  29.             @Override
  30.             public void lambda() {
  31.                 System.out.println("This is Lambda3");
  32.             }
  33.         }
  35.         like = new Like3();
  36.         like.lambda();
  38.         //5.匿名内部类,没有类的名称,必须借助接口或者父类
  39.         like = new ILike() {
  40.             @Override
  41.             public void lambda() {
  42.                 System.out.println("This is Lambda4");
  43.             }
  44.         };
  45.         like.lambda();
  47.         //6.用Lambda简化
  48.         like = ()->{
  49.             System.out.println("This is Lambda5");
  50.         };
  51.         like.lambda();
  52.     }
  53. }
  55. //1.定义一个函数式接口
  56. interface ILike{
  57.     void lambda();
  58. }
  60. //2.实现类
  61. class Like implements ILike {
  63.     @Override
  64.     public void lambda() {
  65.         System.out.println("This is Lambda");
  66.     }
  67. }

lambda表达式简化

  1. package Dome;
  3. /**
  4.  * @author dafran
  5.  * @version 1.0
  6.  * @date 2020-05-24 17:47
  7.  */
  8. public class TestLambda02{
  9.     public static void main(String[] args) {
  11.         ILove love = null;
  13.         //1.Lambda简化
  14.         love = (int a) ->{
  15.             System.out.println("This is Love->" + a);
  16.         };
  18.         //2.参数简化
  19.         love = (a) ->{
  20.             System.out.println("This is Love->" + a);
  21.         };
  23.         //3.简化括号
  24.         love = a -> {
  25.             System.out.println("This is Love->" + a);
  26.         };
  28.         //4.简化花括号
  29.         love = a -> System.out.println("This is Love->" + a);
  31.         // 总结:
  32.             // lambda表达式只能有一行代码的情况下才能简化成为行，如果有多行， 那么就用代码块包
  33.             // 前提是接口为函数式接口
  34.             // 多个参数也可以去掉参数类型，要去掉就都去掉，必须加上括号
  36.         love.love(520);
  37.     }
  38. }
  40. interface ILove{
  41.     void love(int a);
  42. }

六大语法

”->“;

  • 左侧：Lambda表达式的参数列表
  • 右侧：Lambda表达式中所执行的功能，Lambda体
  • 依赖于函数式接口，Lambda表达式即对接口的实现
  1. public class LearnLambda {
  2.     /*
  3.      * 语法一：无参、无返回值
  4.      * 里面的变量和匿名内部类的相同，默认为final
  5.      * 需要可以设数组
  6.      */
  7.     public void test01() {
  8.         Runnable runnable = ()->{
  9.             System.out.println("1");
  10.         };
  11.          Runnable runnable =new Runnable() {
  12.             @Override
  13.             public void run() {
  14.                 System.out.println("1");
  15.             }
  16.         };
  17.     }
  18. }
  20. /**************************************/
  24.   /*
  25.      * 语法二：有一个参数、无返回值
  26.      */
  27.     public void test02() {
  28.         /* Consumer<String> com = (x)->{System.out.println(x);};
  29.          com.accept("test02");
  30.      }*/
  31.         Consumer<String> com = new Consumer();
  32.         this.change(com);
  33.         System.out.println(com);
  34.     };
  35.         public void change(Consumer com) {
  36.             com.accept("test02");
  37.         }
  38.     }
  39. /* 
  40. */
  41. /*******/
  44. public class LearnLambda {
  45.     /*
  46.      * 语法三：只有一个参数，省略括号
  47.      *
  48.      */
  49.     public void test03(){
  50.         Consumer<String> com= x->{ System.out.println(x);};
  51.         com.accept("003");
  52.     }
  54. }
  56. /************************/
  57.  /*
  58.      * 语法四：两个以上的参数，有返回值，并且Lambda体中有多条语句
  59.      *
  60.      */
  61.     public void test04(){
  62.         Comparator<Integer> com = (x,y) -> {
  63.             System.out.println("1234");
  64.             return Integer.compare(x,y);
  65.         };
  66.     }
  70. /*****************/
  74.  public class LearnLambda {
  75.     /*
  76.      * 语法五：Lambda体只有一条语句，return和大括号可以不写
  77.      *
  78.      */
  79.     public void test05(){
  80.         Comparator<Integer> com = (x,y) -> Integer.compare(x,y);
  81.     }
  83. }
  87. /**********************/
  89. public class LearnLambda {
  90.     /*
  91.      * 语六：参数指定类型
  92.      *
  93.      */
  94.     public void test06(){
  95.         Comparator<Integer> com = (Integer x,Integer y) -> Integer.compare(x,y);
  96.     }
  98. }

四大内置函数

类型 类 抽象方法
消费型接口（一个参数，无返回值） Consumer void accept(T t);
供给型接口（无参数，有返回值） Supplier T get();
函数型接口（一个参数，有返回值） Function R app1y(T t);
断言型接口（有参数，返回值为boolean类型） Predicate boolean test(T t); 
  1. import org.junit.jupiter.api.Test;
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import java.util.function.Consumer;
  6. import java.util.function.Function;
  8. public class StudyLambda {
  9.     //消费型接口Consumer
  10.     //需求：传入一个参数做业务处理，不做返回值
  11.     public void happy(double money,Consumer<Double> con){
  12.         con.accept(money);
  13.     }
  14.     @Test
  15.     public void test1(){
  16.         happy(1000, (m) -> System.out.println("每次消费"+m+"元"));
  17.     }
  20.     //供给型接口Supplier
  21.     //需求：产生指定数量的整数，放到集合中，返回集合
  22.     public List<Integer> getNumList(int num, java.util.function.Supplier<Integer> sp){
  23.         List<Integer> resurlt = new ArrayList<>();
  24.         for (int i = 0; i < num; i++) {
  25.             resurlt.add(sp.get());
  26.         }
  27.         return resurlt;
  28.     }
  29.     @Test
  30.     public void test2(){
  31.         List<Integer> numList = getNumList(5,() -> (int) (Math.random() * 100));
  32.         numList.forEach(System.out::println);
  33.     }
  35.     //函数型
  36.     //需求：传入一个字符串，返回一个字符串
  37.     public String strHandler(String str, Function<String, String>fun){
  38.         return fun.apply(str);
  39.     }
  40.     @Test
  41.     public void test3(){
  42.         String result = strHandler("武林盟主",(x) -> x+"无忌老师");
  43.         System.out.println(result);
  44.     }
  46.     //断言型
  47.     //Predicate
  49. }
  1. /*下面的不是很懂*/
  3. class StudyLambda03{
  4.     /*方法引用和对象引用
  5.      * 若Lambda体中的内容有方法实现，我们可以使用“方法引用”
  6.      * 可以理解为方法引用是Lambda表达式的另一种表现形式
  7.      * */
  10.     //对象::实例方法名
  11.     @Test
  12.     public void test4(){
  13.         //Consumer<String> con = (x) -> System.out.println(x);
  14.         PrintStream printStream = System.out;
  15.         //注意的是接口的抽象方法的形参表、返回值类型需要和调用的类方法形参表 返回值类型保持一致
  16.         Consumer<String> con = System.out::println;
  17.         con.accept("123456");
  18.     }
  21.     //类::静态方法名
  22.     @Test
  23.     public void test5(){
  24.         //注意的是接口的抽象方法的形参表、返回值类型需要和调用的类方法形参表 返回值类型保持一致
  25.         Comparator<Integer> com = (x,y) -> Integer.compare(x, y);
  26.         Comparator<Integer> com2 = Integer::compare;
  27.     }
  29.     //类::实例方法名
  30.     @Test
  31.     public void test6(){
  32.         //需求一：比较两个字符串是否相等;
  33.         //要求：第一参数是实例方法的调用者，第二个参数是方法的传入参数时
  34.         BiPredicate<String, String> bp = (x,y) -> x.equals(y);
  35.         BiPredicate<String, String> bp2 =  String::equals;
  36.     }
  39.     //构造器引用
  40.     //此处自己新建类
  41.     @Test
  42.     public void test7(){
  43.         Supplier<Person> student = Person::new;
  44.         Person person = student.get();
  45.         Function<Integer, Person> student = Person::new;
  46.         Person apply = student.apply(25);
  47.         System.out.println(apply.getAge());
  48.     }
  49. }

Stream

Stream是Java8中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用StreamAPI对集合数据进行操作，就类似于使用SQL执行的数据库查询。也可以使用StreamAPl来并行执行操作。

简而言之，StreamAPI提供了一种高效且易于使用的处理数据的方式。

Lambda表达式 - 图1

  1. import org.junit.jupiter.api.Test;
  3. import java.util.ArrayList;
  4. import java.util.Arrays;
  5. import java.util.List;
  6. import java.util.stream.Stream;
  8. public class StreamApi {
  9.     //需求：学员年龄大于25岁的
  10.     List<Person> studentList = Arrays.asList(
  11.             new Person("无极","18","181","35000");
  12.             new Person("无极1","18","181","35000");
  13.             new Person("无极2","18","181","35000");
  14.             new Person("无极3","18","181","35000");
  15.             new Person("无极4","18","181","35000")
  16.     )
  19.     //创建流
  20.     //四种
  21.     @Test
  22.     public void test(){
  23.         List<String> list = new ArrayList<>();
  24.         Stream<String> stream = list.stream();
  26.         Person[] students = new Person[]{};
  27.         Stream<Person> stream1 = Arrays.stream(students);
  29.         Stream<String> stream = Stream.of("a","b","c");
  31.         Stream<Integer> stream4 = Stream.iterate(0,(x) -> x+2);
  32.         stream4.limit(10).forEach(System.out::println);
  33.     }
  35.     //终止操作：一次性执行全部内容 --> "惰性求值"
  36.     @Test
  37.     public void test2(){
  38.         Stream<Person> studentStream = studentList.stream()
  39.                 .filter((x) -> x.getSlary() -> 25000);
  41.         studentStream.forEach(System.out::println);
  42.     }
  44.     //map 映射 接收Lambda，将元素转换成其他形式或提取信息。
  45.     //接受一个函数作为参数，该函数会被应用到每个元素上并其映射成一个新的元素
  46.     @Test
  47.     public void test3(){
  48.         Stream<String> stream = Stream.of("aaa","bbb","ccc");
  49.         stream.map((x) -> x.toUpperCase())
  50.                 .forEach(System.out::println);
  51.         //studentList.stream().map(Person::getName).forEach(System.out::println);
  52.     }
  53. }

并行流和串行流

并行流就是把一个内容分成多个数据块,并用不同的线程分别处理每个数据块的流。Java8中将并行进行了优化，我们可以很容易的对数据进行并行操作。Stream API可以声明性地通过parallel()与sequential()在并行流与顺序流之间进行切换。

  1. import org.junit.jupiter.api.Test;
  3. import java.time.Duration;
  4. import java.time.Instant;
  5. import java.util.stream.LongStream;
  7. /**
  8.  * @author Administrator
  9.  * @Classname StreamApi2
  10.  * @Description TODO
  11.  * @Date 2020-10-04 21:24
  12.  * @Version V1.0
  13.  */
  14. public class StreamApi2 {
  16.     @Test
  17.     public void test(){
  18.         Instant start = Instant.now();
  19.         long res = LongStream.rangeClosed(0,1000000L).
  20.                 parallel().reduce(0,Long::sum);
  21.         System.out.println(res);
  22.         Instant end = Instant.now();
  23.         System.out.println("耗费事件为："+ Duration.between(start, end).toMillis());
  24.     }
  25. }

ForkJoin并发框架从JDK1.7开始，Java提供ForkJoin框架用于并行执行任务，它的思想就是讲一个大任务分割成若干小任务，最终汇总每个小任务的结果得到这个大任务的结果。
两个特性：递归分治、工作密取

引出Stream

  1. import java.util.concurrent.RecursiveTask;
  3. /**
  4.  * @author Administrator
  5.  * @Classname ForkJoinCalculate
  6.  * @Description TODO
  7.  * @Date 2020-10-04 20:43
  8.  * @Version V1.0
  9.  */
  10. public class ForkJoinCalculate extends RecursiveTask {
  12.     private long start;
  13.     private long end;
  15.     private static final long THRESHOLD = 10000;
  17.     public ForkJoinCalculate(long start, long end){
  18.         this.start = start;
  19.         this.end = end;
  20.     }
  22.     /**
  23.      * 运算或者任务拆分
  24.      *
  25.      */
  26.     @Override
  27.     protected Object compute() {
  28.         long length = end - start;
  29.         if (length <= THRESHOLD) {
  30.             //当前任务数据区间小于10000
  31.             long sum = 0;
  32.             for (long i = start; i <= end; i++){
  33.                 sum += i;
  34.             }
  35.             return sum;
  36.         }else {
  37.             //当前任务数据区间大于10000
  38.             long middle = (start + end) / 2;
  39.             ForkJoinCalculate left = new ForkJoinCalculate(start,middle);
  40.             ForkJoinCalculate rigth = new ForkJoinCalculate(middle+1,end);
  41.             left.fork();
  42.             rigth.fork();
  43.             return left.join() + rigth.join();
  44.         }
  45.     }
  46. }