jdk8 的主要新特性是 主要四个：Lambda,Stream,Date,新注解，前二者主要用于集合中。
.1 Lambda表达式和函数式接口
Lambda表达式（也称为闭包）是Java 8中最大和最使人期待的语言改变。它容许咱们将函数当成参数传递给某个方法，或者把代码自己看成数据处理：函数式开发者很是熟悉这些概念。php
不少JVM平台上的语言（Groovy、Scala等）从诞生之日就支持Lambda表达式，可是Java开发者没有选择，只能使用匿名内部类代替Lambda表达式。html
Lambda的设计耗费了不少时间和很大的社区力量，最终找到一种折中的实现方案，能够实现简洁而紧凑的语言结构。java
最简单的Lambda表达式可由逗号分隔的参数列表、->符号和语句块组成，例如：sql
Arrays.asList( "a", "b", "d" ).forEach( e -> System.out.println( e ) );
在上面这个代码中的参数e的类型是由编译器推理得出的，你也能够显式指定该参数的类型，例如：express
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的），例以下列两个代码块的效果彻底相同：swift
String separator = ","; Arrays.asList( "a", "b", "d" ).forEach( ( String e ) -> System.out.print( e + separator ) );
和api
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());
四、返回特定的结果集合（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经常使用方法: http://www.javashuo.com/article/p-phpubucf-bp.html
三、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; } 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); }}
相关文章
- 1. JDK8主要新特性介绍（一）
- 2. ES6 主要的新特性
- 3. JAVA 8 主要新特性 ----------------(六)集合Stream API
- 4. JDK 1.5 主要新特性
- 5. JDK 1.4 主要新特性
- 6. 新版本JDK的主要新特性，持续更新中...
- 7. Java8 和 Java9 的主要新特性
- 8. Java 9 的主要新特性
- 9. PHP7新增的主要特性
- 10. 【译】ES2019一些主要的新特性
- 更多相关文章...
- • RDF 主要 元素 - RDF 教程
- • MySQL 5.7的新特性（新功能） - MySQL教程
- • JDK13 GA发布：5大特性解读
- • 适用于PHP初学者的学习线路和建议
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
