Java8新特性

学习目标：

lambda表达式

Stream

---

学习内容：

一、lambda

1.Lambda表达式
    作用: 简化匿名内部类对象

    使用前提: 函数式接口
    函数式接口: 只有一个必须被重写的抽象方法的接口称为函数式接口
    检查函数式接口注解: @FunctionalInterface 强制检测

    语法:
        () ->  {}
        () :  要重写的抽象方法的参数列表
        -> :  箭头函数 lambda符号 ,具有上下文推到的作用
        {} :  要重写抽象方法的方法体

2.Lambda写法

public class Class03_Lambda {
    public static void main(String[] args) {
        //匿名内部类对象
      /*  run r=new run() {
            @Override
            public void run() {
                System.out.println("跑跑跳跳");
            }
        };*/
        /*1.lambda写法1
        run r=()->{
            System.out.println("跑跑跳跳1");
        };*/

        //2.lambda写法2 : 当lambda体(重写方法的方法体)中的语句只有一句,前后的{}可以省略
       // run r=()-> System.out.println("跑跑跳跳2");

        //3.lambda写法3 : 参数的数据类型可以省略
       /* run r=(a,b)-> System.out.println("跑跑跳跳2"+(a+b));
        r.run(2,5);*/

        //4.lambda写法4 : 参数只有一个,前后的()可以省略
        /*run r=a-> System.out.println("跑跑跳跳3"+a);
        r.run(5);*/

        //5.lambda写法5 : 当方法存在返回值类型,{}lambda体中只有一条语句,并且是return语句,前后的{}与return关键字可以一起省略
        run r=a->a<<2;
        System.out.println(r.run(5));
    }
}

@FunctionalInterface
interface run{
   int run(int x);
}

3.lambda的内置函数接口

        四大内置函数式接口

               消费型接口 Consumer<T>

                   void accept(T t)  有一个参数没有返回值

               函数型接口 Function<T,R>

                   R apply(T t)    有一个参数一个返回值

               断言型接口 Predicate<T>

                   boolean test(T t)   一个参数一个boolean返回值

               供给型接口 Supplier<T>

                   T get()             没有参数一个返回值

public class Class04_FuntionalInterface {
    public static void main(String[] args) {
        testConsumer(1000,i-> System.out.println("恰饭恰了"+i));

        System.out.println(testFunction("   sdfsffsf",s->s.trim()));
        System.out.println(testFunction("sdffsw",s ->s.toUpperCase()));

        System.out.println(testPredicate(List.of("csd","fhjd","fghufe","ffei"),s->s.length()<5));

        System.out.println(testSupplier(5,()->(int)(Math.random()*(11-5+1)+5)));
    }
    //  消费型接口 Consumer<T>  有一个参数没有返回值
    public static void testConsumer(int money, Consumer<Integer> com){
        com.accept(money);
    }

    //函数型接口 Function<T,R>
    //R apply(T t)    有一个参数一个返回值
    //对于某个字符串进行某种行为的操作,得到结果
    public static String testFunction(String str, Function<String,String> fun){
      return   fun.apply(str);
    }

    //断言型接口 Predicate<T>
    //boolean test(T t)   一个参数一个boolean返回值
    // //对集合中的字符串数据做某种要求的过滤
      public static List<String> testPredicate(List<String> ls,Predicate<String> pr){
        List<String> list=new ArrayList<>();
          for (String s:ls) {
              if(pr.test(s)){
                  list.add(s);
              }
          }
          return list;
      }

    // 供给型接口 Supplier<T>
    //   T get()             没有参数一个返回值
    //生成n个随机数
    public static List<Integer> testSupplier(Integer num, Supplier<Integer> sup){
        List<Integer> lt=new ArrayList<>();
        for (int i=1;i<=num;i++){
            lt.add(sup.get());
        }
        return lt;
    }
}

二、Stream流

  2.1 Stream :
               数据的渠道,用来操作由数据源(数组,集合)产生元素序列
        数组|集合关注数据的存储,Stream关注的是对数据的计算
        可以对根据数据源锁产生的数据一系列式的流式计算

   2.2   特点:
        1.Stream本身不能存储数据
        2.Stream不会修改原对象|数据源中的数据,在每次进行流式操作后会返回一个持有结果的新的流
        3.惰性加载|延迟执行: 在进行stream操作时候不会马上执行,会在获取结果时一起执行
        4.流式一次性的流,流是不能重复使用,因为这个流已经被使用消费了

     2.3   创建流:
        1. Collection中的成员stream()
        2. Arrays.stream(数组)
        3.Stream.of(数据)

     2.4使用Stream的过程:
            1.获取流
            2.一系列流式的中间操作 (返回持有结果的新的流)
            3.终止行为(返回真实结果)

        中间操作 : 筛选与切片
                filter: 过滤
                limit：限制从流中获得前n个数据
                distinct：去重
                skip：跳过前n个数据