学习笔记（Lambda，stream()，filter()，collect()，map()）"/>

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

文章目录

• 1.lambda表达式（重点）
• • 1.需求分析
  • 2.Lambda表达式初体验
  • 3.Lambda的语法规则
  • 3.1 Lambda练习1
  • 3.1 Lambda练习2
  • 4.Lambda表达式的原理
  • 5.Lambda表达式的省略写法
  • 6.Lambda表达式的使用前提
  • 7.Lambdah和匿名内部类的对比
• 三 stream
• • 1.filter
  • 2.map

1.lambda表达式（重点）

1.需求分析

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

public static void main(String[] args) {//开启一个线程new Thread(new Runnable() {@Overridepublic 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() {@Overridepublic 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>() {@Overridepublic 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());//去除输入的变量返回listreturn  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;}