函数参数说明:
formmatDate(参数1,参数2):
参数1：日期对象，不能直接传入时间戳

参数2：指定转化的日期格式
注：可以使用new Date(‘时间戳’)转化为普通日期对象
例如:
new Date(1321231326548)
//Mon Nov 14 2011 08:42:06 GMT+0800 (中国标准时间) {}

formatDate(new Date(1231321321217),'yyyy-MM-dd h:m:s')
//"2009-01-07 17:42:1"

函数体
function formatDate (date, fmt) {
  // 1.获取年份
  if (/(y+)/.test(fmt)) {
    fmt = fmt.replace(RegExp.$1, (date.getFullYear() + '').substr(4 - RegExp.$1.length));
  }
  // 2.获取月份
  let o = {
    'M+': date.getMonth() + 1,
    'd+': date.getDate(),
    'h+': date.getHours(),
    'm+': date.getMinutes(),
    's+': date.getSeconds()
  };
  for (let k in o) {
    if (new RegExp(`(${k})`).test(fmt)) {
      let str = o[k] + '';
      fmt = fmt.replace(RegExp.$1, (RegExp.$1.length === 1) ? str : padLeftZero(str));
    }
  }
  return fmt;
};
// 前导0
function padLeftZero (str) {
  return ('00' + str).substr(str.length);
};

使用
formatDate(new Date(),'yyyy-MM-dd hh:mm:ss') 
//"2020-09-21 20:14:13"

在java8之前我们在处理时间的时候都是用的Date,但它其实有很明显的缺点。

1、我们也会对日期做一些操作，比如加几天，加几分，当月的最后一天等等，有些计算比较复杂。

2、也会用SimpleDataFormat来格式化日期。但是SimpleDateFormat是线程不安全的。

所以现在一般都推荐使用LocalDateTime它是线程安全的，并且性能更好，代码更简洁。
一、示例
新时间日期API常用，重要对象主要有下面三个：

LocalDate：只含年月日的日期对象

LocalTime：只含时分秒的时间对象

LocalDateTime：同时含有年月日时分秒的日期对象

下面会通过示例来一一理解他们。

1、创建实例
 public static void main(String[] args) {
        //1、获取当前日期
        LocalDate now = LocalDate.now();
        System.out.println("当前时间 = " + now);
        //输出: 当前时间 = 2020-07-06

        //2、获取指定日期(参数依次 年、月、日）
        LocalDate localDate = LocalDate.of(2020, 6, 30);
        System.out.println("年月日 = " + localDate);
        //输出: 年月日 = 2020-06-30

        //3、获取当前时间
        LocalTime localTime = LocalTime.now();
        System.out.println("localTime = " + localTime);
        //输出: localTime = 22:32:45.994

        //4、获取指定时间（参数依次 时、分、秒、纳秒
        LocalTime localTimeOf = LocalTime.of(12, 24, 12, 4444);
        System.out.println("localTimeOf = " + localTimeOf);
        //输出: localTimeOf = 12:24:12.000004444

        //5、获取当前年月日,时分秒都有的日期
        LocalDateTime localDateTime = LocalDateTime.now();
        System.out.println("localDateTime = " + localDateTime);
        //输出: localDateTime = 2020-07-06T22:32:45.994

        //6、获取指定年月日,时分秒都有的日期(参数依次 年、月、日、时、分）
        LocalDateTime localDateTimeOf = LocalDateTime.of(2020, 7, 30, 12, 12);
        System.out.println("localDateTimeOf = " + localDateTimeOf);
        //输出: localDateTimeOf = 2020-07-30T12:12

         //7、日期+时间 组成 包含年月日,时分秒都有的日期
        LocalDateTime of = LocalDateTime.of(LocalDate.now(), LocalTime.now());
        System.out.println("of = " + of);
        //输出: of = 2020-07-06T22:32:45.995
    }

2、计算日期和时间

日期时间的加减

对于LocalDate,只有精度大于或等于日的加减，如年、月、日；

对于LocalTime,只有精度小于或等于时的加减，如时、分、秒、纳秒；

对于LocalDateTime,则可以进行任意精度的时间相加减；

加法操作
public static void main(String[] args) {
            
        //获取当前时间
        LocalDateTime localDateTime = LocalDateTime.now();
        System.out.println("当前时间 = " + localDateTime);

        //1、加1年
        LocalDateTime plusYears = localDateTime.plusYears(1L);
        System.out.println("plusYears = " + plusYears);
        //输出: plusYears = 2021-07-06T22:46:49.196
        
        //2、加1个月
        LocalDateTime plusMonths = localDateTime.plusMonths(1L);
        System.out.println("plusMonths = " + plusMonths);
        //输出: plusMonths = 2020-08-06T22:46:49.196
        
        //3、加一天
        LocalDateTime plusDays = localDateTime.plusDays(1L);
        System.out.println("plusDays = " + plusDays);
        //输出: plusDays = 2020-07-07T22:46:49.196
        
        //4、加1个小时
        LocalDateTime plusHours = localDateTime.plusHours(1L);
        System.out.println("plusHours = " + plusHours);
        //输出: plusHours = 2020-07-06T23:46:49.196
        
        //5、加10分
        LocalDateTime plusMinutes = localDateTime.plusMinutes(10L);
        System.out.println("plusMinutes = " + plusMinutes);
        //输出: plusMinutes = 2020-07-06T22:56:49.196
        
        //6、加200毫秒
        LocalDateTime plusSeconds = localDateTime.plusSeconds(200L);
        System.out.println("plusSeconds = " + plusSeconds);
        //输出: plusSeconds = 2020-07-06T22:50:09.196
    }

也可以用另外一种方式
	 LocalDateTime nextMonth = localDateTime.plus(1, ChronoUnit.MONTHS);
     LocalDateTime nextYear = localDateTime.plus(1, ChronoUnit.YEARS);
     LocalDateTime nextWeek = localDateTime.plus(1, ChronoUnit.WEEKS);

减法操作
public static void main(String[] args) {
        //获取当前时间
        LocalDateTime localDateTime = LocalDateTime.now();
        System.out.println("当前时间 = " + localDateTime);
        //输出: 当前时间 = 2020-07-06T22:53:38.264

        //1、减1年
        LocalDateTime minusYears = localDateTime.minusYears(1L);
        System.out.println("minusYears = " + minusYears);
        //输出: minusYears = 2019-07-06T22:53:38.264

        //2、减1个月
        LocalDateTime minusMonths = localDateTime.minusMonths(1L);
        System.out.println("minusMonths = " + minusMonths);
        //输出: minusMonths = 2020-06-06T22:53:38.264

        //3、减一天
        LocalDateTime minusDays = localDateTime.minusDays(1L);
        System.out.println("minusDays = " + minusDays);
        //输出: minusDays = 2020-07-05T22:53:38.264

        //4、减1个小时
        LocalDateTime minusHours = localDateTime.minusHours(1L);
        System.out.println("minusHours = " + minusHours);
        //输出: minusHours = 2020-07-06T21:53:38.264

        //5、减10分
        LocalDateTime minusMinutes = localDateTime.minusMinutes(10L);
        System.out.println("minusMinutes = " + minusMinutes);
        //输出: minusMinutes = 2020-07-06T22:43:38.264

        //6、减200毫秒
        LocalDateTime minusSeconds = localDateTime.minusSeconds(200L);
        System.out.println("minusSeconds = " + minusSeconds);
        //输出: minusSeconds = 2020-07-06T22:50:18.264
    }

也可以用另外一种方式
        LocalDateTime lastMonth = localDateTime.minus(1, ChronoUnit.MONTHS);
        LocalDateTime lastYear = localDateTime.minus(1, ChronoUnit.YEARS);
        LocalDateTime lastWeek = localDateTime.minus(1, ChronoUnit.WEEKS);

从代码中可以看到，这些 plus() 和 minus() 方法，是不会改变原date和time的实例的，返回的是新的实例。

3、比较日期和时间

当我们想知道给定的时间或日期是在另一个时间/日期之前还是之后，我们就可以用到**isBefore()和isAfter()**方法，如下所示：
public static void main(String[] args) {
       public static void main(String[] args) {
        LocalDate ld1 = LocalDate.of(2020, 7, 6);
        LocalDate ld2 = LocalDate.of(2020, 7, 7);

        boolean after = ld1.isAfter(ld2);
        System.out.println("ld1是否在ld2之后 = " + after);
        //输出:  ld1是否在ld2之后 = false

        boolean before = ld1.isBefore(ld2);
        System.out.println("ld1是否在ld2之前 = " + before);
        //输出:  ld1是否在ld2之前 = true

        LocalDateTime ldt1 = LocalDateTime.of(2020, 7, 7, 12, 12);
        LocalDateTime ldt2 = LocalDateTime.of(2020, 7, 7, 14, 12);

        boolean after1 = ldt1.isAfter(ldt2);
        System.out.println("ldt1是否在ldt2之后 = " + after1);
        //输出:  ldt1是否在ldt2之后 = false

        boolean before1 = ldt1.isBefore(ldt2);
        System.out.println("ldt1是否在ldt2之后 = " + before1);
        //输出:  ldt1是否在ldt2之后 = true

        //时间相减
        Duration duration = Duration.between(ldt1, ldt2);
        //两个时间差的天数
        long days = duration.toDays();
        System.out.println("days = " + days);
        //输出: days = 0

        //小时数差
        long hours = duration.toHours();
        System.out.println("hours = " + hours);
        //输出: hours = 2

        //分钟数差
        long minutes = duration.toMinutes();
        System.out.println("minutes = " + minutes);
        //输出: minutes = 120

        //毫秒数差
        long millis = duration.toMillis();
        System.out.println("millis = " + millis);
        //输出: millis = 7200000

        //纳秒数差
        long nanos = duration.toNanos();
        System.out.println("nanos = " + nanos);
        //输出: nanos = 7200000000000
    }

4、在String和日期之间转换

在以前使用java.util.Date的时候，我们一般使用 SimpleDateFormat 去完成日期/时间和字符串的转换，在新的日期时间API中，我们使用全新的 DateTimeFormatter。
如果你遵循ISO标准在日期/时间和字符串之间进行转换，那么这个事情会变得很容易，因为在 DateTimeFormatter 中，已经内置了ISO标准的格式。我们来看看代码

日期转字符串
public static void main(String[] args) {
        LocalDateTime ldt = LocalDateTime.now();
        System.out.println("ldt = " + ldt);
        //输出: ldt = 2020-07-07T18:32:34.757

        String format1 = ldt.format(DateTimeFormatter.ISO_DATE);
        System.out.println("format1 = " + format1);
        //输出: format1 = 2020-07-07

        String format2 = ldt.format(DateTimeFormatter.BASIC_ISO_DATE);
        System.out.println("format2 = " + format2);
        //输出:  format2 = 20200707
        
        String format3 = ldt.format(DateTimeFormatter.ISO_DATE_TIME);
        System.out.println("format3 = " + format3);
        //输出: format3 = 2020-07-07T18:32:34.757

        String format4 = ldt.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME);
        System.out.println("format4 = " + format4);
        //输出: format4 = 2020-07-07T18:32:34.757

        String format = ldt.format(DateTimeFormatter.ofPattern("d-M-y"));
        System.out.println("format = " + format);
        //输出: format = 7-7-2020

        String format5 = ldt.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        System.out.println("format5 = " + format5);
        //输出: format5 = 2020-07-07 18:32:34
        
        String format6 = ldt.format(DateTimeFormatter.ofPattern("yyyy年MM月dd日HH时mm分ss秒"));
        System.out.println("format6 = " + format6);
        //输出: format6 = 2020年07月07日18时32分34秒
      }

String转日期
public static void main(String[] args) {
        LocalDate ld = LocalDate.parse("2020-07-07");
        System.out.println("ld = " + ld);
        //输出: ld = 2020-07-07

        String str = "2020-07-07 22:24:33";
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        LocalDateTime ldt = LocalDateTime.parse(str,dateTimeFormatter);
        System.out.println("ldt = " + ldt);
        //输出: ldt = 2020-07-07T22:24:33
      }

5、其它

有的时候，你需要进行一些更加复杂的操作，比如，将日期调整到下个周日、下个工作日，或者是本月的最后一天。这时，你可以使用重载版本的with方法，向其传递一个提供了更多定制化选择的TemporalAdjuster对象，更加灵活地处理日期。

日期处理
public static void main(String[] args) {
        LocalDate date = LocalDate.parse("2020-07-07");
        //获取这个月的第一个周末的时间
        System.out.println(date.with(TemporalAdjusters.dayOfWeekInMonth(1, DayOfWeek.SUNDAY)));
        //输出: 2020-07-05

        //获取上个月的最后一周末的时间
        System.out.println(date.with(TemporalAdjusters.dayOfWeekInMonth(0, DayOfWeek.SUNDAY)));
        //输出: 2020-06-28

        //获取这个月的倒数第一个周末的时间
        System.out.println(date.with(TemporalAdjusters.dayOfWeekInMonth(-1, DayOfWeek.SUNDAY)));
        //输出: 2020-07-26

        //获取这个月的第一个周末的时间,上面的dayOfWeekInMonth更灵活,可以定义第几周
        System.out.println(date.with(TemporalAdjusters.firstInMonth(DayOfWeek.SUNDAY)));
        //输出: 2020-07-05

        //明年的第一天
        System.out.println(date.with(TemporalAdjusters.firstDayOfNextYear()));
        //输出: 2021-01-01
        
        //获取下个周5的时间
        System.out.println(date.with(TemporalAdjusters.next(DayOfWeek.FRIDAY)));
        //输出: 2020-07-10
        
        //获取本月最后一天
        System.out.println(date.with(TemporalAdjusters.lastDayOfMonth()));
        //输出: 2020-07-31

        //获取本月第一天
        System.out.println(date.with(TemporalAdjusters.firstDayOfMonth()));
        //输出: 2020-07-01
      }

其它还有许多,具体查看api

时间处理
public static void main(String[] args) {
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        //一天开始时间
        LocalDateTime todayStart = LocalDateTime.of(LocalDate.now(), LocalTime.MIN);
        String format = todayStart.format(dateTimeFormatter);
        System.out.println("format = " + format);
        //输出: format = 2020-07-07 00:00:00
        
        //一天结束时间
        LocalDateTime todayEnd = LocalDateTime.of(LocalDate.now(), LocalTime.MAX);
        String format1 = todayEnd.format(dateTimeFormatter);
        System.out.println("format1 = " + format1);
        //输出: format1 = 2020-07-07 23:59:59

        //一天中午时间
        LocalDateTime todayMid = LocalDateTime.of(LocalDate.now(), LocalTime.NOON);
        String format2 = todayMid.format(dateTimeFormatter);
        System.out.println("format2 = " + format2);
        //输出: format2 = 2020-07-07 12:00:00
      }

案例：本例是在react-native中格式化日期

1，引入moment



2，使用moment

例如：let startDate = moment('2018-09-27').format(YYYY-MM-DD);



moment使用详解：

格式化日期

当前时间：

moment().format('YYYY-MM-DD HH:mm:ss'); //2014-09-24 23:36:09 

今天是星期几：
moment().format('d'); //3 

转换当前时间的Unix时间戳：
moment().format('X'); 

相对时间

20120901相对当前日期是2年前

moment("20120901", "YYYYMMDD").fromNow(); //2 years ago      

7天前的日期：
moment().subtract('days',7).format('YYYY年MM月DD日'); //2014年10月01日

7天后的日期：
moment().add('days',7).format('YYYY年MM月DD日'); //2014年10月01日

9小时前的时间：
moment().subtract('hours',9).format('HH:mm:ss'); 

9小时后的时间：
moment().add('hours',9).format('HH:mm:ss'); 

moment.js提供了丰富的说明文档，使用它还可以创建日历项目等复杂的日期时间应用。我们日常开发中最常用的是格式化时间，下面我把常用的格式制作成表格说明供有需要的朋友查看
格式代码
			
说明
			
返回值例子
		
M
			
数字表示的月份，没有前导零
			
1到12
		
MM
			
数字表示的月份，有前导零
			
01到12
		
MMM
			
三个字母缩写表示的月份
			
Jan到Dec
		
MMMM
			
月份，完整的文本格式
			
January到December
		
Q
			
季度
			
1到4
		
D
			
月份中的第几天，没有前导零
			
1到31
		
DD
			
月份中的第几天，有前导零
			
01到31
		
d
			
星期中的第几天，数字表示
			
0到6，0表示周日，6表示周六
		
ddd
			
三个字母表示星期中的第几天
			
Sun到Sat
		
dddd
			
星期几，完整的星期文本
			
从Sunday到Saturday
		
w
			
年份中的第几周
			
如42：表示第42周
		
YYYY
			
四位数字完整表示的年份
			
如：2014 或 2000
		
YY
			
两位数字表示的年份
			
如：14 或 98
		
A
			
大写的AM PM
			
AM PM
		
a
			
小写的am pm
			
am pm
		
HH
			
小时，24小时制，有前导零
			
00到23
		
H
			
小时，24小时制，无前导零
			
0到23
		
hh
			
小时，12小时制，有前导零
			
00到12
		
h
			
小时，12小时制，无前导零
			
0到12
		
m
			
没有前导零的分钟数
			
0到59
		
mm
			
有前导零的分钟数
			
00到59
		
s
			
没有前导零的秒数
			
1到59
		
ss
			
有前导零的描述
			
01到59
		
X
			
Unix时间戳
			
1411572969
		
Moment.js 写法示例

Moment.js 是我用过的最好用的操作时间的工具库。它使得操作时间变得很简单。

创建

moment() // 当前时间
moment("1995-12-25") // 1995-12-25
moment("12-25-1995", "MM-DD-YYYY") // 1995-12-25
moment({ year :2010, month :3, day :5, hour :15, minute :10, second :3, millisecond :123})
moment(Date.now() - 24 * 60 * 60 * 1000) // 昨天
moment(new Date(2011, 9, 16)) // 2011-10-16

格式化

moment().format('YYYY年MM月DD日 HH:mm:ss') // 2016年11月11日 22:05:19
moment().format('hh:m:ss') // 10:5:19
moment().format('[YYYY]') // "YYYY"。[] 里的会原样输出。

转化成 Date 对象

moment().toDate()

获取/设置时间信息

moment().second() //获得 秒
moment().second(Number) //设置 秒。0 到 59
moment().minute() //获得 分
moment().minute(Number) //设置 分。0 到 59
// 类似的用法
moment().hour() // 小时
moment().date() // 一个月里的第几天
moment().day() // 星期几
moment().dayOfYear() // 一年里的第几天
moment().week() // 一年里的第几周
moment().month() // 第几个月
moment().quarter() // 一年里的第几个季度
moment().year() // 年
moment().daysInMonth() // 当前月有多少天

操作

moment().add(7, 'days') // 之后的第7天。第2个参数还可以是 'months', 'years' 等。注意是复数。
moment().add(7, 'd'）// 与上面一行代码的运行结果一样。
moment().subtract(1, 'months') // 上个月

moment().startOf('week') // 这周的第一天
moment().startOf('hour') // 等效与 moment().minutes(0).seconds(0).milliseconds(0)。
// 还支持 'year'，'month' 等

moment().endOf('week')

查询

// 早于
moment('2010-10-20').isBefore('2010-10-21') // true
moment('2010-10-20').isBefore('2010-12-31', 'year') // false
moment('2010-10-20').isBefore('2011-01-01', 'year') // true

// 是否相等
moment('2010-10-20').isSame('2010-10-20') // true
moment('2010-10-20').isSame('2009-12-31', 'year')  // false
moment('2010-10-20').isSame('2010-01-01', 'year')  // true

// 晚于
moment('2010-10-20').isAfter('2010-10-19') // true
moment('2010-10-20').isAfter('2010-01-01', 'year') // false
moment('2010-10-20').isAfter('2009-12-31', 'year') // true

// 是否在时间范围内
moment('2010-10-20').isBetween('2010-10-19', '2010-10-25') // true
moment('2010-10-20').isBetween('2010-01-01', '2012-01-01', 'year') // false
moment('2010-10-20').isBetween('2009-12-31', '2012-01-01', 'year') // true

moment().isLeapYear() // 是否是闰年

 

    本人使用日期格式  
dd/MM/yyyy  
但是我机器的日期格式是yyyy-mm-dd  
我使用DateTime.Parse（string），但是只能格式化类似于yyyy-mm-dd格式的日期。  
Parse有其他参数的重载，但是看来看去，我都不知道怎么搞定它，使之能够解析  
dd/MM/yyyy的日期格式，望高手解答  
---------------------------------------------------------------  
 
DateTimeFormatInfo  di  =  new  DateTimeFormatInfo();  
di.ShortDatePattern  =  "dd/MM/yyyy";  
DateTime  d  =  DateTime.Parse("12/12/2001",di);