一.Lambda表达式
前提是：参数是函数式接口才可以书写Lambda表达式
函数式接口条件： 1.接口 2.只有一个抽象方法
lambda表达式又称为匿名函数，允许匿名函数以参数的形式传入方法，简化代码
lambda表达式分为两部分()->{}
():要被覆盖的抽象方法的参数列表
如果参数只有一个的话()可以省略
{}：要被覆盖的抽象方法的方法体
如果方法体中只有一条语句{}和； 和 return省略
lambda中的return取决于抽象方法的返回类型
以下是关于lambda表达式的练习
（1.）TreeSet的一个构造方法可以使用 如下
TreeSet<>(Comparator接口 有一个抽象方法 compare(T x,T y));
java
TreeSet<Integer> set = new TreeSet<>((x, old)->old - x);
Collections.addAll(set,45,23,100,98);(2).Collections.sort(list,Comparator) 也可以使用
java
ArrayList<Integer> list=new ArrayList<>();
Collections.addAll(list,45,23,100,98);
//对list按照个位数升序
/*Collections.sort(list,(n,old)->{
return n%10-old%10;
});*/
Collections.sort(list,(n,old)->n%10-old%10);（3）Collections.min(list,Comparator) 根据名字长度升序并且拿到第一个元素
java
Student stu=Collections.min(set,(n,old)->{return n.getName().length()-old.getName().length();});
Student stu=Collections.min(set,(n,old)-> n.getName().length()-old.getName().length());
System.out.println(stu);二.JDK8.0 新方法
（1.）对于list集合的
list.sort(Comparator<>); 可在比较器中设置比较规则 也可用lambda表达式 如下
其中里面的x.compareTo是泛型自身的比较规则
java
list.sort((x,y)->{return x.compareTo(y);});总结对list的排序
List 去排序
Collections . sort ( List )
Collections . sort ( List , Comparator )
list . sort ( Comparator )
TreeSet set = new TreeSet ( List 对象 );
（2）为Collection提供
forEach(Consumer):
单值集合对象 . forEach (( x ) -> { 逻辑 });
引入了四大接口之一的-----------消费型接口 只会进去 不会出来返回类型void
接口：interface Consumer<泛型>()
唯一的抽象方法: void accept(泛型 x);
使用如下：
获取学生的年龄 并且加1
java
set.forEach((stu)->{
stu.setAge(stu.getAge()+1);
});
java
set.forEach((temp)->{
temp.setScore(temp.getScore()+5);
});所谓的forEach中的小括号就是拿出集合中每一个数据罢了，如果是学生集合，对应的拿出的就是单独一个学生
removeIf(Predicate):删除集合里面所有符合条件的元素 调用如下
单值集合对象.removeIf( (x)->{return 条件判断;})
四大接口之一---断言型接口
接口:interface Predicate<T >{}
唯一的抽象方法: boolean test(泛型 x);
练习removeIf,符合条件的就删除了
javascript
//删除20岁的Jacker
set.removeIf((temp)->{
return temp.getName().equals("Jacker")&&temp.getAge()==20;
});（3）.为map提供的方法
forEach(BiConsumer) 拿出集合中的每个对象进行某种操作
map.forEach((key,value)->{逻辑});
三.方法的引用
jdk8.0的新语法 对lambda表达式进行了进一步简化
之前
对象.实例方法()
对象.静态方法()
类名.静态方法()
new 构造方法()
可以被一下替换
【对象::实例方法】
必须同时满足的两个条件
1 要被覆盖的抽象方法的参数列表和实例方法的参数列表一致
2 要被覆盖的抽象方法的返回类型和实例方法的返回类型一致
java
// 抽象方法：void accept(Integer)
// 实例方法：void println(Integer)
list.forEach(System.out::println);
// list.forEach((x)->System.out.println(x));但是下面的不行
java
Map<String,Integer> map = new HashMap<>();
map.put("黄一亿",59);
map.put("可可可",59);
// 1 要被覆盖的抽象方法的参数列表和实例方法的参数列表一致
// 2 要被覆盖的抽象方法的返回类型和实例方法的返回类型一致
// 抽象方法：void accept(String,Integer)
// 实例方法：void println(String)
// 1 X 2 √
map.forEach((k,v)->System.out.println(k+v));【类名::实例方法】
必须同时满足的三个条件
1 要被覆盖的抽象方法的参数列表比实例方法的参数列表多一个
2 要被覆盖的抽象方法的第一个参数可以调用实例方法
3 要被覆盖的抽象方法的返回类型和实例方法的返回类型一致
java
//抽象方法: int compare(Student x,Student y)
//实例方法； int compareTo(Student y)
//11.抽象方法的参数比实例方法多一个
//22.抽象方法的第一个 参数可以调用---升序可以 降序不OK
//33.抽象方法的返回类型和实例方法的返回类型一致
//1 √ 2 √ 3.√
list.sort((x,y)->{return x.compareTo(y);});
list.sort(Student::compareTo);类名::静态方法
【构造方法::new】
1 要被覆盖的抽象方法的参数列表和构造方法的参数列表一致
2 要被覆盖的抽象方法的返回类型和构造方法的返回类型一致
java
Student stu = null;
stu = Optional.ofNullable(stu) // Optional<Student>
// 构造方法：Student Student()
// 抽象方法：Student get()
// 参数列表一致
// 返回类型一致
// 构造方法::new
// .orElseGet(()->new Student());
.orElseGet(Student::new);
System.out.println(stu);四.Optional****容器类
jdk8.0之后出现的致力于解决空指针问题
首先认识of（元素）---认识不掌握 不好用一点都不好
of( 元素 )
如果元素非空 直接返回包含元素的 Optional 对象
如果元素是 null 直接空指针
get()--------------------------------垃圾 不掌握
如果容器不是空容器 取出容器中的元素
如果容器是空容器 Optional.empty 直接报错【 NoSuchElementException 】
【结合 isPresent() 使用】
【 isPresent() 不是空容器 -true Optional.empty-false 】
ifPresent ( Consumer )
如果容器非空 会调用匿名函数
如果容器时 Optional . empty 不执行匿名函数
对于元素的放用ofNullable---以下掌握
ofNullable( 元素 )
如果元素非空 直接返回包含元素的 Optional 对象
如果元素为空 直接返回 Optional.empty 空元素
java
String str = "hello";
Optional<String> op = Optional.ofNullable(str);
System.out.println(op); 打印 hello
String str = null;
Optional<String> op = Optional.ofNullable(str);
System.out.println(op); 打印Optional.empty搭配上取
orElse(类型 x) x => 如果Optional.empty 使用x
如果容器非空 直接返回容器中的内容
使用如下：
如果str为空则为 no value，不为空则为原来值
java
str = Optional.ofNullable(str).orElse("No Value");orElseGet(Suppler<T> ss)
orElseGet (() -> { return xxx ;})
如果容器非空 直接返回容器中的内容
如果 Optional . empty 使用 x 调用匿名函数【 lambda 的版本】
区别： orElseGet 惰性执行
四大接口之一----供给型接口 只提供 不接收
接口： interface Supplier< 泛型 >{}
唯一的抽象方法：泛型 get()
java
String str = null;
str = Optional.ofNullable(str)// Optional<String>
// 抽象方法：String get()
.orElseGet(()->"No Value");
System.out.println(str);类名::构造方法
java
Student stu = null;
stu = Optional.ofNullable(stu) // Optional<Student>
// 构造方法：Student Student()
// 抽象方法：Student get()
// 参数列表一致
// 返回类型一致
// 构造方法::new
// .orElseGet(()->new Student());
.orElseGet(Student::new);
System.out.println(stu);