JDK1.8新特性(一) ----Lambda表达式、Stream API、函数式接口、方法引用_lambda表达式、函数式接口、stream api、新时间日期api、*方法引用和构造器调用、

//3.终止操作
/**
* 查找和匹配
* allMatch-检查是否匹配所有元素
* anyMatch-检查是否至少匹配一个元素
* noneMatch-检查是否没有匹配所有元素
* findFirst-返回第一个元素
* findAny-返回当前流中的任意元素
* count-返回流中元素的总个数
* max-返回流中最大值
* min-返回流中最小值
*/
//3.1：allMatch检查是否匹配所有元素是否都成立，都成立返回true 否则返回false
Stream<Map<String, Object>> stream2 = maps.stream();
boolean a = stream2.allMatch(x -> Integer.valueOf(x.get("age").toString()) > 16);
System.err.println("结果："+a); //false
//3.2：anyMatch检查是否至少匹配一个元素，只要有一个成立就返回true
Stream<Map<String, Object>> stream3 = maps.stream();
boolean b = stream3.anyMatch(x -> Integer.valueOf(x.get("age").toString()) > 16);
System.err.println("结果："+b); //true
//3.3：noneMatch检查是否没有匹配所有元素，因为有成立的所以有匹配的元素，估 不成立
Stream<Map<String, Object>> stream4 = maps.stream();
boolean c = stream4.noneMatch(x -> Integer.valueOf(x.get("age").toString()) > 16);
System.err.println("结果："+c); //false
//3.4:findFirst返回第一个元素,按照年龄从小到大排序返回第一个元素
Stream<Map<String, Object>> stream5 = maps.stream();
Map<String, Object> first = stream5.sorted((x,y) -> Integer.compare(Integer.valueOf(x.get("age")
.toString()),Integer.valueOf(y.get("age").toString()))).findFirst().get();
System.err.println(first.toString());//{sex=女, name=小红, age=16}
//3.5：findAny-返回当前流中的任意元素
Stream<Map<String, Object>> stream6 = maps.stream();
Map<String, Object> map = stream6.sorted((x,y) -> Integer.compare(Integer.valueOf(y.get("age")
.toString()),Integer.valueOf(x.get("age").toString()))).findAny().get();
//多次测试返回固定是这个，感觉因该是内部有一个算法排序然后返回其中固定某个 {sex=男, name=小明, age=18}
//排序之后返回的永远是第一个
System.err.println(map.toString());
//3.6：返回流中元素的总个数
Stream<Map<String, Object>> stream7 = maps.stream();
long count = stream7.count();
System.err.println("长度为："+count); // 长度为：3
//TODO 最大最小就不测试了，自己可以试试

/**
* collect操作：Collect-将流转换为其他形式，
* 接收一个Collection接口的实现，用于给Stream中元素做汇总的方法
* Collectors.toList()/toSet()
*/
Set<Integer> ageList = list.stream().collect(Collectors.toSet());
ageList.stream().forEach(System.out::println);
//取名字，封装成hashset
HashSet<Integer> hs = list.stream()
.collect(Collectors.toCollection(HashSet::new));
System.err.println(hs.toString());

函数式接口：

/**
* @MethodName: functionInterface
* @Description: 四大函数式接口练习
* @param
* @return
* @author rongrong
* @date 2019-12-23
*/
public void functionInterface(){
/**
* 1.Consumer 《T》：消费型接口，有参无返回值
* 打印：
* 222222
* hello
*/
changeStr("hello",(str) -> System.err.println(str));
 
/**
* 2.Supplier 《T》：供给型接口，无参有返回值
* 打印：
* 111111
* str
*/
String value = getValue(() -> "str");
System.err.println(value);
 
/**
* 3. Function 《T,R》：:函数式接口，有参有返回值
* 打印：
* 333333
* 20000
*/
Long aLong = changeNum(100L, x -> x * 200);
System.err.println(aLong);
/**
* Predicate《T》： 断言型接口，有参有返回值，返回值是boolean类型
* 打印：
* true
*/
boolean rongrong = changeBoolean("rongrong", x -> x.equals("rongrong"));
System.err.println(rongrong);
 
}
 
/**
* Consumer<T> 消费型接口
* @param str
* @param con
*/
public void changeStr(String str, Consumer<String> con){
System.err.println("222222");
con.accept(str);
}
 
/**
* Supplier<T> 供给型接口
* @param sup
* @return
*/
public String getValue(Supplier<String> sup){
System.err.println("111111");
return sup.get();
}
 
/**
* Function<T,R> 函数式接口
* @param num
* @param fun
* @return
*/
public Long changeNum(Long num, Function<Long, Long> fun){
System.err.println("333333");
return fun.apply(num);
}
 
/**
* Predicate<T> 断言型接口
* @param str
* @param pre
* @return
*/
public boolean changeBoolean(String str, Predicate<String> pre){
return pre.test(str);
}

在四大核心函数式接口基础上，还提供了诸如BiFunction、BinaryOperation、toIntFunction等扩展的函数式接口，都是在这四种函数式接口上扩展而来的，不做赘述。

/**
*注意：
* 1.lambda体中调用方法的参数列表与返回值类型，要与函数式接口中抽象方法的函数列表和返回值类型保持一致！
* 2.若lambda参数列表中的第一个参数是实例方法的调用者，而第二个参数是实例方法的参数时，可以使用ClassName::method
* 下边写的例子 上边是不简化时的写法，下边的是对应的简化写法，就是方法引用
*/
 
//100
//200
Consumer<Integer> con = (x) -> System.out.println(x);
con.accept(100);
// 方法引用-对象::实例方法
Consumer<Integer> con2 = System.out::println;
con2.accept(200);
 
// 方法引用-类名::静态方法名
BiFunction<Integer, Integer, Integer> biFun = (x, y) -> Integer.compare(x, y);
Integer apply = biFun.apply(100, 200);
BiFunction<Integer, Integer, Integer> biFun2 = Integer::compare;
Integer result = biFun2.apply(100, 200);
//-1:-1
System.err.println(apply + ":" + result);
 
// 方法引用-类名::实例方法名
BiFunction<String, String, Boolean> fun1 = (str1, str2) -> str1.equals(str2);
Boolean apply1 = fun1.apply("rong", "rong");
BiFunction<String, String, Boolean> fun2 = String::equals;
Boolean result2 = fun2.apply("hello", "world");
//true:false
System.out.println(apply1 + ":" + result2);

(b)构造器引用 

// 构造方法引用 类名::new
Supplier<String> sup = () -> new String();
System.out.println(sup.get());
Supplier<String> sup2 = String::new;
System.out.println(sup2.get());
 
// 构造方法引用 类名::new （带一个参数）
//x 代表是传进去的参数，也就是泛型中的Integer类型
//new String(...) 代表泛型中的String类型
Function<Integer, String> fun = x -> new String(String.valueOf(x));
System.err.println(fun.apply(100));
Function<String, String> fun3 = String::new;
System.out.println(fun3.apply("100"));

(c)数组引用

// 数组引用
Function<Integer, String[]> arrayFun = (x) -> new String[x];
Function<Integer, String[]> arrayFun2 = String[]::new;
//给String数组设置了两个长度。但是值是null
String[] strArray = arrayFun2.apply(2);
Arrays.stream(strArray).forEach(System.out::println);