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字符，并且使用'\r'并跟随'\n'作为分割。编码输出最后没有行分割

加密解密

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);