jdk8 的主要新特性是 主要四个：Lambda,Stream,Date,新注解，前两者主要用于集合中。

.1 Lambda表达式和函数式接口

　　Lambda表达式（也称为闭包）是Java 8中最大和最令人期待的语言改变。它允许我们将函数当成参数传递给某个方法，或者把代码本身当作数据处理：函数式开发者非常熟悉这些概念。

很多JVM平台上的语言（Groovy、Scala等）从诞生之日就支持Lambda表达式，但是Java开发者没有选择，只能使用匿名内部类代替Lambda表达式。

Lambda的设计耗费了很多时间和很大的社区力量，最终找到一种折中的实现方案，可以实现简洁而紧凑的语言结构。

最简单的Lambda表达式可由逗号分隔的参数列表、->符号和语句块组成，例如：

Arrays.asList( "a", "b", "d" ).forEach( e -> System.out.println( e ) );

在上面这个代码中的参数e的类型是由编译器推理得出的，你也可以显式指定该参数的类型，例如：

Arrays.asList( "a", "b", "d" ).forEach( ( String e ) -> System.out.println( e ) );

如果Lambda表达式需要更复杂的语句块，则可以使用花括号将该语句块括起来，类似于Java中的函数体，例如：

Arrays.asList( "a", "b", "d" ).forEach( e -> {
    System.out.print( e );
    System.out.print( e );
} );

Lambda表达式可以引用类成员和局部变量（会将这些变量隐式得转换成final的），例如下列两个代码块的效果完全相同：

String separator = ",";
Arrays.asList( "a", "b", "d" ).forEach( 
    ( String e ) -> System.out.print( e + separator ) );

和

final String separator = ",";
Arrays.asList( "a", "b", "d" ).forEach( 
    ( String e ) -> System.out.print( e + separator ) );

Lambda表达式有返回值，返回值的类型也由编译器推理得出。如果Lambda表达式中的语句块只有一行，则可以不用使用return语句，下列两个代码片段效果相同：

Arrays.asList( "a", "b", "d" ).sort( ( e1, e2 ) -> e1.compareTo( e2 ) );

和

Arrays.asList( "a", "b", "d" ).sort( ( e1, e2 ) -> {
    int result = e1.compareTo( e2 );
    return result;
} );

Lambda的设计者们为了让现有的功能与Lambda表达式良好兼容，考虑了很多方法，于是产生了函数接口这个概念。函数接口指的是只有一个函数的接口，这样的接口可以隐式转换为Lambda表达式。java.lang.Runnable和java.util.concurrent.Callable是函数式接口的最佳例子。在实践中，函数式接口非常脆弱：只要某个开发者在该接口中添加一个函数，则该接口就不再是函数式接口进而导致编译失败。为了克服这种代码层面的脆弱性，并显式说明某个接口是函数式接口，Java 8 提供了一个特殊的注解@FunctionalInterface（Java 库中的所有相关接口都已经带有这个注解了），举个简单的函数式接口的定义：

@FunctionalInterface
public interface Functional {
    void method();
}

不过有一点需要注意，默认方法和静态方法不会破坏函数式接口的定义，因此如下的代码是合法的。

@FunctionalInterface
public interface FunctionalDefaultMethods {
    void method();

    default void defaultMethod() {            
    }        
}

Lambda表达式作为Java 8的最大卖点，它有潜力吸引更多的开发者加入到JVM平台，并在纯Java编程中使用函数式编程的概念。如果你需要了解更多Lambda表达式的细节，可以参考官方文档。

2 Optional

Java应用中最常见的bug就是空值异常。在Java 8之前，Google Guava引入了Optionals类来解决NullPointerException，从而避免源码被各种null检查污染，以便开发者写出更加整洁的代码。Java 8也将Optional加入了官方库。

Optional仅仅是一个容易：存放T类型的值或者null。它提供了一些有用的接口来避免显式的null检查，可以参考Java 8官方文档了解更多细节。

接下来看一点使用Optional的例子：可能为空的值或者某个类型的值：

Optional< String > fullName = Optional.ofNullable( null );
System.out.println( "Full Name is set? " + fullName.isPresent() );        
System.out.println( "Full Name: " + fullName.orElseGet( () -> "[none]" ) ); 
System.out.println( fullName.map( s -> "Hey " + s + "!" ).orElse( "Hey Stranger!" ) );

如果Optional实例持有一个非空值，则isPresent()方法返回true，否则返回false；orElseGet()方法，Optional实例持有null，则可以接受一个lambda表达式生成的默认值；map()方法可以将现有的Opetional实例的值转换成新的值；orElse()方法与orElseGet()方法类似，但是在持有null的时候返回传入的默认值。

上述代码的输出结果如下：

Full Name is set? false
Full Name: [none]
Hey Stranger!

再看下另一个简单的例子：

Optional< String > firstName = Optional.of( "Tom" );
System.out.println( "First Name is set? " + firstName.isPresent() );        
System.out.println( "First Name: " + firstName.orElseGet( () -> "[none]" ) ); 
System.out.println( firstName.map( s -> "Hey " + s + "!" ).orElse( "Hey Stranger!" ) );
System.out.println();

这个例子的输出是：

First Name is set? true
First Name: Tom
Hey Tom!

 2,stream

例子：

@Before
public void init() {
    random = new Random();
    stuList = new ArrayList<Student>() {
        {
            for (int i = 0; i < 100; i++) {
                add(new Student("student" + i, random.nextInt(50) + 50));
            }
        }
    };
}
 
public class Student {
    private String name;
    private Integer score;
    //-----getters and setters-----
}
 
//1列出班上超过85分的学生姓名，并按照分数降序输出用户名字
@Test
public void test1() {
    List<String> studentList = stuList.stream()
            .filter(x->x.getScore()>85)
            .sorted(Comparator.comparing(Student::getScore).reversed())
            .map(Student::getName)
            .collect(Collectors.toList());
    System.out.println(studentList);
}

对stream的操作

1）最常使用

     map：转换流，将一种类型的流转换为另外一种流

/**
 * map把一种类型的流转换为另外一种类型的流
 * 将String数组中字母转换为大写
 */
@Test
public void testMap() {
    String[] arr = new String[]{"yes", "YES", "no", "NO"};
    Arrays.stream(arr).map(x -> x.toLowerCase()).forEach(System.out::println);
}

  filter：过滤流，过滤流中的元素

@Test
public void testFilter(){
    Integer[] arr = new Integer[]{1,2,3,4,5,6,7,8,9,10};
    Arrays.stream(arr).filter(x->x>3&&x<8).forEach(System.out::println);
}

  flapMap：拆解流，将流中每一个元素拆解成一个流

 

/**
 * flapMap：拆解流
 */
@Test
public void testFlapMap1() {
    String[] arr1 = {"a", "b", "c", "d"};
    String[] arr2 = {"e", "f", "c", "d"};
    String[] arr3 = {"h", "j", "c", "d"};
   // Stream.of(arr1, arr2, arr3).flatMap(x -> Arrays.stream(x)).forEach(System.out::println);
    Stream.of(arr1, arr2, arr3).flatMap(Arrays::stream).forEach(System.out::println);
}

     sorted：对流进行排序

String[] arr1 = {"abc","a","bc","abcd"};
/**
 * Comparator.comparing是一个键提取的功能
 * 以下两个语句表示相同意义
 */
@Test
public void testSorted1_(){
    /**
     * 按照字符长度排序
     */
    Arrays.stream(arr1).sorted((x,y)->{
        if (x.length()>y.length())
            return 1;
        else if (x.length()<y.length())
            return -1;
        else
            return 0;
    }).forEach(System.out::println);
    Arrays.stream(arr1).sorted(Comparator.comparing(String::length)).forEach(System.out::println);
}
 
/**
 * 倒序
 * reversed(),java8泛型推导的问题，所以如果comparing里面是非方法引用的lambda表达式就没办法直接使用reversed()
 * Comparator.reverseOrder():也是用于翻转顺序，用于比较对象（Stream里面的类型必须是可比较的）
 * Comparator. naturalOrder()：返回一个自然排序比较器，用于比较对象（Stream里面的类型必须是可比较的）
 */
@Test
public void testSorted2_(){
    Arrays.stream(arr1).sorted(Comparator.comparing(String::length).reversed()).forEach(System.out::println);
    Arrays.stream(arr1).sorted(Comparator.reverseOrder()).forEach(System.out::println);
    Arrays.stream(arr1).sorted(Comparator.naturalOrder()).forEach(System.out::println);
}
 
/**
 * thenComparing
 * 先按照首字母排序
 * 之后按照String的长度排序
 */
@Test
public void testSorted3_(){
    Arrays.stream(arr1).sorted(Comparator.comparing(this::com1).thenComparing(String::length)).forEach(System.out::println);
}
public char com1(String x){
    return x.charAt(0);
}

对map排序

map根据value值倒序排序，下面给出工具类：

public <K, V extends Comparable<? super V>> Map<K, V> sortByValue(Map<K, V> map) {
Map<K, V> result = new LinkedHashMap<>();

map.entrySet().stream()
.sorted(Map.Entry.<K, V>comparingByValue()
.reversed()).forEachOrdered(e -> result.put(e.getKey(), e.getValue()));
return result;
}

当然如果我们想根据map的key进行排序，需要对上面的工具类进行小小的修改，代码如下：

public <K extends Comparable<? super K>, V > Map<K, V> sortByKey(Map<K, V> map) {
Map<K, V> result = new LinkedHashMap<>();

map.entrySet().stream()
.sorted(Map.Entry.<K, V>comparingByKey()
.reversed()).forEachOrdered(e -> result.put(e.getKey(), e.getValue()));
return result;
}

我们可以看到，如果我们需要根据key排序，就需要让key 继承 Comparable ，也就说我们需要对待排序的字段继承 Comparable接口。另一个问题就是，上面的这种写法排序效果是 降序排序，如果我们需要升序排序的话，只需要将上面的.reversed(）关键字限制去掉即可。

public <K, V extends Comparable<? super V>> Map<K, V> sortByValue(Map<K, V> map) {
Map<K, V> result = new LinkedHashMap<>();

map.entrySet().stream()
.sorted(Map.Entry.<K, V>comparingByValue()
).forEachOrdered(e -> result.put(e.getKey(), e.getValue()));
return result;
}

list转换为set( Collectors.toSet() )

List<Plantinfo> plantinfos = plantDao.selectList(qo);
Set<String> plantnoSet = plantinfos.stream().map(Plantinfo::getPlantno).collect(Collectors.toSet());

list转换为map( Collectors.toMap() )

List<Userinfo> userinfos = userService.selectByPlantnoIn();

Map<String, String> map = userinfos.stream().collect(Collectors.toMap(Userinfo::getPlantno, Userinfo::getUsername, (k1, k2) -> k2)); //如果有重复的键，后一个替换前一个

list放入一个新的list中( Collectors.toList() )

//skip就是舍弃stream前多少个元素，那么limit就是返回流前面多少个元素（如果流里元素少于该值，则返回全部）。然后开启并行处理。通过循环我们的分割list的目标就达到了，每次取到的sendList就是100，100这样子的。
List<BigScreenRankingResponse> responsesPart = list.stream().skip(page * perpage).limit(perpage).parallel().collect(Collectors.toList());
 

4、返回特定的结果集合（limit/skip）：
limit 返回 Stream 的前面 n 个元素；skip 则是扔掉前 n 个元素:
List<String> forEachLists = new ArrayList<>();
forEachLists.add("a");
forEachLists.add("b");
forEachLists.add("c");
forEachLists.add("d");
forEachLists.add("e");
forEachLists.add("f");
List<String> limitLists = forEachLists.stream().skip(2).limit(3).collect(Collectors.toList());

注意skip与limit是有顺序关系的，比如使用skip(2)会跳过集合的前两个，返回的为c、d、e、f,然后调用limit(3)会返回前3个，所以最后返回的c,d,e

Java8 Stream常用方法: https://blog.csdn.net/abcwywht/article/details/77991868

 

3、JDK8 新Date

3.1 jdk7 date 的缺点

3.1.1 所有的日期类都是可变的，因此他们都不是线程安全的，这是Java日期类最大的问题之一

3.1.2 Java的日期/时间类的定义并不一致，在java.util和java.sql的包中都有日期类，此外用于格式化和解析的类在java.text包中定义

3.1.3 java.util.Date同时包含日期和时间，而java.sql.Date仅包含日期，将其纳入java.sql包并不合理。另外这两个类都有相同的名字，这本身就是一个非常糟糕的设计。对于时间、时间戳、格式化以及解析，并没有一些明确定义的类。对于格式化和解析的需求，我们有java.text.DateFormat抽象类，但通常情况下，SimpleDateFormat类被用于此类需求

3.1.4 日期类并不提供国际化，没有时区支持，因此Java引入了java.util.Calendar和java.util.TimeZone类，但他们同样存在上述所有的问题

3.2 jdk8 date 的优点

3.2.1 不变性：新的日期/时间API中，所有的类都是不可变的，这对多线程环境有好处。

3.2.2 关注点分离：新的API将人可读的日期时间和机器时间（unix timestamp）明确分离，它为日期（Date）、时间（Time）、日期时间（DateTime）、时间戳（unix timestamp）以及时区定义了不同的类。

3.2.3 清晰：在所有的类中，方法都被明确定义用以完成相同的行为。举个例子，要拿到当前实例我们可以使用now()方法，在所有的类中都定义了format()和parse()方法，而不是像以前那样专门有一个独立的类。为了更好的处理问题，所有的类都使用了工厂模式和策略模式，一旦你使用了其中某个类的方法，与其他类协同工作并不困难。

3.2.4 实用操作：所有新的日期/时间API类都实现了一系列方法用以完成通用的任务，如：加、减、格式化、解析、从日期/时间中提取单独部分，等等。

3.2.5 可扩展性：新的日期/时间API是工作在ISO-8601日历系统上的，但我们也可以将其应用在非IOS的日历上。

3.3 jdk8 date 新增字段含义

Java.time包中的是类是不可变且线程安全的。新的时间及日期API位于java.time中，下面是一些关键类

java8 time包下关键字段解读

属性	含义
Instant	代表的是时间戳
LocalDate	代表日期，比如2020-01-14
LocalTime	代表时刻，比如12:59:59
LocalDateTime	代表具体时间 2020-01-12 12:22:26
ZonedDateTime	代表一个包含时区的完整的日期时间，偏移量是以UTC/  格林威治时间为基准的
Period	代表时间段
ZoneOffset	代表时区偏移量，比如：+8:00
Clock	代表时钟，比如获取目前美国纽约的时间

3.4 使用jdk8 java.time下的date

3.4.1 获取当前

Instant instant = Instant.now(); //获取当前时间戳

LocalDate localDate = LocalDate.now();  //获取当前日期

LocalTime localTime = LocalTime.now();  //获取当前时刻

LocalDateTime localDateTime = LocalDateTime.now();  //获取当前具体时间

ZonedDateTime zonedDateTime = ZonedDateTime.now();   //获取带有时区的时间

3.4.2 字符串转换

jdk8：
String str = "2019-01-11";
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
LocalDate localDate = LocalDate.parse(str, formatter);

jdk7:
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
try {
    Date date = simpleDateFormat.parse(str); 
} catch (ParseException e){ 
    e.printStackTrace();
}

DateTimeFormatter的包路径是java.time.format和LocalDate一样在java.time包下面，而SimpleDateFormat和Date是不同的。所以当判断引入路径的时候更容易判断。
当解析失败的时候，两个异常的抛出不一样，DateTimeFormatter抛出的是DateTimeParseException,继承自RuntimeException,而ParseException明显继承的是Exception。

3.4.3 Date转换LocalDate

import java.time.Instant;
import java.time.LocalDate;
import java.time.ZoneId;
import java.util.Date;

public class Test {

    public static void main(String[] args) {
        Date date = new Date();
        Instant instant = date.toInstant();
        ZoneId zoneId = ZoneId.systemDefault();

        // atZone()方法返回在指定时区从此Instant生成的ZonedDateTime。
        LocalDate localDate = instant.atZone(zoneId).toLocalDate();
        System.out.println("Date = " + date);
        System.out.println("LocalDate = " + localDate);
    }
}

3.4.5 LocalDate 转 Date

import java.time.LocalDate;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.util.Date;

public class Test {

    public static void main(String[] args) {
        ZoneId zoneId = ZoneId.systemDefault();
        LocalDate localDate = LocalDate.now();
        ZonedDateTime zdt = localDate.atStartOfDay(zoneId);

        Date date = Date.from(zdt.toInstant());

        System.out.println("LocalDate = " + localDate);
        System.out.println("Date = " + date);

    }
}

3.4.5 时间戳转LocalDateTime

long timestamp = System.currentTimeMillis();

Instant instant = Instant.ofEpochMilli(timestamp);

LocalDateTime.ofInstant(instant, ZoneId.systemDefault());

3.4.6 LocalDateTime转时间戳

LocalDateTime dateTime = LocalDateTime.now();

dateTime.toInstant(ZoneOffset.ofHours(8)).toEpochMilli();

dateTime.toInstant(ZoneOffset.of("+08:00")).toEpochMilli();

dateTime.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();

3.4.7 LocalDate常用方法总结

getYear()    int    获取当前日期的年份
getMonth()    Month    获取当前日期的月份对象
getMonthValue()    int    获取当前日期是第几月
getDayOfWeek()    DayOfWeek    表示该对象表示的日期是星期几
getDayOfMonth()    int    表示该对象表示的日期是这个月第几天
getDayOfYear()    int    表示该对象表示的日期是今年第几天
withYear(int year)    LocalDate    修改当前对象的年份
withMonth(int month)    LocalDate    修改当前对象的月份
withDayOfMonth(intdayOfMonth)    LocalDate   修改当前对象在当月的日期
isLeapYear()    boolean    是否是闰年
lengthOfMonth()    int    这个月有多少天
lengthOfYear()    int    该对象表示的年份有多少天（365或者366）
plusYears(longyearsToAdd)    LocalDate   当前对象增加指定的年份数
plusMonths(longmonthsToAdd)    LocalDate   当前对象增加指定的月份数
plusWeeks(longweeksToAdd)    LocalDate   当前对象增加指定的周数
plusDays(longdaysToAdd)    LocalDate   当前对象增加指定的天数
minusYears(longyearsToSubtract)    LocalDate    当前对象减去指定的年数
minusMonths(longmonthsToSubtract)    LocalDate    当前对象减去注定的月数
minusWeeks(longweeksToSubtract)    LocalDate    当前对象减去指定的周数
minusDays(longdaysToSubtract)    LocalDate    当前对象减去指定的天数
compareTo(ChronoLocalDateother)    int    比较当前对象和other对象在时间上的大小，返回值如果为正，则当前对象时间较晚，
isBefore(ChronoLocalDateother)    boolean   比较当前对象日期是否在other对象日期之前
isAfter(ChronoLocalDateother)    boolean   比较当前对象日期是否在other对象日期之后
isEqual(ChronoLocalDateother)    boolean   比较两个日期对象是否相等

项目中的具体使用

package com.chitic.supplywater.common.api.util;

import com.chitic.supplywater.common.api.request.DataDevDayRequest;

import java.math.BigDecimal;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.time.temporal.TemporalAdjusters;
import java.util.*;
import java.util.stream.Stream;

/**
 * @Description TODO 时间工具类
 * @Author GX
 * @Date 2019/7/1 9:45
 * @Version V1.0
 **/
public class DateUtil {

    public static final LocalDate NOW = LocalDate.now();

    /**
     * 获取当前时间的10位时间戳
     * @return
     */
    public static Long getDate(){
        //方式1
        //Long timestamp = Timestamp.valueOf(LocalDateTime.now()).getTime()/1000L;
        //方式2
        //Long timestamp = Instant.now().toEpochMilli()/1000L;
        //方式3
        Long timestamp = LocalDateTime.now().toEpochSecond(ZoneOffset.of("+8"));
        //方式4
        //Long startTimestamp = LocalDateTime.now().toInstant(ZoneOffset.of("+8")).toEpochMilli() / 1000L;
        //方式5
        //Long timestamp = System.currentTimeMillis()/1000;
        return timestamp;
    }

    /**
     * 获取当前时间的前60秒的10位时间戳
     * @return
     */
    public static Long getMinusSeconds(){
        LocalDateTime dataTime = LocalDateTime.now().minus(60, ChronoUnit.SECONDS);
//        Long dateTimestamp = dataTime.toInstant(ZoneOffset.of("+8")).toEpochMilli() / 1000L;
        Long dateTimestamp = dataTime.toEpochSecond(ZoneOffset.of("+8"));
        return dateTimestamp;
    }

    /**
     * 获取当前月的开始10位时间戳
     * @return
     */
    public static Long getMonths(){
        LocalDate localDate = LocalDate.now().plusMonths(0).with(TemporalAdjusters.firstDayOfMonth());
        Long startsTimestamp = LocalDateTime.of(localDate, LocalTime.MIN).toEpochSecond(ZoneOffset.of("+8"));
        return startsTimestamp;
    }

    /**
     * 获取N个月前的开始时间和10位时间戳
     * @param n
     * @return
     */
    public static Map<String,Object> getMinusYears(int n){
        Map<String,Object> map = new HashMap<>(2);
        String date = LocalDate.now().minusMonths(n).format(DateTimeFormatter.ofPattern("yyyy-MM"));
        map.put("date",date);
        LocalDateTime today_start = LocalDateTime.of(LocalDate.now().minusMonths(11), LocalTime.MIN);
        Long startTimestamp = today_start.toEpochSecond(ZoneOffset.of("+8"));
        map.put("startTimestamp",startTimestamp);
        return map;
    }

    /**
     * 获取N天前的开始时间和10位时间戳， 结束时间和时间戳
     * n = 0  即为今天
     * @param n
     * @return
     */
    public static Map<String,Object> getMinusDaysPar(int n){
        Map<String,Object> map = new HashMap<>(3);
        String date = LocalDate.now().minusDays(n).format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
        map.put("date",date);

        LocalDateTime today_start = LocalDateTime.of(LocalDate.now().minusDays(n), LocalTime.MIN);
        Long startTimestamp = today_start.toEpochSecond(ZoneOffset.of("+8"));
        map.put("startTimestamp",startTimestamp);

        LocalDateTime today_end = LocalDateTime.of(LocalDate.now().minusDays(n), LocalTime.MAX);
        Long endTimestamp = today_end.toEpochSecond(ZoneOffset.of("+8"));
        map.put("endTimestamp",endTimestamp);
        return map;
    }

    /**
     * 根据时间戳  获取当天的时间
     * @param timestamp
     * @return
     */
    public static Map<String,Object> getTimestampIsDate(Long timestamp){
        Map<String,Object> map = new HashMap<>(3);
        LocalDateTime localDateTime = LocalDateTime.ofEpochSecond(timestamp, 0, ZoneOffset.ofHours(8));
        LocalDate localDate = localDateTime.toLocalDate();
        String date = localDate.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
        map.put("date",date);
        LocalDateTime today_start = LocalDateTime.of(localDate, LocalTime.MIN);
        Long startTimestamp = today_start.toEpochSecond(ZoneOffset.of("+8"));
        map.put("startTimestamp",startTimestamp);

        LocalDateTime today_end = LocalDateTime.of(localDate, LocalTime.MAX);
        Long endTimestamp = today_end.toEpochSecond(ZoneOffset.of("+8"));
        map.put("endTimestamp",endTimestamp);
        return map;
    }

    /**
     * 当前时间戳和一个小时之前的时间戳
     * @return
     */
    public static Map<String,Long> getminusHours(){
        LocalDateTime localDateTime = LocalDateTime.now().minusHours(1);
        Long startTimestamp = localDateTime.toEpochSecond(ZoneOffset.of("+8"));
        Long endTimestamp = LocalDateTime.now().toEpochSecond(ZoneOffset.of("+8"));
        Map<String,Long> map = new HashMap<>(2);
        map.put("startTimestamp",startTimestamp);
        map.put("endTimestamp",endTimestamp);
        return map;
    }

    /**
     * 根据时间yyyy-mm-dd返回此月的开始时间戳和结束时间戳
     * @param date
     * @return
     */
    public static Map<String,Object> getToMonthTimeststamp(String date){
        Map<String,Object> map = new HashMap<>(3);
        LocalDate localDate = LocalDate.parse(date);
        map.put("date",date);
        LocalDate localDate1 = localDate.with(TemporalAdjusters.firstDayOfMonth());
        Long startTimestamp = LocalDateTime.of(localDate1, LocalTime.MIN).toEpochSecond(ZoneOffset.of("+8"));
        map.put("startTimestamp",startTimestamp);

        LocalDate localDate2 = localDate.with(TemporalAdjusters.lastDayOfMonth());
        Long endTimestamp = LocalDateTime.of(localDate2, LocalTime.MAX).toEpochSecond(ZoneOffset.of("+8"));
        map.put("endTimestamp",endTimestamp);
        return map;
    }

    /**
     * //时间戳转时间 LocalDateTime,格式化
     * @return
     */
    public static String getFormatDay(Long timestamp){
        LocalDateTime dateTime =LocalDateTime.ofEpochSecond(timestamp,0, ZoneOffset.ofHours(8));
        String format = dateTime.format(DateTimeFormatter.ofPattern("yyyyMMdd"));
        return format;
    }

    /**
     * 获取所传日期的前N天
     * @return
     */
    public static String getMinusDaysDate(String d, int n){
        LocalDate parse = LocalDate.parse(d);
        String date = parse.minusDays(n).format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
        LocalDate.now().minusDays(n).format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
        return date;
    }

    /**
     * 获取当前日期的前N天 yyyyMMdd
     * @return
     */
    public static String getFormatDate(int n){
        String date = LocalDate.now().minusDays(n).format(DateTimeFormatter.ofPattern("yyyyMMdd"));
        return date;
    }

    /**
     * 根据传来的日期获取n个月之前的yyyy-mm
     * @param date
     * @param n
     * @return
     */
    public static String getYearMonth(String date, int n){
        LocalDate localDate = LocalDate.parse(date+"-01");
        return localDate.minusMonths(n).format(DateTimeFormatter.ofPattern("yyyy-MM"));
    }

    /**
     * 当前时间的前n个月
     * @param n
     * @return
     */
    public static String getMinusMonths12(int n){
        return LocalDate.now().minusMonths(n).format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
    }

    /**
     * 根据时间yyyy-mm-dd返回此天前一天的开始时间戳和当前时间戳
     * @param date
     * @return
     */
    public static Map<String,Object> getToTimeststamp(String date,int n){
        Map<String,Object> map = new HashMap<>(3);
        LocalDate localDate = LocalDate.parse(date);

        LocalDate date1 = LocalDate.parse(date).minusDays(n);
        map.put("date",date1);
        LocalDateTime today_start = LocalDateTime.of(localDate.minusDays(n), LocalTime.MIN);
        Long startTimestamp = today_start.toEpochSecond(ZoneOffset.of("+8"));
        map.put("startTimestamp",startTimestamp);
        LocalDateTime now = LocalDateTime.now();
        long between = ChronoUnit.DAYS.between(date1, now);
        Long endTimestamp = now.minusDays(between).toEpochSecond(ZoneOffset.of("+8"));
        map.put("endTimestamp",endTimestamp);
        return map;
    }
    public static Map<String,Object> getTopToTimeststamp(String date, int n){
        Map<String,Object> map = new HashMap<>(3);
        LocalDate localDate = LocalDate.parse(date).minusDays(n);
        map.put("date",localDate);

        LocalDateTime today_start = LocalDateTime.of(localDate, LocalTime.MIN);
        Long startTimestamp = today_start.toEpochSecond(ZoneOffset.of("+8"));
        map.put("startTimestamp",startTimestamp);

        LocalDateTime today_end = LocalDateTime.of(localDate, LocalTime.MAX);
        Long endTimestamp = today_end.toEpochSecond(ZoneOffset.of("+8"));
        map.put("endTimestamp",endTimestamp);
        return map;
    }

    /**
     * 获取两个时间段的所有的天数
     * @param date
     * @return
     */
    public static List<String> getListDate(String date){
        LocalDate start = LocalDate.parse(date+"-01");
        LocalDate end = LocalDate.now().minusDays(1);
        //如果不是当月，返回所选月的所有天，  是当月，返回已过的天
        long between = ChronoUnit.DAYS.between(start, end);
        List<String> list = new ArrayList<>();
        Stream.iterate(start, a -> {
            return a.plusDays(1);
        }).limit(between + 1).forEach(f -> {
            list.add(f.toString().replace("-","" ));
        });
        return list;
    }

    //判断是否是当月
    public static Boolean isToMonth(String date){
        String yyyyMM = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMM"));
        if(yyyyMM.equals(date)){
            return true;
        }
        return false;
    }

    //判断是否是当年
    public static Boolean isToYear(String date){
        String yyyy = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyy"));
        if(yyyy.equals(date)){
            return true;
        }
        return false;
    }

/**
 * @Description TODO 获取本周的第一天或最后一天
 * @Param: [today, isFirst: true 表示开始时间，false表示结束时间]
 * @return: java.lang.String
 * @Exception:
 */
public static String getStartOrEndDayOfWeek(LocalDate today, Boolean isFirst){
    LocalDate resDate = LocalDate.now();
    if (today == null) {
        today = resDate;
    }
    DayOfWeek week = today.getDayOfWeek();
    int value = week.getValue();
    if (isFirst) {
        resDate = today.minusDays(value - 1);
    } else {
        resDate = today.plusDays(7 - value);
    }
    return resDate.toString();
}

/**
 * @Description TODO 获取本月的第一天或最后一天
 * @Param: [today, isFirst: true 表示开始时间，false表示结束时间]
 * @return: java.lang.String
 * @Exception:
 */
public static String getStartOrEndDayOfMonth(LocalDate today, Boolean isFirst){
    LocalDate resDate = LocalDate.now();
    if (today == null) {
        today = resDate;
    }
    Month month = today.getMonth();
    int length = month.length(today.isLeapYear());
    if (isFirst) {
        resDate = LocalDate.of(today.getYear(), month, 1);
    } else {
        resDate = LocalDate.of(today.getYear(), month, length);
    }
    return resDate.toString();
}

/**
 * @Description TODO 获取本季度的第一天或最后一天
 * @Param: [today, isFirst: true 表示开始时间，false表示结束时间]
 * @return: java.lang.String
 * @Exception:
 */
public static String getStartOrEndDayOfQuarter(LocalDate today, Boolean isFirst){
    LocalDate resDate = LocalDate.now();
    if (today == null) {
        today = resDate;
    }
    Month month = today.getMonth();
    Month firstMonthOfQuarter = month.firstMonthOfQuarter();
    Month endMonthOfQuarter = Month.of(firstMonthOfQuarter.getValue() + 2);
    if (isFirst) {
        resDate = LocalDate.of(today.getYear(), firstMonthOfQuarter, 1);
    } else {
        resDate = LocalDate.of(today.getYear(), endMonthOfQuarter, endMonthOfQuarter.length(today.isLeapYear()));
    }
    return resDate.toString();
}

/**
 * @Description TODO 获取本年的第一天或最后一天
 * @Param: [today, isFirst: true 表示开始时间，false表示结束时间]
 * @return: java.lang.String
 * @Exception:
 */
public static String getStartOrEndDayOfYear(LocalDate today, Boolean isFirst){
    LocalDate resDate = LocalDate.now();
    if (today == null) {
        today = resDate;
    }
    if (isFirst) {
        resDate = LocalDate.of(today.getYear(), Month.JANUARY, 1);
    } else {
        resDate = LocalDate.of(today.getYear(), Month.DECEMBER, Month.DECEMBER.length(today.isLeapYear()));
    }
    return resDate.toString();
}

    public static void main(String[] args) {
        //System.getProperties().list(System.out);
        //System.out.println(System.getProperty("user.name"));
        //System.out.println(System.getProperty("java.library.path"));
        int i = 2;
        System.out.println("i : " + (i<<3));
        System.out.println("当前时间戳："+ getDate());
        System.err.println("今天前的时间戳"+getMinusDaysPar(0));
        System.err.println("1天前的时间戳"+getMinusDaysPar(1));
        System.err.println("2天前的时间戳"+getMinusDaysPar(2));
        System.err.println("3天前的时间戳"+getMinusDaysPar(3));
        System.err.println("4天前的时间戳"+getMinusDaysPar(4));
        System.err.println("5天前的时间戳"+getMinusDaysPar(5));
        System.err.println("6天前的时间戳"+getMinusDaysPar(6));
        System.err.println("7天前的时间戳"+getMinusDaysPar(7));


        System.err.println("1个月前的时间戳"+getMinusYears(1));
        System.err.println("2个月前的时间戳"+getMinusYears(2));
        System.err.println("3个月前的时间戳"+getMinusYears(3));
        System.err.println("4个月前的时间戳"+getMinusYears(4));
        System.err.println("5个月前的时间戳"+getMinusYears(5));

    }

    public static Date getFromSeconds(Long seconds) {
        if (null == seconds) {
            return null;
        }
        return new Date(seconds * 1000L);
    }

}