java 第19天 Lambda、jdk8.0新方法、Optional

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

		// 抽象方法：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); 打印 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，不为空则为原来值

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);