Java教程

01-19、JavaSE知识点总结_Java8新特性

本文主要是介绍01-19、JavaSE知识点总结_Java8新特性,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

JavaSE知识点总结

  • Lambda表达式
  • 函数式(Functional)接口
  • 方法引用与构造器引用
    • 方法引用
    • 构造器引用
    • 数组引用
  • 强大的Stream API
    • 创建 Stream方式一:通过集合
    • 创建 Stream方式二:通过数组
    • 创建 Stream方式三:通过Stream的of()
    • 创建 Stream方式四:创建无限流
    • Stream的中间操作
    • Stream 的终止操作
  • Optional类

在这里插入图片描述

Lambda表达式

  • Lambda是一个匿名函数,我们可以把Lambda表达式理解为是一段可以传递的代码(将代码像数据一样进行传递)。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格,使Java的语言表达能力得到了提升
// 匿名内部类
Runnable runnable = new Runnable(){
	@Override
	public void run(){
	}
}

// Lambda表达式
Runnable r1 = () -> System.out.println("Lambda");
Lambda表达式
Lambda表达式是Java8语言中引入的一种新的语法元素和操作符。这个操作符为“->”,该操作符被称为Lambda操作符或箭头操作符。它将 Lambda 分为两个部分:
左侧:指定了 Lambda 表达式需要的参数列表
右侧:指定了 Lambda 体,是抽象方法的实现逻辑,也即Lambda 表达式要执行的功能
Lambda表达式语法
无参,无返回值Runnable r1 = () -> {sout();};
Lambda 需要一个参数,但是没有返回值Consumer<String> con = (String str) -> {};
数据类型可以省略,因为可由编译器推断得出,称为“类型推断”Consumer<String> con = (str) -> {};
Lambda 若只需要一个参数时,参数的小括号可以省略
Lambda 需要两个或以上的参数,多条执行语句,并且可以有返回值
当 Lambda 体只有一条语句时,return 与大括号若有,都可以省略
类型推断
上述Lambda表达式中的参数类型都是由编译器推断得出的。Lambda表达式中无需指定类型,程序依然可以编译,这是因为javac根据程序的上下文,在后台推断出了参数的类型。Lambda表达式的类型依赖于上下文环境,是由编译器推断出来的。这就是所谓的“类型推断”

函数式(Functional)接口

  • 只包含一个抽象方法的接口,称为函数式接口
  • 你可以通过Lambda表达式来创建该接口的对象。(若Lambda表达式抛出一个受检异常(即:非运行时异常),那么该异常需要在目标接口的抽象方法上进行声明)
  • 我们可以在一个接口上使用 @FunctionalInterface 注解,这样做可以检查它是否是一个函数式接口。同时 javadoc 也会包含一条声明,说明这个接口是一个函数式接口。
  • 在java.util.function包下定义了Java8的丰富的函数式接口

  • Java从诞生日起就是一直倡导“一切皆对象”,在Java里面面向对象(OOP)编程是一切。但是随着python、scala等语言的兴起和新技术的挑战,Java不得不做出调整以便支持更加广泛的技术要求,也即java不但可以支持OOP还可以支持OOF(面向函数编程)
  • 在函数式编程语言当中,函数被当做一等公民对待。在将函数作为一等公民的编程语言中,Lambda表达式的类型是函数。但是在Java8中,有所不同。在Java8中,Lambda表达式是对象,而不是函数,它们必须依附于一类特别的对象类型——函数式接口。
  • 简单的说,在Java8中,Lambda表达式就是一个函数式接口的实例。这就是Lambda表达式和函数式接口的关系。也就是说,只要一个对象是函数式接口的实例,那么该对象就可以用Lambda表达式来表示。
  • 所以以前用匿名实现类表示的现在都可以用Lambda表达式来写
/*
* 函数式接口举例
*/
@FunctionalInterface
public interface Runnable{
	public abstract void run();
}
  • Java内置四大核心函数式接口
函数式接口参数类型返回类型用途
Consumer<T>消费型接口Tvoid对类型为T的对象应用操作,包含方法:void accept(T t)
Supplier<T>供给型接口T返回类型为T的对象,包含方法:T get()
Function<T, R>函数型接口TR对类型为T的对象应用操作,并返回结果。结果是R类型的对象。包含方法:R apply(T t)
Predicate<T>断定型接口Tboolean确定类型为T的对象是否满足某约束,并返回boolean 值。包含方法:boolean test(T t)
  • 其他函数式接口
函数式接口参数类型返回类型用途
BiFunction<T, U, R>T, UR对类型为 T, U 参数应用操作,返回 R 类型的结果。包含方法为: R apply(T t, U u);
UnaryOperator<T> (Function子接口)TT对类型为T的对象进行一元运算,并返回T类型的结果。包含方法为:T apply(T t);
BinaryOperator<T> (BiFunction 子接口)T, TT对类型为T的对象进行二元运算,并返回T类型的结果。包含方法为: T apply(T t1, T t2);
BiConsumer<T, U>T, Uvoid对类型为T, U 参数应用操作。包含方法为: void accept(T t, U u)
BiPredicate<T,U>T, Uboolean包含方法为: boolean test(T t,U u)
ToIntFunction ToLongFunction ToDoubleFunctionTint long double分别计算int、long、double值的函数
IntFunction LongFunction DoubleFunctionint long doubleR参数分别为int、long、double 类型的函数

方法引用与构造器引用

方法引用

  • 当要传递给Lambda体的操作,已经有实现的方法了,可以使用方法引用
  • 方法引用可以看做是Lambda表达式深层次的表达。换句话说,方法引用就是Lambda表达式,也就是函数式接口的一个实例,通过方法的名字来指向一个方法,可以认为是Lambda表达式的一个语法糖
  • 要求:实现接口的抽象方法的参数列表和返回值类型,必须与方法引用的方法的参数列表和返回值类型保持一致
  • 格式:使用操作符 “::” 将类(或对象)与方法名分隔开来
  • 如下三种主要使用情况:
        对象::实例方法名
        类::静态方法名
        类::实例方法名
Comsumer<String> con = (x) -> System.out.println(x);
// 等同于
Comsumer<String> con = System.out::println;

Comsumer<Integer> con = (x,y) -> Integer.compare(x,y);
// 等同于
Comsumer<Integer> com = Integer::compare;

BiPredicate<String String> bp = (x,y) -> x.equals(y);
// 等同于
BiPredicate<String,String> bp = String::equals;

// 当函数式接口方法的第一个参数是需要引用方法的调用者,并且第二个参数是需要引用方法的参数(或无参数)时:ClassName::methodName

构造器引用

  • 格式: ClassName::new
  • 与函数式接口相结合,自动与函数式接口中方法兼容
  • 可以把构造器引用赋值给定义的方法,要求构造器参数列表要与接口中抽象方法的参数列表一致!且方法的返回值即为构造器对应类的对象
Function<Integer,MyClass> fun = (n) -> new MyClass(n);
// 等同于
Function<Integer,MyClass> fun = MyClass::new;

数组引用

  • 格式: type[] :: new
Function<Integer,Integer[]> fun = (n) -> new Integer[n];
// 等同于
Function<Integer,Integer[]> fun = Integer[]::new;

强大的Stream API

  • Stream 和 Collection 集合的区别:Collection 是一种静态的内存数据结构,而 Stream 是有关计算的。前者是主要面向内存,存储在内存中,后者主要是面向 CPU,通过 CPU 实现计算
  • 集合讲的是数据,Stream讲的是计算
  • 注意
        Stream 自己不会存储元素
        Stream 不会改变源对象。相反,他们会返回一个持有结果的新Stream
        Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行
Stream的操作三个步骤
1- 创建 Stream
    一个数据源(如:集合、数组),获取一个流
2- 中间操作
    一个中间操作链,对数据源的数据进行处理
3- 终止操作(终端操作)
    一旦执行终止操作,就执行中间操作链,并产生结果。之后,不会再被使用
在这里插入图片描述

创建 Stream方式一:通过集合

  • Java8 中的 Collection 接口被扩展,提供了两个获取流的方法
  • default Stream stream() : 返回一个顺序流
  • default Stream parallelStream() : 返回一个并行流

创建 Stream方式二:通过数组

  • Java8 中的Arrays 的静态方法 stream() 可以获取数组流
  • static <T> Stream<T> stream(T[] array): 返回一个流

创建 Stream方式三:通过Stream的of()

  • 调用Stream类静态方法 of(), 通过显示值创建一个流。它可以接收任意数量的参数
  • public static Stream of(T… values) : 返回一个流

创建 Stream方式四:创建无限流

  • 使用静态方法 Stream.iterate() 和 Stream.generate(), 创建无限流
  • public static Stream iterate(final T seed, final UnaryOperator f) 迭代
  • public static Stream generate(Supplier s) 生成
public void test4() {
// 迭代
// public static<T> Stream<T> iterate(final T seed, final
// UnaryOperator<T> f)
Stream<Integer> stream = Stream.iterate(0, x -> x + 2); 
stream.limit(10).forEach(System.out::println);
// 生成
// public static<T> Stream<T> generate(Supplier<T> s) 
Stream<Double> stream1 = Stream.generate(Math::random); 
stream1.limit(10).forEach(System.out::println);
}

Stream的中间操作

  • 多个中间操作可以连接起来形成一个流水线,除非流水线上触发终止操作,否则中间操作不会执行任何的处理!而在终止操作时一次性全部处理,称为“惰性求值”
筛选与切片方法描述
filter(Predicate p)接收 Lambda , 从流中排除某些元素
distinct()筛选,通过流所生成元素的 hashCode() 和 equals() 去除重复元素
limit(long maxSize)截断流,使其元素不超过给定数量
skip(long n)跳过元素,返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个,则返回一个空流。与 limit(n) 互补
映射方法描述
map(Function f)接收一个函数作为参数,该函数会被应用到每个元素上,并将其映射成一个新的元素
mapToDouble(ToDoubleFunction f)接收一个函数作为参数,该函数会被应用到每个元素上,产生一个新的 DoubleStream
mapToInt(ToIntFunction f)接收一个函数作为参数,该函数会被应用到每个元素上,产生一个新的 IntStream
mapToLong(ToLongFunction f)接收一个函数作为参数,该函数会被应用到每个元素上,产生一个新的 LongStream。
flatMap(Function f)接收一个函数作为参数,将流中的每个值都换成另一个流,然后把所有流连接成一个流
排序方法描述
sorted()产生一个新流,其中按自然顺序排序
sorted(Comparator com)产生一个新流,其中按比较器顺序排序

Stream 的终止操作

  • 终端操作会从流的流水线生成结果。其结果可以是任何不是流的值,例如:List、Integer,甚至是 void
  • 流进行了终止操作后,不能再次使用
匹配与查找方法描述
allMatch(Predicate p)检查是否匹配所有元素
anyMatch(Predicate p)检查是否至少匹配一个元素
noneMatch(Predicate p)检查是否没有匹配所有元素
findFirst()返回第一个元素
findAny()返回当前流中的任意元素
count()返回流中元素总数
max(Comparator c)返回流中最大值
min(Comparator c)返回流中最小值
forEach(Consumer c)内部迭代(使用 Collection 接口需要用户去做迭代,称为外部迭代。相反,Stream API 使用内部迭代——它帮你把迭代做了)
归约方法描述
reduce(T iden, BinaryOperator b)可以将流中元素反复结合起来,得到一个值。返回 T
reduce(BinaryOperator b)可以将流中元素反复结合起来,得到一个值。返回 Optional<T>
收集方法描述
collect(Collector c)将流转换为其他形式。接收一个 Collector接口的实现,用于给Stream中元素做汇总的方法
  • Collector接口中方法的实现决定了如何对流执行收集的操作(如收集到 List、Set、 Map)
  • Collectors 实用类提供了很多静态方法,可以方便地创建常见收集器实例
方法返回值类型作用举例
toListList<T>把流中元素收集到ListList emps= list.stream().collect(Collectors.toList());
toSetSet<T>把流中元素收集到SetSet emps= list.stream().collect(Collectors.toSet());
toCollectionCollection<T>把流中元素收集到创建的集合Collection emps =list.stream().collect(Collectors.toCollection(ArrayList::new));
countingLong计算流中元素的个数long count = list.stream().collect(Collectors.counting());
summingIntInteger对流中元素的整数属性求和int total=list.stream().collect(Collectors.summingInt(Employee::getSalary));
averagingIntDouble计算流中元素Integer属性的平均值double avg = list.stream().collect(Collectors.averagingInt(Employee::getSalary));
summarizingIntIntSummaryStatistics收集流中Integer属性的统计值。如:平均值int SummaryStatisticsiss= list.stream().collect(Collectors.summarizingInt(Employee::getSalary));
joiningString连接流中每个字符串String str= list.stream().map(Employee::getName).collect(Collectors.joining());
maxByOptional<T>根据比较器选择最大值Optionalmax= list.stream().collect(Collectors.maxBy(comparingInt(Employee::getSalary)));
minByOptional<T>根据比较器选择最小值Optional min = list.stream().collect(Collectors.minBy(comparingInt(Employee::getSalary)));
reducing归约产生的类型从一个作为累加器的初始值开始,利用BinaryOperator与流中元素逐个结合,从而归约成单个值int total=list.stream().collect(Collectors.reducing(0, Employee::getSalar, Integer::sum));
collectingAndThen转换函数返回的类型包裹另一个收集器,对其结果转换函数int how= list.stream().collect(Collectors.collectingAndThen(Collectors.toList(), List::size));
groupingByMap<K, List<T>>根据某属性值对流分组,属性为K,结果为VMap<Emp.Status, List> map= list.stream().collect(Collectors.groupingBy(Employee::getStatus));
partitioningByMap<Boolean, List<T>>根据true或false进行分区Map<Boolean,List> vd = list.stream().collect(Collectors.partitioningBy(Employee::getManage));

  • 并行流就是把一个内容分成多个数据块,并用不同的线程分别处理每个数据块的流。相比较串行的流,并行的流可以很大程度上提高程序的执行效率
  • Java8中将并行进行了优化,我们可以很容易的对数据进行并行操作。 Stream API 可以声明性地通过 parallel() 与 sequential() 在并行流与顺序流之间进行切换

Optional类

  • Optional<T>类(java.util.Optional) 是一个容器类,它可以保存类型T的值,代表这个值存在。或者仅仅保存null,表示这个值不存在。原来用null 表示一个值不存在,现在Optional可以更好的表达这个概念。并且可以避免空指针异常

  • Optional类的Javadoc描述如下:这是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true,调用get()方法会返回该对象

  • Optional提供很多有用的方法,这样我们就不用显式进行空值检测

  • 创建Optional类对象的方法:
        Optional.of(T t) : 创建一个 Optional 实例,t必须非空;
        Optional.empty() : 创建一个空的 Optional 实例
        Optional.ofNullable(T t):t可以为null

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

  • 获取Optional容器的对象:
        T get(): 如果调用对象包含值,返回该值,否则抛异常
        T orElse(T other) :如果有值则将其返回,否则返回指定的other对象。
        T orElseGet(Supplier<? extends T> other) :如果有值则将其返回,否则返回由Supplier接口实现提供的对象。
        T orElseThrow(Supplier<? extends X> exceptionSupplier) :如果有值则将其返回,否则抛出由Supplier接口实现提供的异常

@Test
public void test1() {
Boy b = new Boy("张三");
Optional<Girl> opt = Optional.ofNullable(b.getGrilFriend()); // 如果女朋友存在就打印女朋友的信息
opt.ifPresent(System.out::println);
}
@Test
public void test2() {
Boy b = new Boy("张三");
Optional<Girl> opt = Optional.ofNullable(b.getGrilFriend()); // 如果有女朋友就返回他的女朋友,否则只能欣赏“嫦娥”了
Girl girl = opt.orElse(new Girl("嫦娥"));
System.out.println("他的女朋友是:" + girl.getName());
}
@Test
public void test3(){
Optional<Employee> opt = Optional.of(new Employee("张三", 8888)); //判断opt中员工对象是否满足条件,如果满足就保留,否则返回空
Optional<Employee> emp = opt.filter(e -> e.getSalary()>10000); System.out.println(emp);
}
@Test
public void test4(){
Optional<Employee> opt = Optional.of(new Employee("张三", 8888)); //如果opt中员工对象不为空,就涨薪10%
Optional<Employee> emp = opt.map(e -> 
{e.setSalary(e.getSalary()%1.1);return e;});
System.out.println(emp);
}
这篇关于01-19、JavaSE知识点总结_Java8新特性的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!