Java8的新特性

Lambda表达式

Lambda是一个匿名函数，我们可以把Lambda表达式理解为是一段可以传递的代码（将代码像数据一样传递）。使用它可以写出更简洁，更灵活的的代码。作为一种观念更紧凑的代码风格，使Java的语言表达能力得到了提升。

//Lambda表达式的使用举例
@Test
public void test1(){
	Runnable r1 = new Runnable(){
		@Override
		public void run(){
			System.out.println("测试lambda")
		}
	}
	r1.run();
	//使用lambda
	Runnable r2 = ()->System.out.println("我爱北京天安门");
	r2.run();
}

Lambda表达式的使用
1.举例：（o1,o2) -> Integer.compare(o1,o2);
2.格式：
->:lambda操作符 或箭头操作符
->左边：lambda形参列表（其实就是接口中的抽象方法的形参列表）
->右边：lambda体（其实就是重写的抽象方法的方法体）
3.Lambda表达式的使用：（分为6种情况）
语法格式一：无参，无返回值

Runnable r1 = () ->{System.out.println("hello Lambda!")};

语法格式二：Lambda需要一个参数，但是没有返回值

Consumer<String> con = (String str)->{System.out.println(str)};

语法格式三：数据类型可以省略，因为可由编译器推断得出，称为类型推断

Consummer<String> con = (str)->{System.out.println(Str);};

语法格式四：Lambda若只需要一个参数时，参数的小括号可以省略

Consumer<String> con = str -> {System.out.println(str);};

语法格式五：Lambda需要两个或以上的参数，多条执行语句，并且可以有返回值

Comparator<Integer> com = (x,y)->{
	System.out.print("实现函数时接口方法！");
	return Integer.compare(x,y);
}

语法格式六：当Lambda体只有一条语句时，return与大括号若有，都可以省略

Comparator<Integer> com = (x,y)->Integer.compare(x,y);

总结：
->左边：Lambda形参列表的参数类型可以省略（类型推断）；如果lambda形参列表只有一个参数，其一对()也可以省略
->右边：Lambda体应该使用一对{}包裹；如果lambda体只有一条执行语句（可能是return 语句），可以省略这一对{}和return关键字

4.Lambda表达式的本质：作为函数式接口的实例

函数式接口

如果一个接口中，只声明了一个抽象方法，则此接口就称为函数式接口,可以使用FunactionalInterface检验是否属于函数式接口
匿名实现类标识的都可以用Lambda表达式来写

//定义一个函数式接口
@FunctionalInterface
public interface MyInterface{
	void method1();
}

Java内置的四大核心函数式接口：

函数式接口	参数类型	返回类型	用途
Consumer<T>消费型接口	T	void	对类型为T对象应用操作，包含方法：void accept(T t);
Supplier<T>供给型接口	无	T	返回类型为T的对象：包含方法：T get();
Function<T,R>函数型接口	T	R	对类型为T的对象应用操作，并返回结果。结果是R类型的对象，包含方法：R apply(T t)
Predicate<T>	T	boolean	确定类型为T的对象是否满足某约束，并返回boolean值，包含方法:boolean test(T t)

	@Test
	public void test1(){
		happTime(500, money->System.out.println("花费了"+money+"元，好开心"));
	}
	
	public void happyTime(double money,Consumer<Double> con){
		con.accept(money);
	}

@Test void test2(){
	List<String> list = Arrays.asList("北京","南京","天津"，"东京","普京")；
	List<String> filterStr = filterString(list,s->s.contains("京"));
	System.out.printn(filterStr);
}
 
//根据给定的规则， 过滤集合中的字符串，此规则由Predicate的方法决定
public List filterString(List<String>list,Predicate<String> pre){
	ArrayList<String> filterList = new ArrayList<>();
	for(String s : list){
		if(pre.test(s)){
			filterList.add(s);
		}
	}
	return filterList;
}

方法引用和构造器引用

当要传递给Lambda体的操作，已经有实现的方法发，可以使用方法引用
方法引用可以看做是Lambda表达式深层次的表达。换句话说，方法引用就Lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法，可以认为是Lambda表达式的一个语法糖
要求：实现接口的抽喜爱那个方法的参数列表和返回值类型，必须与方法引用的方法的参数列表和返回值类型保持一致！
格式：使用操作符"::"将类（或对象）与方法名分隔开来。
如下三种主要使用情况：
情况1：对象::实例方法名
情况2：类::静态方法名
情况3：类::实例方法名。
1.使用情景：当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用。
2.方法引用，本质上就是Lambda表达式，而Lambda表达式作为函数式接口的实例。所以方法引用，也是函数式接口的实例
3.方法引用使用的要求：要求接口种的抽象方法的形参列表和返回值类型与方法引用的方法的形参列表和返回值类型相同。（针对情况1和2)

@Test
public void test1(){
	PrintStream ps = System.out;
	Consumer<String> con2 = ps::println;
	con2.accept("beijing");
}
 
@Test
public void test2(){
Employee emp = new Employee(1001,"tom",23,5600);
Suppliper<Strijng> sup2 = emp::getName;
System.out.println(sup2.get);
}
 
@Test
public void test3(){
	Comparator<Integer> com1 = Integer::compare;
	System.out.println(com1.compare(11,12)); 
}
 
@Test
public void test5()){
	Comparator<String> com1 = (s1,s2)->s1.compareTo(s2);
	System.out.println(com1.compare("abc","abd"));
	Comparator<String> com2 = String::compareTo;
	System.out.println(com21.compare("abd","abc"));
}
 
@Test
public void test7(){
	Employee employee = new Employee(1001,"jerry",23,50000);
	Function<Employee,String> func1 = e->e.getName();
	System.out.println(func1.apply(employee));
	Function<Employee,String> func2 = Employee::getName;
	System.out.println(func1.apply(employee));
}

构造器引用

和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致。
抽象方法的返回值类型即为构造器所属的类的类型

@Test
public void test1(){
	Supplier<Employee> sup1 = ()->new Employee();
	Supplier<Employee> sup2 = Employee::new;
	Employee employee1 = sup1.get();
	Employee employee2 = sup2.get();
}
@Test
public void test2(){
	Function<Integer,Employee> func1 = id->new Employee(id);
	Employee employee = func1.apply(1001);
	System.out.println(employee);
	Function<Integer,Employee> fun2 = Employee::new;
	Employee employee1  = fun2.apply(1002);
}

数组引用

可以把数组看作是一个特殊的类，则写法与构造器引用一致

 
@Test
public void test4(){
	Function<Integer,String[]>func1 = length ->new String[length];
	String[] arr1 =  func1.apply(5);
	System.out.println(Arrays.toString(arr1));
	
	Function<Integer,String[]> func2 = String[]::new;
	String[] arr2 = func2.apply(5);
	System.out.println(Arrays.toString(arr2));
}

Stream API

Stream API(java.util.stream)把真正的函数式编程风格引入到Java中。这是目前位置对Java类库最好的补充，因为StreamAPI 可以极大提供Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。
Stream是Java8中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用StreamAPI对集合数据进行操作，就类似使用SQL执行的数据库查询，也可以使用StreamAPI来并行执行操作。简言之，StreamAPI提供了以中高效且易于是哟个你的处理数据的方式。
NoSQL的数据（redis,MongDB)需要Java层面去处理
Stream 和 Collection 集合的区别：Collection是以中静态的内存数据结构，而Stream是有关计算的，前者主要面向内存，存储在内存中，后者主要是面向CPU，通过CPU实现计算。
Stream到底是什么？
是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。
“集合讲的事数据，Stream讲的是计算！”
Stream自己不会存储元素，Stream不会改变源对象，相反，他们回返回一个持有结果的新的Stream。Stream操作是延迟执行的。这意味着他们回等到需要结果的时候才执行。
Stream的操作的三个步骤
1-创建Stream
一个数据源（如：集合数组）获取一个流
2-中间操作
一个中间操作连，对数据源的数据进行处理
3-终止操作（终端操作）
一旦执行终止操作，就执行中间操作链，并产生结果，之后不会再被使用。
4.说明：
4.1一个中间操作链，对数据源的数据进行处理
4.2一旦执行终止操作，就执行中间操作链，并产生结果，之后不会再被使用。

//创建Stream方式一：通过集合
@Test
public void test1(){
	List<Employee> employees = EmployeeData.getEmployees();
	//default Stream<E> stream():返回一个顺序流
	Stream<Employee> stream = employees.stream();
	//default Stream<E> parallelStream():返回一个并行流
}

//创建Stream方式二：通过数组
@Test
public void test2(){
	//通过Arrays类的static<T> Stream<T> stream(T[] array):返回一个流
	int[] arr  = new int[]{1,2,3,4,5,6};
	IntStream stream = Arrays.stream(arr);
	Employee e1 = new Employee(1001,"Tom");
	Employee e2 = new Employee(1002,"Jerry");
	Stream<Employee> stream1 = Arrays.stream(arr1);
}

@Test
public void test3(){
//创建Stream方式三：通过Stream的of()
	Stream<Integer> stream  = Stream.of(1,2,3,4,5,6);
	//创建Stream 方式四：
	//迭代
	//遍历前10个偶数
	Stream.iterate(0,t -> t+2).limit(10).forEach(System.out::println);
	//生成
	Stream.generate(Math::random).limit(10).forEach(System.out::println);
}

Stream的中间操作

多个中间操作可以连接起来形成一个流水线，除非流水线上出发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值”。
1-筛选与切片

方法	描述
filter(Predicate p)	接受Lambda，从流中排除某些元素
distinct()	筛选，通过流所生成的元素的hashCode()和equals()去除重复元素
limit(long maxSize	截断流，使其元素不超过给定数量）
Skip(long n)	跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足n个，则返回一个空流，与limit(n)互补

//1-筛选与切牌你
@Test
public void test1(){
	List<Employee> list = EmployeeData.getEmployees();
	//filter(Predicate p)——接收Lambda，从流中排除某些元素。
	Stream<Employee> stream = list.stream();
	stream.filter(e->e.getrSalary()>7000).forEach(System.out::println);
	
	list.stream().limit(3).forEach(System.out::println);
	
	list.stream().skip(3).forEach(System.out::println);
	
	list.stream().distinct().forEach(System.out.println);
}

2-映射

方法	描述
map(Function f)	接受一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
map ToDouble(ToDoubleFunction n)	接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的DoubleStream
map ToInt(ToIntFunction f)	接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的IntStream
map ToLong(ToLongFunction f)	接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的LongStream
flatMap(Function f)	接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有的流连成一个流

List<String> list = Arrays.asList("aa","bb","cc","dd");
list.stream().map(str->str.toUpperCase()).forEach(System.out::println);
 
//获取员工姓名长督促大于3的员工的姓名
List<Employee> employees = EmployeeDataa.getEmployees();
//employees.stream().map(e->e.getName());
Stream<String> stringStream = employees.stram().map(Employee::getName);
nameStream.filter(name->name.length()>3).forEach(System.out::println);
 
//
Stream<Stream<Character>> streamStream = list.stream().map(StreamApiTest1::fromStringToStream);
streamStream.forEach(s->{
	s.forEach(System.out::print);
})
 
Stream<Character> characterStream = list.stream().flatMap(StreamAPITest1::fromStringToStream);
characterStream.forEach(System.out::print);
 
//将字符串中的多个字符构成的集合转换为对应的Stream的实例
public static Stream<Character> fromStringToStream(String str){
	ArrayList<Character> list = new ArrayList<>();
	for(Character c : str.toCharArray()){
		list.add(c);
	}
	return list.stream();
}

3-排序

方法	描述
sorted()	产生一个新流，其中按自然顺序排序
sorted(Compoarator com)	产生一个新流，器中按比较器顺序排序

List<Integer> list = Arrays.stream(23,432,235,34,23,455,23324);
list.stream().sorted().forEach(System.out::print);
//Employee需要实现Comparable接口
List<Employee> employees = EmployeeData.getEmployees();
employees.stream().sorted().forEach(System.out.print);
employees.stream().sorted((e1,e2)->{
	return Integer.compare(e1.getAge,e2.getAge)
}).forEach(System.out::print);

Stream的终止操作

终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List、Integer，甚至是void
流进行了终止操作后，不能在此使用。
1-匹配与查找

方法	描述
allMatch(Predicate p)	检查是否匹配所有元素
anyMatch(Predicate p)	检查是否至少匹配一个元素
noneMatch(Predicate p)	检查是否没有匹配所有元素
findFirst()	返回第一个元素
findAny()	返回当前流中的任意元素
count()	返回流中元素的总个数
max(Comparator c)	返回流中的最大值
min(Comparator c)	返回流中的最小值
forEach(Consumer c)	内部迭代

List<Employee> employees = EmployeeData.getEmployees();
boolean allMatch =  employees.stream().allMatch(e->getAge()>18);
System.out.println(allMatch);
boolean anyMatch =  employees.stream().anyMatch(e->getAge()>18);
System.out.println(anyMatch);
boolean noneMatch =  employees.stream().noneMatch(e->getName().startsWith("张"));
System.out.println(noneMatch);
Optional<Employee> employee =  employess.stream.findFirst();
System.out.println(employee);
Optional<Employee> findAny =  employess.parallelStream().findAny();
System.out.println(findAny);
long count = employees.stream().filter(e->e.getSalary()>5000).count();
System.out.println(count);
Stream<Double> salaryStream = employees.stream().map(e->e.getSalarty());
Optional<Double> maxSalary = salaryStream.max(Double::compare);
System.out.print(maxSalary);
Optional<Employee> employee = employees.stream().min((e1,e2)->Double.compare(e1.getSalary,e2.getSalary));
System.out.println(employee);

2-归约

方法	描述
reduce(T iden,BinaryOperator b)	可以将流中元素反复结合起来，得到一个值，返回T
reduce(BinaryOperator b)	可以将流中元素反复结合起来，得到一个值，返回Optional<T>

//计算1-10的自然数的和
List<Integer> list = Arralys.toList(1,2,3,4,5,6,7,8,9,10);
Integer sum = list.stream().reduce(0,Integer::sum);
System.out.print(sum);
 
List<Employee> employees = EmployeeData.getEmployees();
Option<Double> sumMoney =  employees.stream().map(Employee::getSalary).reduce(Double::sum);
System.out.print(sumMoney);

3-收集

方法	描述
collect(Collector c)	将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法
Collector接口中方法的实现决定了如何对流执行收集的操作（如收集到List,Set,Map）
另外，Collectors实用类提供了很多静态方法，可以方便的创建常见收集器实例。

List<Employee> employees = EmployeeData.getEmployees();
List<Employee> employeeList = employees.stream().filter(e->e.getSalary()>6000).collect(Collectors.toList());
employeeList.forEach(System.out::println);

List<Person> people = Arrays.asList(
            new Person(1, "Alice"),
            new Person(2, "Bob"),
            new Person(3, "Charlie")
        );
        Map<Integer, Person> peopleById = people.stream()
            .collect(Collectors.toMap(Person::getId, Function.identity()));
        System.out.println(peopleById);

Optional 类

Optional<T> 类(java.util.Optional) 是一个容器类，它可以保存类型T的值，代表这个值存在。或者仅仅保存null，表示这个值不存在。原来用 null 表示一个值不存在，现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常
Optional提供很多有用的方法，这样我们就不用显式进行空值检测
创建Optional类对象的方法：

Optional.of(T t)：创建一个Optional实例，t必须非空；
Optional.empty():创建一个空的Optional实例
Optional.ofNullable(T t):t可以为null

判断Option容其中上是否包含对象

bolean isPresent():判断是否包含对象
void ifPresent(Consumer<? super T> consumer):如果有值,就执行Comsumer接口的实现代码，并且该值会作为参数传给他

获取Optional容器的对象

T get():如果调用对象包含之，返回该值，否则跑一次
T orElse(T other):如果有值则将其返回，否则返回指定的other对象
T orELseGet(Supplier<? extends T> other): 如果有值将其返回，否则返回由Supplier接口实现提供的对象
T orElseThrow(Supplier<? extends X> exceptionSupplier):如果有值则将其返回，否则抛出由Supplier接口实现提供的异常。

Girl girl = new Girl();
Option<Girl> optionGirl = Option.of(girl);
Option<gorl> optrionGirl1 = optionl.ofNullable(girl);
girl = null;
System.out.println(optionGirl1);
 
public String getGirlName(Boy boy){
//优化前
	//return boy.getGirl().getName();
	//if(boy!=null){
		//Girl girl = boy.getGirl();
		//if(girl!=null){
			//return girl.getName();
		//}
	//}
	//return null;
	//优化后：
	Optional<Boy> boyOptional = Optional.ofNullable(boy);
	//T orElse(T other):如果有值则将其返回，否则返回指定的other对象
	Boy boy1 =  boyOptional.orElse(new Boy(new Girl("迪丽热巴")));
	Girl girl  = boy1.getGirl();
	Optional<Girl> girlOptional = Optional.ofNullable(girl);
	//Girl1一定非空
	Girl girl1 =  girlOptional.orElse(new Girl("古力娜扎"))；
	return girl1.getName();
	
}
 
 
Boy boy = null;
Boy boy = new Boy();
String girlName = getGirlName(boy);
System.out.println(girlName);