阅读数:119 评论数:0

一、Java8简介

1、添加了函数式编程、Stream、全新的日期处理类。

2、函数编程新加了一些概念：lambda表达式、函数式接口、函数引用、默认方法、Optional类（干掉空指针）等。

3、Stream中提供了一些流式处理集合的方法，并提供了一些归约、划分等类的方法。

4、日期中添加了ZoneDateTime、DataFormat等线程安全的方法类。

二、lambda简介

1、基本语法

（1）参数列表->表达式

（2）参数列表->{表达式}

需要注意的是lambda表达式默认隐含了return 关键字，在单个表达式中，我们无需再写return 关键字，也无需写花括号。

只有当表达式是一个集合的时候，才需要写花括号及return 关键字。

2、异常处理

将抛出的函数进行包装，使其不抛出异常。

public class Try {
   // 包装使其不抛出异常
   public static <T, R> Function<T, R> of(UncheckedFunction<T, R> mapper) {
      Objects.requireNonNull(mapper);
      return t -> {
         try {
            return mapper.apply(t);
         } catch (Exception e) {
            throw Exceptions.unchecked(e);
         }
      };
   }

   // 作为lambda的目标类型
   @FunctionalInterface
   public interface UncheckedFunction<T, R> {
      R apply(T t) throws Exception;
   }

}
List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5, 6, 0);
integers.forEach(Try.of(i -> System.out.println(50 / i)));

三、函数式接口

1、Java8函数式接口

// Function<T, R> -T作为输入，返回的R作为输出   
Function<String,String> fun = (x) -> {System.out.print(x+": ");return "Function";};  
System.out.println(fun.apply("hello world"));

//Predicate<T> -T作为输入，返回的boolean值作为输出
Predicate<String> pre = (x) ->{System.out.print(x);return false;};  
System.out.println(": "+pre.test("hello World"));

//Consumer<T> - T作为输入，执行某种动作但没有返回值   
Consumer<String> con = (x) -> {System.out.println(x);};  
con.accept("hello world");

//Supplier<T> - 没有任何输入，返回T   
Supplier<String> supp = () -> {return "Supplier";};  
System.out.println(supp.get());

//BinaryOperator<T> -两个T作为输入，返回一个T作为输出，对于“reduce”操作很有用   
BinaryOperator<String> bina = (x,y) ->{System.out.print(x+" "+y);return "BinaryOperator";};  
System.out.println(" "+bina.apply("hello ","world"));

2、自定义函数式

@FunctionalInterface

四、java8的时间

Java处理日期、日历和时间的方式一直为社区所诟病，比如SimpleDateFormat是非线程安全的。

java.time包下所有类都是线程安全的。

LocalDate、LocalTime、LocalDateTime、Instant为不可变对象，修改这些对象会返回一个副本。

1、方法前缀的含义，统一了API

of：静态工厂方法(用类名去调用)。
parse：静态工厂方法，关注于解析(用类名去调用)。
now： 静态工厂方法，用当前时间创建实例(用类名去调用)
get：获取某些东西的值。
is：检查某些东西的是否是true。
with：返回一个部分状态改变了的时间日期对象拷贝(单独一个with方法,参数为TemporalAdjusters类型)。
plus：返回一个时间增加了的、时间日期对象拷贝(如果参数是负数也能够有minus方法的效果)。
minus：返回一个时间减少了的、时间日期对象拷贝。
to：把当前时间日期对象转换成另外一个，可能会损失部分状态。
at：把这个对象与另一个对象组合起来，例如： date.atTime(time)。
format :根据某一个DateTimeFormatter格式化为字符串。

2、Instant，时间戳

它与我们常使用的System.currentTimeMillis()有些类似，不过Instant可以精确到纳秒，System.currentTimeMillis()只精确到毫秒。

Instant除了使用now()方法创建外，还可以通过ofEpochSecond方法创建：

Instant instant = Instant.ofEpochSecond(120, 100000);

ofEpochSecond()方法的第一个参数为秒，第二个参数为纳秒，上面的代码表示从1970-01-01 00:00:00开始后两分钟的10万纳秒的时刻。

3、Duration 计算两个"时间"的间隔

LocalDateTime from = LocalDateTime.of(2019, Month.JANUARY, 21, 15, 56, 0);    // 2019-01-21 15:56:00
LocalDateTime to = LocalDateTime.of(2019, Month.FEBRUARY, 21, 15, 56, 0);     // 2019-02-21 15:56:00
Duration duration = Duration.between(from, to);     // 表示从 2019-01-21 15:56:00 到 2019-02-21 15:56:00

long days = duration.toDays();              // 这段时间的总天数
long hours = duration.toHours();            // 这段时间的小时数
long minutes = duration.toMinutes();        // 这段时间的分钟数
long seconds = duration.getSeconds();       // 这段时间的秒数
long milliSeconds = duration.toMillis();    // 这段时间的毫秒数
long nanoSeconds = duration.toNanos();      // 这段时间的纳秒数

Duration对象还可以通过of()方法创建，该方法接收一个时间段长度和一个时间单位作为参数。

Duration duration1 = Duration.of(5, ChronoUnit.DAYS);       // 5天
Duration duration2 = Duration.of(1000, ChronoUnit.MILLIS);  // 1000毫秒

4、Period 计算两个“日期”的间隔

Period在概念上和Duration类似，区别在于Period是以年月日来衡量一个时间段，比如2年3个月6天。

Period period = Period.of(2, 3, 6);

由于Period是以年月日衡量时间段，所以between()方法只能接收LocalDate类型的参数

// 2019-01-21 到 2019-02-21 这段时间
Period period = Period.between(
                LocalDate.of(2019, 1, 21),
                LocalDate.of(2019, 2, 21));

5、ZoneId 时区

//获取所有合法的“区域/城市”字符串 :
Set<String> zoneIds = ZoneId.getAvailableZoneIds();
//获取系统默认时区 :
ZoneId systemZoneId = ZoneId.systemDefault();
//创建时区 ：
ZoneId shanghaiZoneId = ZoneId.of("Africa/Bangui");
//-------------------获取我国的时区
//Etc/GMT-8
ZoneId.of("Etc/GMT-8")
// GMT+8
ZoneId.of("GMT+8")
ZoneId.of("GMT+08")
ZoneId.of("GMT+08:00")
// UTC+8
ZoneId.of("UTC+8")
ZoneId.of("UTC+08")
ZoneId.of("UTC+08:00")
// UT+8
ZoneId.of("UT+8")
ZoneId.of("UT+08")
ZoneId.of("UT+08:00")
//+8
ZoneId.of("+8")
ZoneId.of("+08")
ZoneId.of("+08:00")
// 上海
ZoneId.of("Asia/Shanghai")
// 重庆
ZoneId.of("Asia/Chongqing")
ZoneId.of("Asia/Chungking")

6、LocalDate 只能获取年月日

（1）创建

//获取当前年月日  
LocalDate localDate = LocalDate.now();  
//构造指定的年月日  
LocalDate localDate1 = LocalDate.of(2020, 10, 10);  

（2）获取年、月、日、星期几

//获取年
int year = localDate.getYear();  
int year1 = localDate.get(ChronoField.YEAR);  
//获取月份
Month month = localDate.getMonth();  
int month1 = localDate.get(ChronoField.MONTH_OF_YEAR);  
//获取天
int day = localDate.getDayOfMonth();  
int day1 = localDate.get(ChronoField.DAY_OF_MONTH);  
//获取星期几
DayOfWeek dayOfWeek = localDate.getDayOfWeek();  
int dayOfWeek1 = localDate.get(ChronoField.DAY_OF_WEEK);  

7、LocalTime 只能获取小时 分 秒

（1）创建

 LocalTime localTime = LocalTime.of(13, 51, 10);  
 LocalTime localTime1 = LocalTime.now();  

（2）获取时分秒

//获取小时  
int hour = localTime.getHour();  
int hour1 = localTime.get(ChronoField.HOUR_OF_DAY);  
//获取分  
int minute = localTime.getMinute();  
int minute1 = localTime.get(ChronoField.MINUTE_OF_HOUR);  
//获取秒  
int second = localTime.getSecond();  
int second1 = localTime.get(ChronoField.SECOND_OF_MINUTE);  

8、LocalDateTime = LocalDate+LocalTime

（1）创建

LocalDateTime localDateTime = LocalDateTime.now();  
LocalDateTime localDateTime1 = LocalDateTime.of(2020, Month.SEPTEMBER, 10, 14, 46, 56);  
LocalDateTime localDateTime2 = LocalDateTime.of(localDate, localTime);  
LocalDateTime localDateTime3 = localDate.atTime(localTime);  
LocalDateTime localDateTime4 = localTime.atDate(localDate);  

（2）获取LocalDate

LocalDate localDate2 = localDateTime.toLocalDate();  

（3）获取LocalTime

LocalTime localTime2 = localDateTime.toLocalTime();  

（4）修改

LocalDateTime localDateTime = LocalDateTime.of(2020, Month.SEPTEMBER, 10,  
              14, 46, 56);  
//增加一年  
localDateTime = localDateTime.plusYears(1);  
localDateTime = localDateTime.plus(1, ChronoUnit.YEARS);  
//减少一个月  
localDateTime = localDateTime.minusMonths(1);  
localDateTime = localDateTime.minus(1, ChronoUnit.MONTHS);  


//使用with进行修改
//修改年为2020
localDateTime = localDateTime.withYear(2020);  
//修改为2022  
localDateTime = localDateTime.with(ChronoField.YEAR, 2022);  

9、DateTimeFormatter日期格式化字符串

定义的static的SimpleDateFormat可能会出现线程安全问题，需要每个线程单独new或者通过ThreadLocal来存放SimpleDateFormat，并且只能解析到毫秒

DateTimeFormatter是线程安全的，可以解析到纳秒。

public DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSSSSSZ");
dtf.format(ZonedDateTime.of(LocalDateTime.now(), ZoneId.systemDefault()));