Java8特性

Posted 浮梦

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java8特性相关的知识,希望对你有一定的参考价值。

java8特性

Oracle 公司于 2014 年 3 月 18 日发布 Java 8 ,它支持函数式编程,新的 javascript 引擎,新的日期 API,新的Stream API 等。

1.lambda表达式 & 函数式接口

详见lambda表达式总结

2. 方法引用

方法引用的规定,实现抽象方法的参数列表,必须与方法引用方法的参数列表保持一致!至于返回值就不作要求

方法引用通过方法的名字来指向一个方法。方法引用可以使语言的构造更紧凑简洁,减少冗余代码。方法引用使用一对冒号 ::

引用对象的实例方法 Object::instanceMethodName
引用类的静态方法 ?ClassName::staticMethodName
引用类的实例方法 ClassName::methodName
引用构造方法 ClassName::new

1、2、4相对好理解,第三个在Java 8 In Action 是这样介绍的, 指向任意类型实例方法的方法引用(我觉得叫类的任意对象的实例方法引用更直观)

它要求接口方法的参数必须比引用方法的参数多一个。而且第一个参数要是该引用方法的所在类型的或其父类,除接口方法的第一个参数以外, 其余参数的类型要求一样。

example1,一个参数

public ?class Test1 {
? ? public void a(){
? ? }
? ? public static void main(String[] args) {
? ? ? ? MyInter m = Test1::a;
? ? }
}
@FunctionalInterface
interface MyInter {
? ? //入参参数比Test1的a方法多一个,且Test1::a的Test1与该入参类型Test1相同
? ? public void d(Test1 d);
}

example2,两个参数

public ?class Test1 {
? ? public void a(Integer param1,int param2){
? ? }
? ? public static void main(String[] args) {
? ? ? ? MyInter m = Test1::a;
? ? }
}
@FunctionalInterface
interface MyInter {
? ? //该接口参数比上述的a方法参数数量多一个,除去第一个,其它类型一致(可兼容,如可以一个int,一个Integer)
? ? //且Test1::a的Test1是该入参类型Test1相同
? ? public void d(Test1 d,int param1,int param2);
}

example3 继承(参考上转型)

public ?class Test1 {
? ? public void a(Integer param1,int param2){
? ? }
? ? public static void main(String[] args) {
? ? ? ? MyInter m = Test1::a;
? ? }
}
class Test2 extends Test1 {
}
@FunctionalInterface
interface MyInter {
? ? //该接口参数比上述的a方法参数数量多一个,除去第一个,其它类型一致(可兼容,如可以一个int,一个Integer)
? ? //且Test1::a的Test1是该入参类型Test2的子类(不可颠倒)
? ? //我的理解:最后执行的是Test1的a方法,是由入参Test2执行,Test2是子类,肯定可以执行父类的方法,所以ok
? ? public void d(Test2 d,int param1,int param2);
}

总结:指向任意类型实例方法的方法引用有两个要求:

  • 第一点:接口方法的参数比引用方法的参数多一个
  • 第二点:接口方法的第一个参数恰巧是调用引用方法的对象(其引用方法所在类或其父类的实例)

3. 默认方法

Java 8 新增了接口的默认方法。我们只需在方法名前面加个 default 关键字即可实现默认方法。

简单说,默认方法就是接口可以有实现方法,而且不需要实现类去实现其方法。

Java 8 的另一个特性是接口可以声明(并且可以提供实现)静态方法

public class Car {
    public static void main(String[] args) {
        A a = new B();
        a.print();
    }
}

interface A{
    default void print(){
        System.out.println("-a-");
    }
    static void staticMethod(){
        System.out.println("-do-");
    }
}

class B implements A{

    @Override
    public void print() {
        A.super.print();
        A.staticMethod();
        System.out.println("-b-");
    }
}

运行结果为

-a-
-do-
-b-

4. Stream类

Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。

  • foreach:迭代流中的每个数据
Random random = new Random();
random.ints().limit(10).forEach(System.out::println);

注:在stream的foreach中,无法使用break和continue终止循环。使用return;可以退出本次循环,不影响下一次循环

  • map:用于映射每个元素到对应的结果
List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
// 获取对应的平方数
List<Integer> squaresList = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());
  • filter:通过设置的条件过滤元素
List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
// 获取空字符串的数量
int count = strings.stream().filter(string -> string.isEmpty()).count();
  • limit:会用获取指定数量的流
//打印10条数据
Random random = new Random();
random.ints().limit(10).forEach(System.out::println);
  • sorted:用于对流进行排序
//10个随机数排序
Random random = new Random();
random.ints().limit(10).sorted().forEach(System.out::println);
  • parallel并行程序:parallelStream是流并行处理程序的代替方法
List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
// 获取空字符串的数量
int count = strings.parallelStream().filter(string -> string.isEmpty()).count();
  • Collectors:规约操作,例如将流转换为集合和聚合元素
List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());
 
System.out.println("筛选列表: " + filtered);
String mergedString = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.joining(", "));
System.out.println("合并字符串: " + mergedString);

流搜索

  • findAny:查找任何一个就返回 Optional
  • findFirst:查找到第一个就返回 Optional
  • anyMatch:匹配上任何一个则返回 Boolean
  • allMatch:匹配所有的元素则返回 Boolean
// 查找某一个枚举值
public static SwitchEnum findAny(int type) {
    return Arrays.stream(SwitchEnum.values())
            .filter(switchEnum -> switchEnum.getType() == type)
            .findAny()
            .orElse(null);
}

// 匹配到第一个枚举值就返回
public static SwitchEnum findFirst(String name) {
    return Arrays.stream(SwitchEnum.values())
            .filter(switchEnum -> switchEnum.getName().equals(name))
            .findFirst()
            .orElse(null);
}


// 枚举匹配
public static boolean anyMatch(int type) {
    return Arrays.stream(SwitchEnum.values())
            //匹配任何一个则返回
            .anyMatch(switchEnum -> switchEnum.getType() == type);
}

// 枚举匹配
public static boolean allMatch(String name) {
    return Arrays.stream(SwitchEnum.values())
            //匹配所有
            .allMatch(switchEnum -> switchEnum.getName().equals(name));
}

5.Optional类

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

Optional 是个容器:它可以保存类型T的值,或者仅仅保存null。Optional提供很多有用的方法,这样我们就不用显式进行空值检测。

Optional 类的引入很好的解决空指针异常。

方法 描述
static Optional empty() 返回空的 Optional 实例
boolean equals(Object obj) 判断其他对象是否等于 Optional
Optional filter(Predicate<? super predicate) 如果值存在,并且这个值匹配给定的 predicate,返回一个Optional用以描述这个值,否则返回一个空的Optional
Optional flatMap(Function<? super T,Optional> mapper) 如果值存在,返回基于Optional包含的映射方法的值,否则返回一个空的Optional
T get() 如果在这个Optional中包含这个值,返回值,否则抛出异常:NoSuchElementException
int hashCode() 返回存在值的哈希码,如果值不存在 返回 0
void ifPresent(Consumer<? super T> consumer) 如果值存在则使用该值调用 consumer , 否则不做任何事情
boolean isPresent() 如果值存在则方法会返回true,否则返回 false
Optional map(Function<? super T,? extends U> mapper) 如果有值,则对其执行调用映射函数得到返回值。如果返回值不为 null,则创建包含映射返回值的Optional作为map方法返回值,否则返回空Optional
static Optional of(T value) 返回一个指定非null值的Optional
static Optional ofNullable(T value) 如果为非空,返回 Optional 描述的指定值,否则返回空的 Optional
T orElse(T other) 如果存在该值,返回值, 否则返回 other
T orElseGet(Supplier<? extends T> other) 如果存在该值,返回值, 否则触发 other,并返回 other 调用的结果
T orElseThrow(Supplier<? extends X> exceptionSupplier) 如果存在该值,返回包含的值,否则抛出由 Supplier 继承的异常
String toString() 返回一个Optional的非空字符串,用来调试
  1. of() 和 ofNullable() 方法
    创建包含值的 Optional。
    两个方法的不同之处在于,如果你把 null 值作为参数传递进去,of() 方法会抛出 NullPointerException。
    明确对象不为 null 的时候使用 of()。
    如果对象即可能是 null 也可能是非 null,你就应该使用 ofNullable() 方法。
    Optional<User> opt = Optional.ofNullable(user);

  2. 返回对象值
  • get():从 Optional 实例中取回实际值对象的方法之一是使用 get() 方法,但如果值是null会抛异常,用之前要判断,isPresent()
  • orElse():如果有值则返回该值,否则返回传递给它的参数值.
//如果user对象为空,返回user2对象
User result = Optional.ofNullable(user).orElse(user2)
  • orElseGet():有值的时候返回值,如果没有值,它会执行作为参数传入的 Supplier(供应者) 函数式接口
  • 注意:orElse() 和 orElseGet() 的不同之处:当对象为空时无差异。当对象不为空时,orElse中的方法仍然会执行。
User result = Optional.ofNullable(user).orElse(new User("extra@gmail.com", "1234"));
User result2 = Optional.ofNullable(user).orElseGet(User::new);
//user不为空,上面的构造方法仍然执行了

取值实例:

//传统判断:
if (user != null) {
    AddressEntity addressEntity = user.getAddressEntity();
    if (addressEntity != null) {
        String address = addressEntity.getAddress();
        if (address != null && address.length() > 3) {
            return address;
        }

    }
}

//optional
return Optional.ofNullable(user)
    .map(u -> u.getAddressEntity())
    .map(a -> a.getAddress())
    .filter(s -> s.length() > 3)
    .orElse(null);

判断操作

public static void doThing(String name) {
        if (name != null) {
            System.out.println(name);
        }
    }

public static void doThingOptional(String name) {
    Optional.ofNullable(name)
            .ifPresent(System.out::println);
}

6.时间日期API

旧版问题:

  • 非线程安全: java.util.Date 是非线程安全的,所有的日期类都是可变的,这是Java日期类最大的问题之一。
  • 设计很差 ? Java的日期/时间类的定义并不一致,在java.util和java.sql的包中都有日期类
  • 时区处理麻烦 ? 日期类并不提供国际化,没有时区支持

Java 8 在 java.time 包下提供了很多新的 API。以下为两个比较重要的 API:

  • Local(本地) ? 简化了日期时间的处理,没有时区的问题。
  • Zoned(时区) ? 通过制定的时区处理日期时间。

6.1 LocalDateTime

常用方法 描述
LocalDateTime.now() 获取当前时间
of(int ...) 可以根据年月日时分,年月日时分秒,年月日时分秒毫秒等 获取时间
parse(CharSequence text) 根据文本创建时间,形如"2007-12-03T10:15:30"
toLocalDate() 获取当前日期对象
toLocalTime() 获取当前时间对象
getYear()
getMonth() 月(是个对象)
getMonthValue() 月值,eg:12
getDayOfMonth()、getDayOfYear()、getDayOfWeek() 当前是月、年、周的第几天
getHour()、getSecond()、getSecond()、getNano() 获取时、分、秒、毫秒
withYear(int year).. 替换时间,可以替换Year、Month、DayOfMonth、DayOfYear、Hour、Minute、Second、Nano
plusYears(long),plusMonth(long)... 一天后的时间,一年后的时间。(年,..,毫秒)
minYears(long),minMonths(long) 一天前的时间,(年,...,毫秒)
isAfter(LocalDataTime ldt) 对比当前对象时间是否在参数对象时间之后?返回boolean
isBefore(LocalDataTime ldt) 对比之前
isEqual(LocalDataTime ldt) 对比是否相等

实例:

// 获取当前的日期时间
LocalDateTime currentTime = LocalDateTime.now();
System.out.println("当前时间: " + currentTime);

LocalDate date1 = currentTime.toLocalDate();
System.out.println("date1: " + date1);

Month month = currentTime.getMonth();
int day = currentTime.getDayOfMonth();
int seconds = currentTime.getSecond();

System.out.println("月: " + month +", 日: " + day +", 秒: " + seconds);

LocalDateTime date2 = currentTime.withDayOfMonth(10).withYear(2012);
System.out.println("date2: " + date2);

// 12 december 2014
LocalDate date3 = LocalDate.of(2014, Month.DECEMBER, 12);
System.out.println("date3: " + date3);

// 22 小时 15 分钟
LocalTime date4 = LocalTime.of(22, 15);
System.out.println("date4: " + date4);

// 解析字符串
LocalTime date5 = LocalTime.parse("20:15:30");
System.out.println("date5: " + date5);

7. Base64

Java 8 内置了 Base64 编码的编码器和解码器。
Base64工具类提供了一套静态方法获取下面三种BASE64编解码器:

  • 基本:输出被映射到一组字符A-Za-z0-9+/,编码不添加任何行标,输出的解码仅支持A-Za-z0-9+/。
  • URL:输出映射到一组字符A-Za-z0-9+_,输出是URL和文件。
  • MIME:输出隐射到MIME友好格式。输出每行不超过76字符,并且使用‘ ‘并跟随‘ ‘作为分割。编码输出最后没有行分割

加密解密

String text = "base64 in java8 lib";
//编码
String encode = Base64.getEncoder()
        .encodeToString(text.getBytes(StandardCharsets.UTF_8));
System.out.println(encode);

//解码
String decode = new String(Base64.decode(encode), StandardCharsets.UTF_8);
System.out.println(decode);

以上是关于Java8特性的主要内容,如果未能解决你的问题,请参考以下文章

利用Idea重构功能及Java8语法特性——优化深层嵌套代码

java8新特性——Lambda表达式

2020了你还不会Java8新特性?Java 8新特性介绍

Java8新特性

Java8新特性

Java8常用新特性实践