java8新特性学习笔记（Lambda，stream()，filter()，collect()，map()）

1.lambda表达式（重点）

1.需求分析

创建一个新的线程，指定线程要执行的任务

public static void main(String[] args) {
    //开启一个线程
    new Thread(new Runnable() {
      @Override
      public void run() {
        System.out.println("新线程中执行的代码:"+Thread.currentThread().getName());
      }
    }).start();
    System.out.println("主线程中的代码:"+Thread.currentThread().getName());
  }

代码分析：
1.Thread类需要一个Runnable接口作为参数，其中的抽象方法run方法是用来指定线程任务内容的核心
2.为了指定run方法体，不得不需要Runnable的实现类
3.为了省去定义一个Ruunnable的实现类，不得不是使用匿名内部类
4.必须覆盖重写抽象的run方法，所有的发的方法名称，方法参数，方法返回值不得不重写一遍
5.而实际上，我们只在乎方法体的代码

2.Lambda表达式初体验

 new Thread(() -> { System.out.println("新线程Lambda表达式"+ Thread.currentThread().getName());})
                     .start();

Lambda表达式的优点 ：简化了匿名内部类的使用，语法更加简单，
匿名内部类的语法冗余，体验了Lambda表达式后发现Lambda表达式是简化匿名内部类的一种方式。

3.Lambda的语法规则

Lambda省去了面向对象的条条框框 lamabda的标准格式由3个部分组成

(参数类型 参数名称) -> {

}
格式说明：
(参数类型 参数名称):参数列表
{代码体}:方法体
->:箭头，分割参数与列表和方法体

3.1 Lambda练习1

练习无参无返回值的Lambda

public interface UserService {
  void goShow();
}

然后创建主方法使用

public class Demo02Lambda {
  public static void main(String[] args) {

    goShow(new UserService() {
      @Override
      public void goShow() {
        System.out.println("show 方法执行了");
      }
    });
    System.out.println("-------------");

    goShow(() -> {
      System.out.println("Lambda Show 方法执行了");
    });
  }
  public static void goShow(UserService userService){
    userService.goShow();
  }
}

输出：

show 方法执行了
-------------
Lambda Show 方法执行了

3.1 Lambda练习2

完成一个有参且有返回值的Lambda表达式

创建一个parson对象

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Parson {
  private String name;

  private int age;
}

在list中保存多个parson对象，然后对这些对象做根据age排序的操作

ublic class Demo03Lambda {
  public static void main(String[] args) {

    List<Parson> list = new ArrayList<>();
    list.add(new Parson("zhou",33));
    list.add(new Parson("zhang",44));
    list.add(new Parson("chen",55));

    Collections.sort(list, new Comparator<Parson>() {
      @Override
      public int compare(Parson o1, Parson o2) {
        return o1.getAge()-o2.getAge();
      }
    });
    for (Parson parson : list){
      System.out.println(parson);
    }
    System.out.println("----------------");

    Collections.sort(list, (Parson o1 ,Parson o2) -> {
      return o1.getAge() - o2.getAge();
    });
    for (Parson parson :list){
      System.out.println(parson);
    }
  }
}

输出结果

Parson(name=zhou, age=33)
Parson(name=zhang, age=44)
Parson(name=chen, age=55)
----------------
Parson(name=zhou, age=33)
Parson(name=zhang, age=44)
Parson(name=chen, age=55)

4.Lambda表达式的原理

匿名内部类在编译的时候会产生一个class文件
Lamabda表达式在程序运行的时候会形成一格类
1.在类中新增了一个方法，这个方法的方法体就是Lambda表达式中的代码
2.还会形成一个匿名内部类，实现接口 ，重写抽象方法
3.在接口中重写方法会调用新生成的方法

5.Lambda表达式的省略写法

在Lambda表达式的标准写法基础上，可以使用省略写法的规则为：
1.小阔号内的参数类型可以省略
2.如果小括号内有且仅有一个参数，则小括号可以省略
3.如果大括号内有且仅有一个语句 可以同时省略大括号retrn关键字及语句分号

6.Lambda表达式的使用前提

Lambda表达式的语法是非常简洁的 但是Lambda表达式不是随便用的，使用时有几个条件要特别注意
1.方法的参数或局部变量类型必须为借口才能是引用Lambda
2.接口与中有且仅有一个抽象方法（@Functionallnterface）

7.Lambdah和匿名内部类的对比

Lambda和匿名内部类的对比
1.所需类型不一样

   1.匿名内部类的类可以是类，抽象类，接口
   2.Lambda表达式需要的类型必须是接口

2.抽象方法的数量不一样

1.匿名内部类所需的接口中的抽象方法的数量是随意的
2.Lambda表达式所需要的接口中只能有一个抽象方法

3.实现原理不一样

1.匿名内部类实在编译后形成一个class
2.Lambda表达式实在程序运行的时候动态生成class

三 stream

1.filter

stream 方法获取指向当前的Collectiond对象的流对象，filter将对流中的元素进行过滤，结合lambda表达式，需要在filter参数中实现一个类似于比较器的predicate对象，返回一个Boolean类型的返回值，只有在返回为true的Collection中的元素才会进入到forEach的循环中

 /**
     * java8新特性，stream方法的filter
     * filter 通过设置的条件过滤元素
     *
     * @param number
     * @return result
     */
    @GetMapping("/filter")
    public List<String> newFeature(String number){
        List<String> result = strArr.stream().filter(str -> !number.equals(str)&&
                !str.equals("")).collect(Collectors.toList());//去除输入的变量返回list
        return  result;
    }

2.map

stream.map()类似于迭代器，结合lambda表达式实现自己的功能，对对象中的某个属性进行提取，或者对对象中的元素进行处理

/**
     * java8新特性，stream方法的map
     * map 对对象中的某个属性进行提取,或对对象中的元素进行处理
     *
     * @param
     * @return names
     */
    @GetMapping("/map")
    public List<String> newFeature(){
        List<TesUser> users = testService.getAll();
        List<String> names = users.stream().map(e -> e.getName()).collect(Collectors.toList());//只返回对象的名字属性
        return names;
    }