今天我们学习了JDK1.8的新特性，lambda表达式，等待唤醒机制和线程池，请根据自己的理解回答下面问题：
1.等待唤醒机制存在的意义是什么？
2.调用wait()方法和notify()方法，需要注意什么？
3.使用线程池来操作线程有什么好处？
4.传统的面向对象编码有什么弊端？
5.什么情况下可以使用lambda表达式来替换面向对象编码？
6.什么情况下lambda表达式可以简写？

1.等待唤醒机制存在的意义是什么？
当我们需要多个线程共同完成一件任务，而不希望发生多线程共同操作一份数据，就可以借用等待唤醒机制来保证多线程之间有序进行通信，确保数据处理符合我们想要的。

2.调用wait()方法和notify()方法，需要注意什么？
1必须要使用它一把锁，这样它们之间才有一个共同的东西进行约束，就好像现实中的关锁和开锁一样。
2必须使用同一把锁对象去调用方法。类似于一把锁的开和关
3调用方法必须在同步代码块中。只有在这个范围内使用才有效。同步代码中放置要进行同步的资源。

3.使用线程池来操作线程有什么好处？
1对于CPU，可以节省资源，而不用每次都需要开启线程，创建线程池，用完再归还的资源浪费。
2对于用户可以提高响应速度，有更好的体验。
3对于程序员来说，提高线程的可管理性， 避免了每次都要创建和关闭线程，防止线程忘记关闭的资源浪费，开关线程上的操作。

4.传统的面向对象编码有什么弊端？
比如为了开启线程，要先创建一个类去继承thread类，重写方法，再创建对象，再调用方法。而我们的目的只是为了调用方法，却由于语法要求，不得不去去那么多操作。这样，就产生了一系列冗余代码。

5.什么情况下可以使用lambda表达式来替换面向对象编码？
函数式接口（只有一个抽象方法）时才能使用lambda表达式

6.什么情况下lambda表达式可以简写？
1如果方法体中只有一行语句，可以省略 { }  ； return。注意：要么全省，要么全不省
2（）中的参数类型可以不写，当只有一个参数类型时，（）可以省略不写

1.等待唤醒机制存在的意义是什么？
当多个线程需要操作同一个资源，且有规律的执行的时候。
2.调用wait()方法和notify()方法，需要注意什么？
多个线程必须使用同一个锁对象


wait方法和notify方法，调用的位置，是在同步代码块内


wait方法和notify方法，由锁对象调用

3.使用线程池来操作线程有什么好处？
减少资源消耗

用户，提高响应速度

，便于管理线程

4.传统的面向对象编码有什么弊端？
不得不编写实现类，不得不重写方法

，不得不创建对象

5.什么情况下可以使用lambda表达式来替换面向对象编码？
必须要有函数式接口

函数式接口：只有一个抽象方法的接口


必须要有接口的上下文关系

就是必须要有接口类型作为变量的类型，或者是参数列表的数据类型，接收的一定是一个接口的实现类

6.什么情况下lambda表达式可以简写？
1.可以省略小括号中的参数类型（int a,int b）->(a,b)
2.如果小括号中只有一个参数，那么小括号可以省略（int a）->{}      a->{}
3.如果lambda表达式中{}中只有一条语句，看分号。一个分号就是一条语句。可以省略 {}  ，renturn , ;


注意：三个要么一起省略，要不一起不省略，不能省略部分

1.等待唤醒机制存在的意义是什么？
有多个线程共同完成一件任务的时候，希望线程有规律的执行。
2.调用wait()方法和notify()方法，需要注意什么？
必须在同一个锁对象同步方法块里执行，
必须被同一个锁对象调用wait()方法和notify()方法。
必须在同步方法块里调用。

3.使用线程池来操作线程有什么好处？
1.降低资源消耗
2.提高响应速度
3.提高线程的管理性

4.传统的面向对象编码有什么弊端？
要编写实现类，要重新方法，还要创建对象，麻烦！

5.什么情况下可以使用lambda表达式来替换面向对象编码？
被实现的接口必须只要一个抽象方法，
必须一接口来接收实现对象

6.什么情况下lambda表达式可以简写？
（int a,int b）->{}

如果（）里面只有一个参数就可以省略（）；
如果（）里面有多个参数类型相同，就可以省略写参数类型。
如果{}里面就只有一句代码（就是只有一个分号），就可以省略{}，; ,和return。

1.等待唤醒机制存在的意义是什么？
有多个线程共同完成一件任务的时候，希望线程有规律的执行。
2.调用wait()方法和notify()方法，需要注意什么？
必须在同一个锁对象同步方法块里执行，
必须被同一个锁对象调用wait()方法和notify()方法。
必须在同步方法块里调用。

3.使用线程池来操作线程有什么好处？
1.降低资源消耗
2.提高响应速度
3.提高线程的管理性

4.传统的面向对象编码有什么弊端？
要编写实现类，要重新方法，还要创建对象，麻烦！

5.什么情况下可以使用lambda表达式来替换面向对象编码？
被实现的接口必须只要一个抽象方法，
必须一接口来接收实现对象

6.什么情况下lambda表达式可以简写？
（int a,int b）->{}

如果（）里面只有一个参数就可以省略（）；
如果（）里面有多个参数类型相同，就可以省略写参数类型。
如果{}里面就只有一句代码（就是只有一个分号），就可以省略{}，; ,和return。

1.等待唤醒机制存在的意义是什么？

①.当我们需要多个线程共同来完成一件任务

②,我们希望他们可以有规律的执行

2.调用wait()方法和notify()方法，需要注意什么？

        ①wait方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对 象调用的wait方法后的线程。

        ②wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继 承了Object类的。

        ③wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这2个方 法   



3.使用线程池来操作线程有什么好处？

        ①对cpu：降低了内存消耗；

        ②对程序员：方便管理线程；

        ③对用户：提高响应速度；

4.传统的面向对象编码有什么弊端？

       ①需要重写方法；

        ②需要新建对象；

        ③需要创建实现类；

5.什么情况下可以使用lambda表达式来替换面向对象编码？

   ①使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法   

   ②使用Lambda必须具有上下文推断。 也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能         使用Lambda作为该接口的实例。   

6.什么情况下lambda表达式可以简写？

    ①小括号内参数的类型可以省略；

    ②如果小括号内有且仅有一个参，则小括号可以省略；

    ③如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。

1.等待唤醒机制存在的意义是什么？
     多个线程去完成同一个任务时,一个线程在完成自己的工作后进入等待唤醒状态(wait()),然后等其他线程完成了指定的
代码后,然后唤醒此线程继续执行代码(notify()).
2.调用wait()方法和notify()方法，需要注意什么？
    1.需要使用同一个锁对象,只有使用了同一个锁对象的多个线程,才能使用对应的锁对象唤醒在等待状态的对象
    2.wait()方法和notify()方法,必须要在同步代码块中或者同步方法中使用.如果不在同步方法或者代码块中使用,那么就不能使用锁对象调用这两个方法
3.使用线程池来操作线程有什么好处？
    1.对于CPU来说,降低了资源的消耗,使用线程池减少了创建和销毁线程的次数.每个在线程池中的线程都能被重复利用
    2.对于用户来说,使用线程池可以提高响应速度,当有任务到达时,不需要等到线程创建,只要线程池中有空闲的线程,就可以直接使用线程池中的线程来完成任务
    3.对于程序员来说,使用线程池可以提高线程的管理性,可以根据系统的承受能力，调整线程中工作的线程的数目
4.传统的面向对象编码有什么弊端？
    1.为了实现一段代码不得不创建一个实现类
    2.我们不得不重写里面得方法，
    3.我们不得不创建对象最后才执行我们要执行我们的代码。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
    1.使用lambda表达式必须有接口，且接口中有且只有一个抽象方法。
    2.使用lambda表达式必须有上下文关系。
6.什么情况下lambda表达式可以简写？
     1.可以省略小括号中的参数类型。
     2.如果小括号中只有一个参数，那么可以省略小括号不写。
     3.如果lambda中的{}代码中只有一行代码，那么可以省略{}，return,  ; 这三个必需一起省略。不能只省略一个。

1.等待唤醒机制存在的意义是什么？ 多条线程有规律的完成自己手上的任务。 2.调用wait()方法和notify()方法，需要注意什么？ 多个线程必须使用同一个锁对象，wait方法和notify方法调用的位置，必须在同步代码块内，且都由锁对象调用。 3.使用线程池来操作线程有什么好处？ 减少cpu资源消耗，对用户来说提高响应速度，让程序员方便管理线程。 4.传统的面向对象编码有什么弊端？ 要编写实现类，重写方法和创建对象。 5.什么情况下可以使用lambda表达式来替换面向对象编码？ 必须是同一个抽象类接口，接口类型必须为变量或者是参数列表的数据类型，接收的一定是一个接口的实现类。 6.什么情况下lambda表达式可以简写？ 可以根据上下文推导得知的信息，lambda表达式可以简写。 1. 小括号内参数的类型可以省略； 2. 如果小括号内有且仅有一个参，则小括号可以省略； 3. 如果大括号内有且仅有一个语句 。

1.等待唤醒机制存在的意义是什么？
答：存在的意义是多个线程同时共享一个资源的时候，可以让这多个线程有规律的执行这一个资源

2.调用wait()方法和notify()方法，需要注意什么？
答：多个线程的锁对象需要用同一个锁对象，wait（）方法和notify（）要放在同一个代码块中，wait()方法和notify()方法由锁对象调用

3.使用线程池来操作线程有什么好处？
答：因为每次创建线程需要耗费很多资源，创建线程池可以在使用线程的时候葱线程池里拿，会提高代码的效率。

4.传统的面向对象编码有什么弊端？
答：想要调用方法实现最终的目的不得不创建对象，不得不编写实现类，会很麻烦

5.什么情况下可以使用lambda表达式来替换面向对象编码？
答：必须要有函数式接口，函数式接口：只有一个抽象方法的接口
必须要有接口的上下文关系，就是必须要有接口类型作为变量的类型，或者是参数列表的数据类型，接收的一定是一个接口的实现类

6.什么情况下lambda表达式可以简写？
答：小括号内的参数类型可以省略，当小括号里有一个参数的时候，小括号可以省略，当大括号里只有一条输出语句的时候，那么大括号，分号，和return都可以省略。

1.实现线程间的通信，使线程间形成相互协作的关系。
2.调用wait()方法和notify()方法需要在同步代码块中；调用wait()方法和notify()方法需要使用同一个锁对象。wait()方法和notify()方法是属于Object类的。
3.节省计算机性能，不需要频繁的创建线程；提高响应速度，任务不需要等线程创建；便于管理，可以更加灵活管理线程的数量。
4.面向对象编码做一件事情,找一个能解决这个事情的对象,调用对象的方法,完成事情。在这个过程中，需要频繁的创建类，重写方法，创建对象，或者使用匿名对象，匿名内部类，语法太过复杂。
5.当接口为函数式接口，即接口中只有一个抽象方法；必须要有接口类型作为变量的类型，或者是参数列表的数据类型，接收的一定是一个接口的实现类。
6.函数式接口只有一行代码时，lambda表达式可以简写。

1.等待唤醒机制存在的意义是什么？当多个线程之间需要互相协作去操作同一个资源的时候,等待唤醒机制的存在就可以使得这些线程在合作的时候有规律的执行而不会出现因为争抢CPU的执行权从而出问题的事情发生。2.调用wait()方法和notify()方法，需要注意什么？
需要注意三点：1、多个线程必须使用同一个锁对象
                        2、两种方法均由锁对象调用
                        3、两种方法的调用位置都要在同步代码块、同步方法或者Lock锁方法中。

3.使用线程池来操作线程有什么好处？对于cpu来说可以减少资源消耗；对于用户来说可以提高应用的响应速度；对于程序员来说方便对线程的管理。

4.传统的面向对象编码有什么弊端？
为了实现一个简单的功能需要去编写实现类然后还要创建对象还需要重写方法。过程很繁琐，代码冗余。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
这需要满足两个条件：1、接口是函数型接口，只有一个抽象类方法。2、要有接口类型作为变量的类型或者是参数列表的数据类型，接收的一定是一个接口的实现类，就是必须要有接口的上下文关系。
6.什么情况下lambda表达式可以简写？

1.可以省略小括号中的参数类型（int a,int b）->(a,b)

2.如果小括号中只有一个参数，那么小括号可以省略（int a）->{}      a->{}

3.如果lambda表达式中{}中只有一条语句，看分号。一个分号就是一条语句。可以省略 {}  ，renturn , 这三个要么一起省略要么都不省略。

1.等待唤醒机制存在的意义是什么？
当多个线程共同操作同一个资源，并需要有规律执行时可以使用等待唤醒机制

2.调用wait()方法和notify()方法，需要注意什么？
(1)多个线程的锁对象必须时同一个
(2)wait()方法和notify()方法调用时要在同步代码块中
(3)wait()方法和notify()方法由锁对象调用

3.使用线程池来操作线程有什么好处？
(1)对于用户来说，提高响应速度
(2)对于CPU来说，提高运行效率
(3)对于程序员来说，方便管理

4.传统的面向对象编码有什么弊端？
(1)不得不编写实现类
(2)不得不重写run()方法
(3)不得不创建对象

5.什么情况下可以使用lambda表达式来替换面向对象编码？
(1)必须要有函数式接口
函数式接口：只有一个抽象方法的接口
(2)必须要有接口的上下文关系
就是必须要有接口类型作为变量的类型，或者是参数列表的数据类型，接收的一定是一个接口的实现类

6.什么情况下lambda表达式可以简写？
(1)可以省略小括号中的参数类型（int a,int b）->(a,b)
(2)如果小括号中只有一个参数，那么小括号可以省略（int a）->{}      a->{}
(3)如果lambda表达式中{}中只有一条语句，看分号；一个分号就是一条语句。可以省略 {}  ，renturn , 分号；
注意：三个要么一起省略，要不一起不省略，不能省略部分

1.等待唤醒机制存在的意义是什么？
当多个线程需要操作同一个资源，且有规律的执行的时候,可以采用等待唤醒机制，实现线程之间的通信，让多个线程相互协作。

2.调用wait()方法和notify()方法，需要注意什么？
a.多个线程必须要使用同一个锁对象；
b.wait()方法和notify()方法的调用位置必须是在同步代码快内，或者是同步函数内；
c.必须由同一个锁对象来调用这两个方法。

3.使用线程池来操作线程有什么好处？
a.可以节省系统资源。频繁的建立销毁线程对于系统资源的耗费非常严重，因此采用线程池来操作线程能够降低资源的消耗；
b.可以提高程序响应的速度。当有任务到达时，可以直接分配线程池的线程，而不用耗费时间新建线程；
c.可以提高线程的管理水平。可以根据系统的承受能力，灵活调整线程池中工作线线程的数目。

4.传统的面向对象编码有什么弊端？
面向对象讲究一切从对象出发。面对一个需求，考虑的是建立或者找到能实现该需求的类和方法，而这种思考方式有时候会让问题变得复杂，有时候仅仅需要实现一个小功能，一个简单的方法即可满足，但是却要建立类，建立对象，再由对象调用方法去实现，显得冗余。

5.什么情况下可以使用lambda表达式来替换面向对象编码？
满足以下两个条件时可以用lambda表达式来替换面向对象编码：
a.必须要有函数式接口,即只有一个抽象方法的接口
b.必须要有接口的上下文关系，即要有接口类型作为变量的类型，或者是参数列表的数据类型，接收的一定是一个接口的实现类

6.什么情况下lambda表达式可以简写？
a.可以省略小括号中的参数类型（int a,int b）简写为(a,b)
b.如果小括号中只有一个参数，那么小括号可以省略（int a）->{}简写为a->{}
c.如果lambda表达式中{}中只有一条语句，看分号。一个分号就是一条语句。可以省略“{}” 、“renturn”和“,”;需要注意的是：这三者要么都省略，要么都不省略。

1.等待唤醒机制存在的意义是什么？目的是为了解决程序安全问题，让程序之间协调的运作
2.调用wait()方法和notify()方法，需要注意什么？
1、使用同一个锁对象
2、是否在同步代码块中调用
3、必须使用同一个锁对象调用方法
3.使用线程池来操作线程有什么好处？
1、降低资源消耗
2、提高响应速度
3、提高线程的可管理性
4.传统的面向对象编码有什么弊端？

• 我们必须编写一个实现类
• 必须重写接口中的方法
• 必须创建对象，调用方法
  
  

5.什么情况下可以使用lambda表达式来替换面向对象编码？
1、重写的接口必须是函数式接口，就是只含一个抽象方法
2、必须有接口的上下文关系，
6.什么情况下lambda表达式可以简写？

1、括号中参数列表的数据类型可以不写
2、括号中如果参数列表中参数只有一个，那么可以只写参数省略数据类型和（）
3、如果{}中只有一个分号的代码，无论是否有返回值都可以省略{}、return、；但是这些必须同时省略，缺一不可

今天我们学习了JDK1.8的新特性，lambda表达式，等待唤醒机制和线程池，请根据自己的理解回答下面问题：
1.等待唤醒机制存在的意义是什么？
答：等待唤醒机制的意义是，能够实现可以控制的有规律的线程开关。使得线程之间通信得以实现，各个线程相互协作。

2.调用wait()方法和notify()方法，需要注意什么？
答：不同的线程要有同一个锁对象，wait方法和notify方法要写在同步代码块内，调用这两个方法要通过锁对象调用。

3.使用线程池来操作线程有什么好处？
答：线程池是装线程的容器，是一种集合。使用线程池对于使用程序的用户来说：提高了响应速度（减少了创建线程的时间）。对于cpu来说，避免了不必要的资源消耗（频繁创建线程会浪费资源） 。对于程序员而言，线程池会更加方便管理不同的线程。

4.传统的面向对象编码有什么弊端？
答：由于受制于java语言，对于处理一个事情，需要频繁的创建对象或者创建实现类和子类。代码量较多。

5.什么情况下可以使用lambda表达式来替换面向对象编码？
答：两个前提：1.必须是有函数式接口（该接口只有一个抽象方法）2.必须要有接口上下关系。接口类型作为变量的类型，或者是参数列表的数据类型，该位置一定是接收到一个接口的实现类对象。

6.什么情况下lambda表达式可以简写？
答：可推断，可省略
1.方法的参数列表内参数的参数类型一致，参数类型可以省略。如果参数列表只有一个参数，参数列表和参数列表的小括号都可以省略。
2.方法体的内容如果只有一句代码，那么return，；，{}都可以同时省略，注意是同时省略。（只是省略其中一项，会报错）

1.等待唤醒机制存在的意义是什么？ 答：解决线程安全问题，让线程在共享资源有规律执行！ 2.调用wait()方法和notify()方法，需要注意什么？ 答：wait方法和notify方法，调用的位置，是在同步的代码块内；wait方法和notify的方法由锁对象调用 多个线程必须使用同一个锁对象 3.使用线程池来操作线程有什么好处？ 答：cpu会减少资源消耗，用户提高响应速度，也便于程序员管理线程 4.传统的面向对象编码有什么弊端？ 答：非常消耗内存资源 5.什么情况下可以使用lambda表达式来替换面向对象编码？ 答：必须要有函数接口；函数接口只有一个抽象方法的接口；必须要有接口的上下文关系； 6.什么情况下lambda表达式可以简写？ 答：可以省略小括号中的的参数类型；如果小括号只有一个参数，那么小括号可以省略； 如果lambda表达式大括号中只有一条语句，看分号、一个分号就是一条语句。可以省略 大括号和runturn。

1.等待唤醒机制存在的意义是什么？
为了各个线程之间互相协作，有规律的执行各自的线程任务。

2.调用wait()方法和notify()方法，需要注意什么？
A，wait()，notify()必须写在同步代码块内部；B，需要同一个锁对象去调用；C，使用同一个锁对象作为代码块的锁对象。

3.使用线程池来操作线程有什么好处？
A线程池可以减少程序资源的消耗B,提高对线程的管理C，提高响应速度。

4.传统的面向对象编码有什么弊端？
传统的面对对象编码首先需要编写一个类，再创建一个类对象，再调用类中的各个变量方法，程序繁杂，代码繁多，编写麻烦。

5.什么情况下可以使用lambda表达式来替换面向对象编码？
A，需要有一个函数式接口（只包含有一个抽象方法的接口）
2.必须有接口的上下文表达式（就是必须要有接口类型作为变量的类型，或者是参数列表的数据类型，接收的一定是一个接口的实现类）

6.什么情况下lambda表达式可以简写？

1.可以省略小括号中的参数类型（int a,int b）->(a,b)
2.如果小括号中只有一个参数，那么小括号可以省略（int a）->{}      a->{}
3.如果lambda表达式中{}中只有一条语句，看分号。一个分号就是一条语句。可以省略 {}  ，renturn , ;
注意：三个要么一起省略，要不一起不省略，不能省略部分

1.等待唤醒机制存在的意义是什么？ 答：等待唤醒机制就是是多个线程间的一种协作机制，能够让线程在操作同一个资源时具有规律。

2.调用wait()方法和notify()方法，需要注意什么？
答：1.多个线程必须使用同一个锁对象。

2.wait方法和notify方法，调用的位置，是在同步代码块内。

3.wait方法和notify方法，由锁对象调用。

3.使用线程池来操作线程有什么好处？
答：减少资源消耗，提高响应速度，便于管理线程。


4.传统的面向对象编码有什么弊端？
答：不得不编写实现类，不得不重写方法，不得不创建对象。


5.什么情况下可以使用lambda表达式来替换面向对象编码？
答：只有一个抽象方法的接口，必须要有接口类型作为变量的类型，或者是参数列表的数据类型，接收的一定是一个接口的实现类。


6.什么情况下lambda表达式可以简写？

答：1.小括号内参数的类型可以省略。
2.如果小括号中只有一个参数，那么小括号可以省略。
3.如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号（要么同时省略要么都不省略，不能部分省略）。

1.等待唤醒机制存在的意义是什么？
使多个有协作关系的线程能按照指定顺序执行任务

2.调用wait()方法和notify()方法，需要注意什么？
1.多个线程必须使用同一个锁对象。
2.要在同步代码块中调用
3.必须由锁对象调用

3.使用线程池来操作线程有什么好处？
优点：1、对于cpu:降低资源消耗； 2、对于用户：提高响应速度；   3、对于程序员：便于管理线程。

4.传统的面向对象编码有什么弊端？
不得不编写实现类，不得不重写方法，不得不创建对象

5.什么情况下可以使用lambda表达式来替换面向对象编码？
1、重写方法的接口必须是函数式接口（只包含一个抽象方法）
2、必须由接口的上下文关系（必须由接口类型来接受实现类对象）

6.什么情况下lambda表达式可以简写？
1、参数列表中的数据类型
2、如果（）中只有一个参数，那么数据类型和（）都可以省略
3、如果方法体只有一行，那么可以同时省略{}、return、“；”。

1.等待唤醒机制存在的意义是什么？

意义：java是单线程并发运行，线程执行顺序随机。通过唤醒机制可以控制线程的执行流程。
        即，在多个共用资源的线程中，我们希望控制他们的执行规律。

2.调用wait()方法和notify()方法，需要注意什么？

注意：  （1）wait()和notify()方法需要在同步代码块中执行
        （2）需要同一个锁对象。
        （3）通过锁对象来调用wait()和notify()方法。
3.使用线程池来操作线程有什么好处？

好处：  （1）节省内存资源。（系统方面）
        （2）提高响应速度（用户方面）
        （3）方便管理多个线程。（程序员）

4.传统的面向对象编码有什么弊端？

弊端：  （1）必须编写实现类（2）必须重写方法        （3）必须创建对象
        即，操作固定重复冗长，占用大量资源。


5.什么情况下可以使用lambda表达式来替换面向对象编码？

使用前提：（1）必须是函数式接口：有且只有一个抽象方法的接口。因为多个方法系统无法辨别省略是哪个方法省略。
        （2）必须有实现类接收，因为接口本身不能创建对象。
        （3）在程序中必须有上下关系，因为系统需要推导省略的依据。

6.什么情况下lambda表达式可以简写？

原则：可推导->可省略
（1）可以省略小括号中的参数类型（int a,int b）->(a,b)


（2）如果小括号中只有一个参数，那么小括号可以省略（int a）->{}      a->{}


（3）如果lambda表达式中{}中只有一条语句，看分号。一个分号就是一条语句。可以省略 {}  ，renturn , ;

     注意：三个要么一起省略，要不一起不省略，不能省略部分