java8新特性之Lambda表达式

一、Lambda 表达式的基础语法

java8中引入了一个新的操作符‘->’该操作符称为箭头操作符或lambda操作符，箭头操作符将Lambda表达式拆分成两部分

左侧：lambda表达式的参数列表
右侧：lambda表达式中所需执行的功能，即Lambda代码块

lambda表达式其实就是java的语法糖，最后运行的代码还会转换成平时的格式编译运行。只是写的格式较为简单。
//语法格式一
对于没有参数，没有返回值的函数式接口
什么是函数式接口？
接口中只有一个抽象方法称为函数式接口。可以使用注解@FunctionalInterface修饰，可以检查这个接口是否是函数式接口。

    @Test
    public void test1(){
        //首先是匿名内部类输出语句
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello Lambda!");
            }
        };

        runnable.run();
        System.out.println("----------------------");
        //lambda表达式输出
        Runnable r = () -> System.out.println("Hello Lambda!");

        r.run();
    }

可以看到使用lambda表达式代码简洁了不少

//语法格式二：只有一个参数，无返回值的方法,若只有一个参数，这个参数前后的（）可以省略

@Test
public void test2(){
    Consumer<String> consumer = (x)-> System.out.println(x);
    consumer.accept("study java program hardly");
}

//语法格式三：有多个参数，有返回值，并且lambda函数块中有多条语句

 @Test
    public void test3(){
        Comparator<Integer> comparator = (x,y)->{
            System.out.println("比较两个integer数的大小");
            return Integer.compare(x,y);
        };

        int i = comparator.compare(13, 17);
        System.out.println(i);
    }

//语法格式四：如果在多个参数的情况下有返回值且函数块中只有一条语句，那么return，{}都可以省略

    @Test
    public void test4(){
        Comparator<Integer> comparator = (x,y)-> Integer.compare(x,y);
    }

**//语法格式五：Lambda表达式的参数列表上的参数类型可以省略，
// 当省略后，JVM编译器通过上下文推断出数据类型，“类型推断”,当然如果加上的话所有参数都要添加类型**

    @Test
    public void test5(){
        Comparator<Integer> comparator = (Integer x,Integer y)-> Integer.compare(x,y);

    }

二、Java8四大核心函数式接口

Consumer: 消费型接口
方法： void accept(T t);

Supplier: 供给型接口
方法：T get();

Function<T,R>: 函数式接口
方法：R apply(T t); //返回值是R类型

Predicate: 断言型接口
方法：boolean test(T t);

1. 消费型接口Consumer

/**
     * 消费型接口测试
     */
    @Test
    public void test1() {

        happy(100, (m) -> System.out.println("消费：" + m + "元"));

    }

    public void happy(double money, Consumer<Double> consumer) {
        consumer.accept(money);
    }

供给型接口

/**
   * 供给型接口测试
   */
  @Test
  public void test2() {

      //随机产生10个0--100的随机数
      List<Integer> nums = getNums(10, () -> (int) (Math.random() * 100));
      for (Integer num : nums) {
          System.out.println(num);
      }
  }

  public List<Integer> getNums(int n, Supplier<Integer> supplier) {
      List<Integer> list = new ArrayList<>();

      for (int i = 0; i < n; i++) {
          Integer num = supplier.get();
          list.add(num);
      }


      return list;
  }

函数式接口

/**
     * 函数式接口测试
     */
    @Test
    public void test3() {

        String str = "			啦啦啦   ";
        String s1 = strHandler(str, (s) -> s.trim());//去掉字符串前后空格
        System.out.println(s1);
        String s2 = strHandler("ajhfdsa", (s) -> s.toUpperCase());//转大写
        System.out.println(s2);
    }


    //处理字符串
    public String strHandler(String str, Function<String, String> fun) {

        return fun.apply(str);
    }

断言式接口

/**
     * 断言型接口测试
     */
    @Test
    public void test4() {

        List<String> list = Arrays.asList("Hello", "test", "class", "happy", "functional");
        List<String> stringList = filterStr(list, (s) -> s.length() > 4);
        for (String s : stringList) {
            System.out.println(s);
        }

    }

    //将满足条件的字符串放入集合中返回
    public List<String> filterStr(List<String> list, Predicate<String> predicate) {
        List<String> stringList = new ArrayList<>();

        for (String s : list) {
            if (predicate.test(s)) {
                stringList.add(s);
            }
        }
        return stringList;
    }