Java8新特性（五）————— 串行流、并行流、新时间日期API

关注微信公众号【行走在代码行的寻路人】获取Java相关资料，分享项目经验及知识干货。

• 串行流与并行流

并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。Java 8 中将并行进行了优化，我们可以很容易的对数据进行并行操作。Stream API 可以声明性地通过 parallel() 与sequential() 在并行流与顺序流之间进行切换。

• Fork/Join 框架

就是在必要的情况下，将一个大任务，进行拆分(fork)成若干个小任务（拆到不可再拆时），再将一个个的小任务运算的结果进行 join 汇总.

• Fork/Join 框架与传统线程池的区别

采用 “工作窃取”模式（work-stealing）：当执行新的任务时它可以将其拆分分成更小的任务执行，并将小任务加到线程队列中，然后再从一个随机线程的队列中偷一个并把它放在自己的队列中。相对于一般的线程池实现,fork/join框架的优势体现在对其中包含的任务的处理方式上.在一般的线程池中,如果一个线程正在执行的任务由于某些原因无法继续运行,那么该线程会处于等待状态.而在fork/join框架实现中,如果某个子问题由于等待另外一个子问题的完成而无法继续运行.那么处理该子问题的线程会主动寻找其他尚未运行的子问题来执行.这种方式减少了线程的等待时间,提高了性能。

• 新时间日期API（线程更安全）

1. LocalDate、LocalTime、LocalDateTime

LocalDate、LocalTime、LocalDateTime 类的实例是不可变的对象，分别表示使用 ISO-8601日历系统的日期、时间、日期和时间。它们提供了简单的日期或时间，并不包含当前的时间信息。也不包含与时区相关的信息。

package com.company.test;

import org.junit.Test;

import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.TemporalAdjusters;

/**
 * 1.LocalDate、LocalTime、LocalDateTime
 * 2.Duration : 用于计算两个“时间”间隔
 *   Period : 用于计算两个“日期”间隔
 * 3.TemporalAdjuster : 时间校正器
 * 4.DateTimeFormatter : 解析和格式化日期或时间
 */
public class LocalDateTimeTest {

    /**
     * LocalDate、LocalTime、LocalDateTime
     */
    @Test
    public void test1(){
        //获取当前时间
        LocalDateTime ldt = LocalDateTime.now();
        System.out.println(ldt);
        //年份
        System.out.println(ldt.getYear());
        //月份
        System.out.println(ldt.getMonthValue());
        //日
        System.out.println(ldt.getDayOfMonth());
        //小时
        System.out.println(ldt.getHour());
        //分钟
        System.out.println(ldt.getMinute());
        //秒
        System.out.println(ldt.getSecond());
        //自定义年月日时分秒
        LocalDateTime ld2 = LocalDateTime.of(2020, 5, 20, 13, 14, 00);
        System.out.println(ld2);
        //加20年
        LocalDateTime ldt3 = ld2.plusYears(20);
        System.out.println(ldt3);
        //减两个月
        LocalDateTime ldt4 = ld2.minusMonths(2);
        System.out.println(ldt4);
    }

    /**
     * Duration : 用于计算两个“时间”间隔
     * Period : 用于计算两个“日期”间隔
     */
    @Test
    public void test2(){
        Instant ins1 = Instant.now();

        System.out.println("--------------------");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
        }
        Instant ins2 = Instant.now();
        //时间差
        System.out.println("所耗费时间为：" + Duration.between(ins1, ins2));

        LocalDate ld1 = LocalDate.now();
        LocalDate ld2 = LocalDate.of(2016, 1, 1);

        Period pe = Period.between(ld2, ld1);
        System.out.println(pe.getYears());//时间差多少年
        System.out.println(pe.getMonths());//时间差多少月
        System.out.println(pe.getDays());//时间差多少日
    }

    /**
     * TemporalAdjuster : 时间校正器
     */
    @Test
    public void test3(){
        //当期那时间
        LocalDateTime ldt = LocalDateTime.now();
        System.out.println(ldt);
        //定位在10日
        LocalDateTime ldt2 = ldt.withDayOfMonth(10);
        System.out.println(ldt2);
        //调整日期到周六
        LocalDateTime ldt3 = ldt.with(TemporalAdjusters.next(DayOfWeek.SUNDAY));
        System.out.println(ldt3);
        //自定义：下一个工作日
        LocalDateTime ldt5 = ldt.with((l) -> {
            LocalDateTime ldt4 = (LocalDateTime) l;

            DayOfWeek dow = ldt4.getDayOfWeek();

            if(dow.equals(DayOfWeek.FRIDAY)){
                return ldt4.plusDays(3);
            }else if(dow.equals(DayOfWeek.SATURDAY)){
                return ldt4.plusDays(2);
            }else{
                return ldt4.plusDays(1);
            }
        });
        System.out.println(ldt5);
    }

    /**
     * DateTimeFormatter : 解析和格式化日期或时间
     */
    @Test
    public void test5(){
        //时间格式化
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss E");
        LocalDateTime ldt = LocalDateTime.now();
        String strDate = ldt.format(dtf);
        System.out.println(strDate);
        LocalDateTime newLdt = ldt.parse(strDate, dtf);
        System.out.println(newLdt);
    }
}

• 接口中的默认方法、静态方法

Java 8中允许接口中包含具有具体实现的方法，该方法称为 默认方法”，默认方法使用 default 关键字修饰。接口中允许添加静态方法。

接口默认方法的”类优先”原则若一个接口中定义了一个默认方法，而另外一个父类或接口中又定义了一个同名的方法时：

1. 选择父类中的方法。如果一个父类提供了具体的实现，那么接口中具有相同名称和参数的默认方法会被忽略。
2. 接口冲突。如果一个父接口提供一个默认方法，而另一个接口也提供了一个具有相同名称和参数列表的方法（不管方法是否是默认方法），那么必须覆盖该方法来解决冲突。

public interface MyInterface {
	
	default String getName(){
		return "呵呵呵";
	}
	
	public static void show(){
		System.out.println("接口中的静态方法");
	}

}

• Optional 类

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

常用方法：

1. Optional.of(T t) : 创建一个 Optional 实例
2. Optional.empty() : 创建一个空的 Optional 实例
3. Optional.ofNullable(T t):若 t 不为 null,创建 Optional 实例,否则创建空实例
4. isPresent() : 判断是否包含值
5. orElse(T t) : 如果调用对象包含值，返回该值，否则返回t
6. orElseGet(Supplier s) :如果调用对象包含值，返回该值，否则返回 s 获取的值
7. map(Function f): 如果有值对其处理，并返回处理后的Optional，否则返回 Optional.empty()
8. flatMap(Function mapper):与 map 类似，要求返回值必须是Optional