3分钟看完Java 8——史上最强Java 8新特性总结之第四篇 其他新特性

目录

· 默认方法和静态方法

    · 初步理解

    · 应用模式

    · 优先级问题

· Optional

· CompletableFuture

    · 基本用法

    · CompletableFuture与Stream API

· 新日期和时间API

    · 旧API

    · 创建

    · 操作

    · 格式化与解析

    · 时区

---

 

默认方法和静态方法

初步理解

1. 面临问题：Java 8以前，当已设计的接口被其他框架、库使用后，如果向接口添加新方法，将导致这些框架和库无法编译。

2. 解决方法：Java 8可在接口中使用静态方法和默认方法。

应用模式

1. 合并接口与辅助工具类：比如接口java.util.Collection与其辅助工具类java.util.Collections，接口支持静态方法后，可将辅助工具类的方法加入到接口。

2. 可选方法：比如JDK中的java.util.Iterator，接口提供一个默认的remove()实现，这样实体类就无需在自己的实现中显式地提供一个空方法。

interface Iterator<T> {

    boolean hasNext();

    T next();

    default void remove() {
        throw new UnsupportedOperationException();
    }

}

3. 行为多继承

    a) Rotatable.java

public interface Rotatable {

    void setRotationAngle(int angleInDegrees);

    int getRotationAngle();

    default void rotateBy(int angleInDegrees) {
        setRotationAngle((getRotationAngle() + angleInDegrees) % 360);
    }

}

    b) Moveable.java

 

public interface Moveable {

    int getX();

    int getY();

    void setX(int x);

    void setY(int y);

    default void moveHorizontally(int distance) {
        setX(getX() + distance);
    }

    default void moveVertically(int distance) {
        setY(getY() + distance);
    }

}

    c) Resizable.java

public interface Resizable {

    int getWidth();

    int getHeight();

    void setWidth(int width);

    void setHeight(int height);

    void setAbsoluteSize(int width, int height);

    default void setRelativeSize(int wFactor, int hFactor) {
        setAbsoluteSize(getWidth() / wFactor, getHeight() / hFactor);
    }

}

    d) Monster.java

public class Monster implements Rotatable, Moveable, Resizable {

    @Override
    public int getX() {
        return 0;
    }

    @Override
    public int getY() {
        return 0;
    }

    @Override
    public void setX(int x) {
    }

    @Override
    public void setY(int y) {

    }

    @Override
    public int getWidth() {
        return 0;
    }

    @Override
    public int getHeight() {
        return 0;
    }

    @Override
    public void setWidth(int width) {
    }

    @Override
    public void setHeight(int height) {
    }

    @Override
    public void setAbsoluteSize(int width, int height) {
    }

    @Override
    public void setRotationAngle(int angleInDegrees) {
    }

    @Override
    public int getRotationAngle() {
        return 0;
    }

}

    e) Sun.java

public class Sun implements Moveable, Rotatable {

    @Override
    public int getX() {
        return 0;
    }

    @Override
    public int getY() {
        return 0;
    }

    @Override
    public void setX(int x) {
    }

    @Override
    public void setY(int y) {
    }

    @Override
    public void setRotationAngle(int angleInDegrees) {
    }

    @Override
    public int getRotationAngle() {
        return 0;
    }

}

优先级问题

1. 方法执行优先级规则：

    a) 距离当前类越近的方法优先级越高；

    b) 显示方法近于隐式方法；

    c) 距离相等时，非默认方法优先于默认方法。

2. 举例

    a) hello()方法优先级：B > A。

        i. A.java

public interface A {
    
    default void hello() {
        System.out.println("Hello from A");
    }
    
}

        ii. B.java

public interface B extends A {

    default void hello() {
        System.out.println("Hello from B");
    }

}

        iii. C.java

public class C implements B, A {

    public static void main(String[] args) {
        new C().hello(); // Hello from B
    }

}

    b) hello()方法优先级：B > A。

        i. A.java

public interface A {
    
    default void hello() {
        System.out.println("Hello from A");
    }
    
}

        ii. B.java

public interface B extends A {

    default void hello() {
        System.out.println("Hello from B");
    }

}

        iii. D.java

public class D implements A{
}

        iv. C.java

public class C extends D implements B, A {

    public static void main(String[] args) {
        new C().hello(); // Hello from B
    }

}

    c) hello()方法优先级：D > B > A。

        i. A.java

public interface A {
    
    default void hello() {
        System.out.println("Hello from A");
    }
    
}

        ii. B.java

public interface B extends A {

    default void hello() {
        System.out.println("Hello from B");
    }

}

        iii. D.java

public class D implements A {

    @Override
    public void hello() {
        System.out.println("Hello from D");
    }

}

        iv. C.java

public class C extends D implements B, A {

    public static void main(String[] args) {
        new C().hello(); // Hello from D
    }

}

    d) hello()方法优先级：C > B = A，由于A、B优先级相等，有冲突，所以必须在C中Override hello()方法，否则将报错class C inherits unrelated defaults for hello() from types B and A。

        i. A.java

public interface A {
    
    default void hello() {
        System.out.println("Hello from A");
    }
    
}

        ii. B.java

public interface B {

    default void hello() {
        System.out.println("Hello from B");
    }

}

        iii. C.java 

public class C implements B, A {

    @Override
    public void hello() {
        B.super.hello();
    }

    public static void main(String[] args) {
        new C().hello(); // Hello from B
    }

}

Optional

1. Optional目的：解决null带来的以下问题。

    a) 错误：NullPointerException。

    b) 代码膨胀：代码充斥着深度嵌套的null检查，可读性变差。

    c) 毫无意义：null自身没有任何语义，它代表在静态类型语言中以一种错误的方式对缺失变量值的建模。

    d) 破坏了Java的哲学：Java一直试图避免让程序员意识到指针的存在，唯一的例外是null指针。

    e) 类型缺陷：null并不属于任何类型，它可以被赋值给任意引用类型的变量。这导致当这个变量被传递到系统中的另一个部分后，将无法获知null变量最初的赋值到底是什么类型。

2. java.util.Optional类的方法

方法	描述
empty	返回空Optional实例
filter	如果值存在并且满足提供的Predicate，则返回包含该值的Optional对象；否则返回空Optional对象
flatMap	如果值存在，就对该值执行提供的mapping函数，返回Optional类型的值，否则返回一个空Optional对象
get	如果值存在，将该值用Optional封装返回，否则抛出NoSuchElementException异常
ifPresent	如果值存在，则执行使用该值的方法调用，否则什么也不做
isPresent	如果值存在，则返回true，否则返回false
map	如果值存在，则对该值执行提供的mapping函数
of	将指定值用Optional封装后返回，如果该值为null，则抛出NullPointerException异常
ofNullable	将指定值用Optional封装后返回，如果该值为null，则返回空Optional对象
orElse	如果有值，则将其返回，否则返回一个默认值
orElseGet	如果有值，则将其返回，否则返回由指定Supplier接口生成的值
orElseThrow	如果有值，则将其返回，否则抛出指定的Supplier接口生成的异常

3.举例

    a) 使用Optional前

        i. Person.java

public class Person {

    private Car car;

    public Car getCar() {
        return car;
    }

}

        ii. Car.java

public class Car {

    private Insurance insurance;

    public Insurance getInsurance() {
        return insurance;
    }

}

        iii. Insurance.java

public class Insurance {

    private String name;

    public String getName() {
        return name;
    }

}

        iv. Test.java

public class Test {

    public static String getCarInsuranceName(Person person) {
        if (person != null) {
            Car car = person.getCar();
            if (car != null) {
                Insurance insurance = car.getInsurance();
                if (insurance != null) {
                    return insurance.getName();
                }
            }
        }
        return "Unknown";
    }

}

    b) 使用Optional后

        i. Person.java

import java.util.Optional;

public class Person {

    // 可能为null
    private Car car;

public Optional<Car> getCar() {
        // 使用Optional封装car，允许car为null
        return Optional.ofNullable(car);
    }

}

        ii. Car.java

import java.util.Optional;

public class Car {

    // 可能为null
    private Insurance insurance;

    public Optional<Insurance> getInsurance() {
        return Optional.ofNullable(insurance);
    }

}

        iii. Insurance.java

public class Insurance {

    // 不可能为null
    private String name;

    // 不可能为null，所以不使用Optional
    public String getName() {
        return name;
    }

}

        iv. Test.java

import java.util.Optional;

public class Test {

    public static String getCarInsuranceName(Person person) {
        Optional<Person> optPerson = Optional.ofNullable(person);
        // 由于Person::getCar返回类型是Optional<Car>，
        // 所以optPerson.map(Person::getCar)返回类型是Optional<Optional<Car>>，
        // 因此导致map(Car::getInsurance)报错
        // Optional<String> name = optPerson.map(Person::getCar)
        //                 .map(Car::getInsurance)
        //                 .map(Insurance::getName);
        // 使用flatMap扁平化，从而避免上述报错
        return optPerson.flatMap(Person::getCar)
                .flatMap(Car::getInsurance)
                .map(Insurance::getName)
                .orElse("Unknown"); // 如果Optional结果值为空，则使用默认值
    }

}

    c) 使用filter()方法判断Predicate

// 不使用Optional
Insurance insurance = null;
if(insurance != null && "CambridgeInsurance".equals(insurance.getName())){
    System.out.println("ok");
}
// 使用Optional
Optional<Insurance> optInsurance = Optional.ofNullable(null);
optInsurance.filter(ins -> "CambridgeInsurance".equals(ins.getName()))
        .ifPresent(ins -> System.out.println("ok"));

CompletableFuture

基本用法

1. java.util.concurrent.Future接口

    a) 起始：Java 5。

    b) 使用方法：通常需要将耗时操作封装在一个Callable对象中，再将它提交给ExecutorService执行，最后通过Future获取执行结果。

2. java.util.concurrent.CompletableFuture类

    a) 起始：Java 8。

    b) 优点：比Future更加直观，功能更强大。

3. 举例

    a) Future

        i. Shop.java

 

import java.util.concurrent.*;

public class Shop {

    public double getPrice(String product) {
        return calculatePrice(product);
    }

    public Future<Double> getPriceAsync(String product) {
        ExecutorService executor = Executors.newCachedThreadPool();
        Future<Double> future = executor.submit(new Callable<Double>() {
            public Double call() {
                return getPrice(product);
            }
        });
        return future;
    }

    private double calculatePrice(String product) {
        delay();
        return Math.random() * 1000;
    }

    private static void delay() {
        try {
            Thread.sleep(1000L);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

}

        ii. Test.java

import java.util.concurrent.*;

public class Test {

    public static void main(String[] args) {
        try {
            Future<Double> future = new Shop().getPriceAsync("Candy");
            Double price = future.get();
            System.out.println(price);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

}

    b) CompletableFuture方法一

import java.util.concurrent.*;

public class Shop {

    public double getPrice(String product) {
        return calculatePrice(product);
    }

    public Future<Double> getPriceAsync(String product) {
        CompletableFuture<Double> future = new CompletableFuture<>();
        new Thread(() -> {
            try {
                double price = getPrice(product);
                future.complete(price); // 如果价格计算正常结束，完成Future操作并设置商品价格
            } catch (Exception ex) {
                future.completeExceptionally(ex); // 否则就抛出导致失败的异常，完成这次Future操作
            }
        }).start();
        return future;
    }

    private double calculatePrice(String product) {
        delay();
        return Math.random() * 1000;
    }

    private static void delay() {
        try {
            Thread.sleep(1000L);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

}

    c) CompletableFuture方法二

import java.util.concurrent.*;

public class Shop {

    public double getPrice(String product) {
        return calculatePrice(product);
    }

    public Future<Double> getPriceAsync(String product) {
        return CompletableFuture.supplyAsync(() -> calculatePrice(product));
    }

    private double calculatePrice(String product) {
        delay();
        return Math.random() * 1000;
    }

    private static void delay() {
        try {
            Thread.sleep(1000L);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

}

CompletableFuture与Stream API

1. 并行流与顺序流+CompletableFuture都可以实现流的并行处理，如何选取？

    a) 灵活

        i. 并行流：线程数由ForkJoinPool的全局属性决定。

        ii. 顺序流+CompletableFuture：自由创建线程池，灵活控制线程数。

    b) 场景

        i. 并行流：更适合计算密集型并且没有I/O的操作，因为实现简单，同时效率更高（如果所有的线程都是计算密集型，则没有必要创建比CPU核数更多的线程）。

        ii. 顺序流+CompletableFuture：更适合并行工作单元涉及I/O等待（包括网络连接等待）的操作，该场景不使用并行流的另一个原因是处理流的流水线中如果发生I/O等待，流的延迟特性会让我们很难判断到底什么时候触发了等待。该场景线程数用以下公式计算（出自《Java并发编程实战》）：

N_threads = N_CPU * U_CPU * (1 + W/C)

        N_CPU为CPU核数，可通过Runtime.getRuntime().availableProcessors()获取。

        U_CPU为期望的CPU利用率（应介于0和1之间）。

        W/C是等待时间与计算时间的比率。

2. 举例

    a) Shop.java

public class Shop {

    private String name;

    public Shop(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public double getPrice(String product) {
        return calculatePrice(product);
    }

    private double calculatePrice(String product) {
        delay();
        return Math.random() * 1000;
    }

    private static void delay() {
        try {
            Thread.sleep(1000L);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

}

    b) Test.java

import java.util.*;
import java.util.concurrent.*;

import static java.util.stream.Collectors.toList;

public class Test {

    // 顺序流
    public static List<String> findPrices1(List<Shop> shops, String product) {
        return shops.stream()
                .map(shop -> String.format("%s price is %.2f", shop.getName(), shop.getPrice(product)))
                .collect(toList());
    }

    // 并行流
    public static List<String> findPrices2(List<Shop> shops, String product) {
        return shops.parallelStream()
                .map(shop -> String.format("%s price is %.2f", shop.getName(), shop.getPrice(product)))
                .collect(toList());
    }

    // 顺序流+CompletableFuture
    public static List<String> findPrices3(List<Shop> shops, String product) {
        // 创建一个线程池，线程池中线程的数目为100和商店数目二者中较小的一个值
        Executor executor = Executors.newFixedThreadPool(Math.min(shops.size(), 100),
                new ThreadFactory() {
                    public Thread newThread(Runnable r) {
                        Thread t = new Thread(r);
                        t.setDaemon(true); // 使用守护线程——这种方式不会阻止程序的关停
                        return t;
                    }
                });
        List<CompletableFuture<String>> priceFutures = shops.stream()
                .map(shop -> CompletableFuture.supplyAsync(() -> String.format("%s price is %.2f", shop.getName(), shop.getPrice(product)), executor))
                .collect(toList());
        return priceFutures.stream()
                .map(CompletableFuture::join) // 等待所有异步操作结束
                .collect(toList());
    }

    public static void printPrices(List<String> prices) {
        prices.stream().forEach(System.out::println);
    }

    public static void main(String[] args) {
        List<Shop> shops = Arrays.asList(new Shop("BestPrice"),
                new Shop("LetsSaveBig"),
                new Shop("MyFavoriteShop"),
                new Shop("BuyItAll"));
        String product = "Candy";
        List<String> prices1 = findPrices1(shops, product);
        printPrices(prices1);
        List<String> prices2 = findPrices2(shops, product);
        printPrices(prices2);
        List<String> prices3 = findPrices3(shops, product);
        printPrices(prices3);
    }

}

新日期和时间API

旧API

1. java.util.Date

    a) 起始：Java 1.0。

    b) 缺点：只能以毫秒精度表示时间；易用性差，比如年份从1900开始，月份从0开始。

// 2014年3月18日
System.out.println(new Date(114, 2, 18));

2.java.util.Calendar

    a) 起始：Java 1.1。

    b) 缺点：易用性差，比如月份从0开始；Date和Calendar如何选择问题；格式化类DateFormat只能用于Date。

创建

1. java.time.LocalDate

    a) 只存储年、月、日，不存储时区。

    b) 不可变，线程安全。

2. java.time.LocalTime

    a) 只存储时、分、秒，不存储时区。

    b) 不可变，线程安全。

3. java.time.LocalDateTime

    a) 只存储年、月、日、时、分、秒，不存储时区。

    b) 不可变，线程安全。

    c) LocalDate和LocalTime的合体。

4. java.time.Instant

    a) Unix时间戳秒数，即与UTC时区1970-01-01 00:00:00的秒数和纳秒差值。

    b) 内部存储秒数和纳秒（1 ns = 10^-9 s）两个字段。

    c) 面向机器设计的类，方便机器处理。

5. java.time.temporal.ChronoField

    a) 实现了java.time.temporal.TemporalFieldl接口的枚举，提供了访问java.time.temporal.Temporal接口实现类的标准字段。

    b) LocalDate、LocalTime、LocalDateTime和Instant实现了Temporal接口。

    c) 注意：由于Instant是面向机器的，通过ChronoField获取Instant字段时，只支持秒、毫秒（1,000毫秒=1秒）、微秒（1,000,000微秒=1秒）和纳秒（1,000,000,000纳秒=1秒）。

6. java.time.Duration

    a) 表示一个时间段的持续时长。

    b) 内部存储持续时长的秒和纳秒。

7. java.time.Period

    a) 表示一个时间段的持续时长。

    b) 内部存储持续时长的年、月、日。

8. Duration和Period的通用方法

方法	静态方法	描述
between	Y	创建两个时间点之间的间隔时长
from	Y	由一个临时时间点创建间隔时长
of	Y	由组成部分创建时长的实例
parse	Y	由字符串创建时长的实例
addTo	N	创建该时长的副本，并将其叠加到某个指定的Temporal对象
get	N	读取该时长的状态
isNegative	N	检查该时长是否为负值，不包含零
isZero	N	检查该时长的时长是否为零
minus	N	通过减去一定的时间创建该时长的副本
multipliedBy	N	将时长的值乘以某个标量创建该时长的副本
negated	N	以忽略某个时长的方式创建该时长的副本
plus	N	以增加某个指定时长的方式创建该时长的副本
subtractFrom	N	从指定的Temporal对象中减去该时长

9. 举例

    a) java.time.LocalDate

// 创建
LocalDate today = LocalDate.now();
LocalDate d = LocalDate.parse("2014-03-18");
LocalDate date = LocalDate.of(2014, 3, 18); // 2014-03-18
// 直接获取字段
int year = date.getYear(); // 2014
Month month = date.getMonth(); // MARCH
int day = date.getDayOfMonth(); // 18
DayOfWeek dow = date.getDayOfWeek(); // TUESDAY
int len = date.lengthOfMonth(); // 31 (3月总天数)
boolean leap = date.isLeapYear(); // false
// 通过ChronoField获取字段
int year = date.get(ChronoField.YEAR); // 2014
int month = date.get(ChronoField.MONTH_OF_YEAR); // 3
int day = date.get(ChronoField.DAY_OF_MONTH); // 18

    b) java.time.LocalTime

// 创建
LocalTime t = LocalTime.parse("13:45:20");
LocalTime time = LocalTime.of(13, 45, 20); // 13:45:20
// 直接获取字段
int hour = time.getHour(); // 13
int minute = time.getMinute(); // 45
int second = time.getSecond(); // 20

    c) java.time.LocalDateTime

// 创建2014-03-18T13:45:20的4种方法
LocalDateTime dt1 = LocalDateTime.of(2014, Month.MARCH, 18, 13, 45, 20);
LocalDateTime dt2 = LocalDateTime.of(date, time);
LocalDateTime dt3 = date.atTime(13, 45, 20);
LocalDateTime dt4 = date.atTime(time);
// 提取
LocalDate date1 = dt1.toLocalDate(); // 2014-03-18
LocalTime time1 = dt1.toLocalTime(); // 13:45:20

    d) java.time.Instant

// 创建1970-01-01T00:00:03Z的4种方法
Object o1 = Instant.ofEpochSecond(3);
Object o2 = Instant.ofEpochSecond(3, 0);
Object o3 = Instant.ofEpochSecond(2, 1_000_000_000); // 2秒之后再加上100万纳秒（1秒）
Object o4 = Instant.ofEpochSecond(4, -1_000_000_000); // 4秒之前的100万纳秒（1秒）
// Exception in thread "main" java.time.temporal.UnsupportedTemporalTypeException: Unsupported field: DayOfMonth
int day = Instant.now().get(ChronoField.DAY_OF_MONTH);

    e) java.time.Duration

// 创建3秒持续时长的5种方法
Duration d1 = Duration.between(LocalTime.parse("00:00:00"), LocalTime.parse("00:00:03"));
Duration d2 = Duration.between(LocalDateTime.parse("1970-01-01T00:00:00"), LocalDateTime.parse("1970-01-01T00:00:03"));
Duration d3 = Duration.between(Instant.ofEpochSecond(0), Instant.ofEpochSecond(3));
Duration d4 = Duration.ofSeconds(3);
Duration d5 = Duration.of(3, ChronoUnit.SECONDS);

    f) java.time.Period

// 创建10天持续时长的3种方法
Period p1 = Period.between(LocalDate.of(2014, 3, 8), LocalDate.of(2014, 3, 18));
Period p2 = Period.ofDays(10);
Period p3 = Period.of(0, 0, 10);

操作

1. 操作相关方法

    a) with*()方法：创建某字段为新值的新Temporal对象。

    b) plus*()方法：创建加上某个时长的新Temporal对象。

    c) minus*()方法：创建减去某个时长的新Temporal对象。

    d) java.time.temporal.TemporalAdjuster.*方法：高级日期时间操作方法

方法	描述
dayOfWeekInMonth	创建一个新日期，它的值为同一个月中每一周的第几天
firstDayOfMonth	创建一个新日期，它的值为当月的第一天
firstDayOfNextMonth	创建一个新日期，它的值为下月的第一天
firstDayOfNextYear	创建一个新日期，它的值为明年的第一天
firstDayOfYear	创建一个新日期，它的值为当年的第一天
firstInMonth	创建一个新日期，它的值为同一个月中，第一个符合星期几要求的值
lastDayOfMonth	创建一个新日期，它的值为下月的最后一天
lastDayOfNextMonth	创建一个新日期，它的值为下月的最后一天
lastDayOfNextYear	创建一个新日期，它的值为明年的最后一天
lastDayOfYear	创建一个新日期，它的值为今年的最后一天
lastInMonth	创建一个新日期，它的值为同一个月中，最后一个符合星期几要求的值
next previous	创建一个新日期，并将其值设置为日期调整后或调整前，第一个符合指定星期几要求的日期
nextOrSame previousOrSame	创建一个新日期，并将其值设置为日期调整后或调整前，第一个符合指定星期几要求的日期，如果该日期已经符合要求，直接返回该对象

2. 举例

    a) with*()方法

LocalDate date1 = LocalDate.of(2014, 3, 18); // 2014-03-18
LocalDate date2 = date1.withYear(2011); // 2011-03-18
LocalDate date3 = date2.withDayOfMonth(25); // 2011-03-25
LocalDate date4 = date3.with(ChronoField.MONTH_OF_YEAR, 9); // 2011-09-25

    b) plus*()方法和minus*()方法

LocalDate date1 = LocalDate.of(2014, 3, 18); // 2014-03-18
LocalDate date2 = date1.plusWeeks(1); // 2014-03-25
LocalDate date3 = date2.minusYears(3); // 2011-03-25
LocalDate date4 = date3.plus(6, ChronoUnit.MONTHS); // 2011-09-25

    c) TemporalAdjuster.*方法

import static java.time.temporal.TemporalAdjusters.*;
LocalDate date1 = LocalDate.of(2014, 3, 18); // 2014-03-18
LocalDate date2 = date1.with(nextOrSame(DayOfWeek.SUNDAY)); // 2014-03-23
LocalDate date3 = date2.with(lastDayOfMonth()); // 2014-03-31

    d) 自定义TemporalAdjuster：计算下一个工作日（仅跳过周六日）

TemporalAdjuster nextWorkingDay = TemporalAdjusters.ofDateAdjuster(
        temporal -> {
            DayOfWeek dow = DayOfWeek.of(temporal.get(ChronoField.DAY_OF_WEEK));
            int dayToAdd = 1;
            if (dow == DayOfWeek.FRIDAY) dayToAdd = 3;
            if (dow == DayOfWeek.SATURDAY) dayToAdd = 2;
            return temporal.plus(dayToAdd, ChronoUnit.DAYS);
        });
date = date.with(nextWorkingDay); // 2014-03-19

格式化与解析

1. java.time.format.DateTimeFormatter

    a) 用于格式化和解析。

    b) 线程安全。

2. 举例

    a) 使用内置格式格式化与解析

// 格式化
LocalDate date = LocalDate.of(2014, 3, 18);
String s1 = date.format(DateTimeFormatter.BASIC_ISO_DATE); // 20140318
String s2 = date.format(DateTimeFormatter.ISO_LOCAL_DATE); // 2014-03-18
// 解析
LocalDate date1 = LocalDate.parse("20140318", DateTimeFormatter.BASIC_ISO_DATE);
LocalDate date2 = LocalDate.parse("2014-03-18", DateTimeFormatter.ISO_LOCAL_DATE);

    b) 使用模式自定义格式式化与解析

DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日");
// 格式化
LocalDate date1 = LocalDate.of(2014, 3, 18);
String formattedDate = date1.format(formatter);
// 解析
LocalDate date2 = LocalDate.parse(formattedDate, formatter);

    c) 更复杂方式自定义格式式化与解析

DateTimeFormatter formatter = new DateTimeFormatterBuilder()
        .appendValue(ChronoField.YEAR, 4, 10, SignStyle.EXCEEDS_PAD)
        .appendLiteral("年")
        .appendValue(ChronoField.MONTH_OF_YEAR, 2)
        .appendLiteral("月")
        .appendValue(ChronoField.DAY_OF_MONTH, 2)
        .appendLiteral("日")
        .parseCaseInsensitive()
        .toFormatter();
// 格式化
LocalDate date1 = LocalDate.of(2014, 3, 18);
String formattedDate = date1.format(formatter);
// 解析
LocalDate date2 = LocalDate.parse(formattedDate, formatter);

时区

1. java.time.ZoneId类：替换java.util.TimeZone的新时区类。

2. 举例

    a) 获取时区

// 北京时间
ZoneId beijingZone = ZoneId.of("Asia/Shanghai");
// 默认时区
ZoneId zoneId = TimeZone.getDefault().toZoneId();

    b) 设置时区

LocalDate date = LocalDate.of(2014, Month.MARCH, 18);
ZonedDateTime zdt1 = date.atStartOfDay(beijingZone);
LocalDateTime dateTime = LocalDateTime.of(2014, Month.MARCH, 18, 13, 45);
ZonedDateTime zdt2 = dateTime.atZone(beijingZone);
Instant instant = Instant.now();
ZonedDateTime zdt3 = instant.atZone(beijingZone);

 

作者：netoxi
出处：http://www.cnblogs.com/netoxi
本文版权归作者和博客园共有，欢迎转载，未经同意须保留此段声明，且在文章页面明显位置给出原文连接。欢迎指正与交流。