java 第19天

一.Lambda表达式

前提是：参数是函数式接口才可以书写Lambda表达式

函数式接口条件： 1.接口  2.只有一个抽象方法 

lambda表达式又称为匿名函数，允许匿名函数以参数的形式传入方法，简化代码

lambda表达式分为两部分()->{}

():要被覆盖的抽象方法的参数列表

如果参数只有一个的话()可以省略

{}：要被覆盖的抽象方法的方法体

如果方法体中只有一条语句{}和； 和 return省略

lambda中的return取决于抽象方法的返回类型

以下是关于lambda表达式的练习

（1.）TreeSet的一个构造方法可以使用 如下

TreeSet<>(Comparator接口 有一个抽象方法 compare(T x,T y)); 

		TreeSet<Integer> set = new TreeSet<>((x, old)->old - x);Collections.addAll(set,45,23,100,98);

(2).Collections.sort(list,Comparator) 也可以使用

		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)  根据名字长度升序并且拿到第一个元素

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是泛型自身的比较规则

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

		set.forEach((stu)->{stu.setAge(stu.getAge()+1);});

	set.forEach((temp)->{temp.setScore(temp.getScore()+5);});

所谓的forEach中的小括号就是拿出集合中每一个数据罢了，如果是学生集合，对应的拿出的就是单独一个学生

removeIf(Predicate):删除集合里面所有符合条件的元素 调用如下

单值集合对象.removeIf(  (x)->{return 条件判断;})

四大接口之一---断言型接口

接口:interface Predicate<T >{}

唯一的抽象方法: boolean test(泛型 x);

练习removeIf,符合条件的就删除了

		//删除20岁的Jackerset.removeIf((temp)->{return temp.getName().equals("Jacker")&&temp.getAge()==20;});

（3）.为map提供的方法

forEach(BiConsumer) 拿出集合中的每个对象进行某种操作

map.forEach((key,value)->{逻辑});

三.方法的引用

jdk8.0的新语法 对lambda表达式进行了进一步简化

之前

对象.实例方法()  

对象.静态方法()

类名.静态方法()

new 构造方法()

可以被一下替换

【对象::实例方法】

必须同时满足的两个条件

1 要被覆盖的抽象方法的参数列表和实例方法的参数列表一致

2 要被覆盖的抽象方法的返回类型和实例方法的返回类型一致

		// 抽象方法：void accept(Integer)// 实例方法：void println(Integer)list.forEach(System.out::println);// list.forEach((x)->System.out.println(x));

但是下面的不行

		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 要被覆盖的抽象方法的返回类型和实例方法的返回类型一致

		//抽象方法: 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 要被覆盖的抽象方法的返回类型和构造方法的返回类型一致

		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 空元素

        String str = "hello";Optional<String> op = Optional.ofNullable(str);System.out.println(op); 打印 helloString str = null;Optional<String> op = Optional.ofNullable(str);System.out.println(op);  打印Optional.empty

搭配上取 

orElse(类型 x) x => 如果Optional.empty 使用x

如果容器非空 直接返回容器中的内容

使用如下：

如果str为空则为 no value，不为空则为原来值

str = Optional.ofNullable(str).orElse("No Value");

orElseGet(Suppler<T> ss)

orElseGet (() -> { return xxx ;})

如果容器非空 直接返回容器中的内容

如果 Optional . empty 使用 x 调用匿名函数【 lambda 的版本】

区别： orElseGet 惰性执行

四大接口之一----供给型接口 只提供 不接收

接口： interface Supplier< 泛型 >{}

唯一的抽象方法：泛型 get()

        String str = null;str = Optional.ofNullable(str)// Optional<String>// 抽象方法：String get().orElseGet(()->"No Value");System.out.println(str);

类名::构造方法

		Student stu = null;stu = Optional.ofNullable(stu) // Optional<Student>// 构造方法：Student Student()// 抽象方法：Student get()// 参数列表一致// 返回类型一致// 构造方法::new// .orElseGet(()->new Student());.orElseGet(Student::new);System.out.println(stu);