AI专业者开发社区 1 号成员
  •  0 回帖  •  1 浏览  •  4 个月前
   

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 实用类提供了很多静态方法，可以方便的创建常见收集器实例。
image 
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);