介绍
 
Python 附带了各种有用的对象，可以直接使用。例如日期对象就是一个例子。由于日期和时间的复杂性，日期类型很难从头开始操作。所幸，Python 日期对象将日期转换成所需的字符串格式变得相当容易。
 
日期格式化是作为程序员的你最重要的任务之一。不同地区表示日期/时间的方法各不相同，因此你作为程序员的一大目标是以用户可读的方式显示日期值。
 
例如，你可能需要用数字格式表示日期值，如 “02-23-2018”。另一方面，你可能需要以更长的文本格式（如 “Feb 23,2018”）表示相同的日期。在另一种情况下，你可能希望从数字格式的日期值中提取出字符串格式的月份。
 
在本文中，我们将研究不同类型的日期对象及其功能。
 
datetime 模块
 
正如你猜到的， Python 的 datetime 模块包含可用于处理日期和时间值的方法。要使用这个模块，我们得先通过以下 import 语句将其导入：
 
import datetime
 
我们可以使用 time 类表示时间值。时间类的属性包括小时、分钟、秒和微秒。
 
time 类的参数是可选的。尽管不指定任何参数，你将获得 0 的时间（对象），但这大多数时候不太可能是你需要的。
 
例如，要初始化值为 1 小时、10 分种、20 秒、13 微秒的时间对象，我们可以运行以下命令：
 
t = datetime.time(1, 10, 20, 13)
 
让我们使用 print 功能来查看时间：
 
print(t)
 
输出：
 
01:10:20.000013
 
你可能只需要查看小时、分钟、秒或者微秒，您可以像下边这么做：
 
print('hour:', t.hour)
 
输出：
 
hour: 1
 
可以按照如下方式检索上述时间（对象）的分钟、秒或者微秒:
 
'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：579817333 
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
print('Minutes:', t.minute)
print('Seconds:', t.second)
print('Microsecond:', t.microsecond)
 
输出：
 
Minutes: 10
Seconds: 20
Microseconds: 13
 
日历日期指可以通过 date 类表示。示例具有的属性有年、月和日。
 
让我们来调用 today 方法来查看今天的日期：
 
'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：579817333 
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
import datetime

today = datetime.date.today()
print(today)
 
输出：
 
2018-09-15
 
代码将返回今天的日期，因此你看到的输出取决于你运行脚本的日期。
 
现在我们调用 ctime 方法以另一种格式打印日期：
 
print('ctime:', today.ctime())
 
输出：
 
ctime: Sat Sep 15 00:00:00 2018
 
ctime 方法会使用比我们之前看到的示例更长的日期时间格式。此方法主要用于将 Unix 时间（从 1970 年 1 月 1 日以来的秒数）转换为字符串格式。
 
以下是我们如何使用 date 类显示年份，月份和日期：
 
'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：579817333 
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
print('Year:', today.year)
print('Month:', today.month)
print('Day :', today.day)
 
输出
 
Year: 2018

Month: 9
Day : 15
 
使用 strftime 将日期转换为字符串
 
既然你已经知道如何创建时间和日期对象，那么让我们学习如何将它们格式化为更易读的字符串。
 
为此，我们将使用 strftime 方法。这个方法可以帮助我们将日期对象转换为可读字符串。它需要两个参数，语法如下所示：
 
time.strftime(format, t)
 
第一个参数是格式字符串（以何种格式显示时间日期，感谢 rocheers 提醒），第二个参数是格式化的时间，可选值。
 
这个方法也可以在 datetime 对象上直接调用。如以下示例所示：
 
'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：579817333 
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
import datetime

x = datetime.datetime(2018, 9, 15)

print(x.strftime("%b %d %Y %H:%M:%S"))
 
输出：
 
Sep 15 2018 00:00:00
 
我们使用以下字符串来格式化日期:
 
%b: 返回月份名称的前三个字符。在我们的例子中，它返回 “Sep”。
%d: 返回本月的日期，从 1 到 31。在我们的例子中，它返回 “15”。
%Y: 返回四位数格式的年份。在我们的例子中，它返回 “2018”。
%H: 返回小时。在我们的例子中，它返回 “00”。
%M: 返回分钟，从 00 到 59。在我们的例子中，它返回 “00”。
%S: 返回秒，从 00 到 59。在我们的例子中，它返回 “00”。
 
我们没有时间（对象），因此时间值都是 “00”。下面的例子显示了如何格式化时间：
 
'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：579817333 
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
import datetime

x = datetime.datetime(2018, 9, 15, 12, 45, 35)

print(x.strftime("%b %d %Y %H:%M:%S"))
 
输出：
 
Sep 15 2018 12:45:35
 
完整的字符代码列表
 
除了上面给出的字符串外，strftime 方法还使用了其他几个指令来格式化日期值：
 
%a: 返回工作日的前三个字符，例如 Wed。
%A: 返回返回工作日的全名，例如 Wednesday。
%B: 返回月份的全名，例如 September。
%w: 返回工作日作为数字，从 0 到 6，周日为 0。
%m: 将月份作为数字返回，从 01 到 12。
%p: 返回 AM/PM 标识。
%y: 返回两位数格式的年份，例如，”18“ 而不是 ”2018“。
%f: 返回从 000000 到 999999 的微秒。
%Z: 返回时区。
%z: 返回 UTC 偏移量。
%j: 返回当年的日期编号，从 001 到 366。
%W: 返回年份的周数，从 00 到 53。星期一被记为一周第一天。
%U: 返回年份的周数，从 00 到 53。星期日被记为一周第一天。
%c: 返回本地日期和时间版本。
%x: 返回本地日期版本。
%X: 返回本地时间版本。
 
 
译者备注：原文中的是 weekday，在查了一些资料后翻译成 “工作日”，但是考虑以下示例：
 
from datetime import datetime
x  = datetime.now()
x.strftime("%A")
 
输出：
 
'Sunday'
 
 
请考虑以下示例：
 
'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：579817333 
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
import datetime

x = datetime.datetime(2018, 9, 15)

print(x.strftime('%b/%d/%Y'))
 
输出：
 
Sep/15/2018
 
以下是你只获取月份的方法：
 
print(x.strftime('%B'))
 
输出：
 
September
 
让我们只展示年份：
 
print(x.strftime('%Y'))
 
输出：
 
2018
 
在这个例子中，我们使用了格式化代码 %Y。请注意，它的 Y 是大写的，现在使用小写写：
 
print(x.strftime('%y'))
 
输出：
 
18 
 
这次省略了年份中前两位数字。如你所见，使用这些格式化代码，你可以用你想要的任何方式表示日期时间。
 
使用 strptime 将字符串转换成日期
 
strftime 方法帮助我们将日期对象转换为可读的字符串，strptime 恰恰相反。它作用于字符串，并将它们转换成 Python 可以理解的日期对象。
 
这是这个方法的语法：
 
datetime.strptime(string, format)
 
string 参数是我们转换成日期格式的字符串值。format 参数是指定转换后日期采用的格式的指令。
 
例如，如果我们需要将字符串 “9/15/18” 转换成 datetime 对象。
 
我们先导入 datetime 模块，我们将使用 from 关键字以便能够在没有点格式的情况下引用模块中特定的函数：
 
from datetime import datetime
 
然后我们可以用字符串形式定义日期：
 
str = '9/15/18'
 
在将字符串转换为实际的 datetime 对象之前，Python 无法将上述字符串理解为日期时间。我们可以通过调用 strptime 方法成功完成：
 
执行以下命令转换字符串：
 
date_object = datetime.strptime(str, '%m/%d/%y')
 
现在让我们调用 print 函数用 datetime 格式显示字符串：
 
print(date_object)
 
输出：
 
2018-09-15 00:00:00
 
如你所见，转换成功！
 
你可以看到正斜杠 “/” 用于分隔字符串的各个元素。这告诉 strptime 方法我们的日期是什么格式，我们的例子中是用 “/” 作为分隔符。
 
但是，如果月/日/年被 “-” 分隔怎么办？你应该这么处理：
 
from datetime import datetime

str = '9-15-18'
date_object = datetime.strptime(str, '%m-%d-%y')

print(date_object)
 
输出：
 
2018-09-15 00:00:00
 
再一次，多亏了格式说明符，strptime 方法能够解析我们的日期并将其转换为日期对象。
 
结论
 
在本文中，我们研究了如何在 Python 中格式化日期。我们看到 Python 中的 datetime 模块如何操作日期和时间值。该模块包含了许多操作日期时间的类，比如，time 类用于表示时间值，而 date 类用来表示日历日期值。

函数参数说明:
 
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"

标题 使用DateTimeFormatter对象实现格式化时间日期
 
要求:
 
用DateTimeFormatter实现: 用扫描器获取输入的时间(年月日时分),这个时间的格式是常用的格式,然后格式化这个时间,把格式化的时间输出到控制台,可以在控制台重复输入时间.格式化的时间参考企业微信聊天记录的展示时间
 
实现步骤如下:
 
测试类测试代码
 
package date;

import java.util.Scanner;

/**
 * 测试日期格式化<br>
 * 2019年12月24日 下午2:26:01
 * 
 * @author 王留闯
 * @version 1.0
 */
public class Test {
//	用扫描器获取输入的时间(年月日时分),这个时间的格式是常用的格式,
//	然后格式化这个时间,把格式化的时间输出到控制台,
//	可以在控制台重复输入时间.格式化的时间参考企业微信聊天记录的展示时间

	static {
		System.out.println(Instruction.START.getOrder());
	}

	/**
	 * 程序入口
	 * 
	 * @param args 入口参数
	 */
	public static void main(String[] args) {

		// 获取控制台输入
		Scanner scanner = new Scanner(System.in);
		// 判断是否有下一行输入
		while (scanner.hasNextLine()) {
			// 获取下一行的输入
			String currentDate = scanner.nextLine().trim();
			if (Order.EXIT.ContainsOrder(currentDate)) {
				System.out.println("程序结束,欢迎你下次使用");
				
				scanner.close();
				System.exit(0);
			} else {
				// 处理日期时间的方法
				System.out.println(DateTimeFormat.datetimeFormat(currentDate));
			}
			// 提示语句
			System.out.println(Instruction.DATES.getOrder());
		}
	}

}
 
该枚举类用于获取退出命令
 
package date;

import java.util.Arrays;

/**
 * 用于退出命令<br>
 * 2020年1月10日 上午8:34:48
 * 
 * @author 王留闯
 * @version 1.0
 */
public enum Order {

	/**
	 * 退出扫描器
	 */
	EXIT("退出", "exit", "结束程序");
	/**
	 * 命令的名字
	 */
	private final String[] exit;

	/**
	 * 使用私有构造器初始化退出指令
	 * 
	 * @param exit
	 */
	private Order(String... exit) {
		this.exit = exit;
	}

	/**
	 * 返回命令的名字
	 * 
	 * @return
	 */
	public String getExit() {
		return Arrays.toString(exit);
	}

	/**
	 * 用于和控制输入的指令进行匹配
	 * 
	 * @param currentString 控制台输入的指令
	 * @return 处理结果
	 */
	public boolean ContainsOrder(String currentString) {
		// 使用for循环遍历扫描器输入的字符串是否和退出命令匹配
		for (int i = 0; i < exit.length; i++) {
			// 控制台输入的字符串和退出字符串匹配返回true;
			if (currentString.equals(exit[i])) {
				return true;
			}
		}
		// 如果都不匹配返回false;
		return false;
	}
}
 
用于获取提示信息
 
package date;

/**
 * 用于提示信息<br>
 * 2019年12月24日 下午7:41:10
 * 
 * @author 王留闯
 * @version 1.0
 */
public enum Instruction {
	/**
	 * 开始提示语句
	 */
	START("欢迎使用时间日期格式化器,请你输入合法日期:\n退出指令请输入:" + Order.EXIT.getExit()),
	/**
	 * 日期每行提示语句
	 */
	DATES("\"请输入合法日期:\n\t退出输入:" + Order.EXIT.getExit()),

	/**
	 * 日期不合法
	 */
	INVALID_DATE("日期不合法"),
	/**
	 * 时间不合法
	 */
	INVALID_TIME("时间不合法"),
	/**
	 * 日期长度不合法
	 */
	INVALID_DATE_LENGTH("日期长度不合法"),
	/**
	 * 时间长度不合法
	 */
	INVALID_TIME_LENGTH("时间长度不合法"),
	/**
	 * 时间日期之间必须以空格分隔
	 */
	NOT_CONTAINS_BLANK("时间日期之间必须以空格分隔");
	/**
	 * 指令
	 */
	private String order;

	/**
	 * 构造器初始化成员变量
	 * 
	 * @param order 指令
	 */
	private Instruction(String order) {
		this.order = order;
	}

	/**
	 * 获取指令
	 * 
	 * @return 返回指令
	 */
	public String getOrder() {
		return order;
	}

}
 
出里日期时间并对日期时间进行分割处理
 
package date;

/**
 * 格式器日期时间<br>
 * 2019年12月24日 下午5:12:26
 * 
 * @author 王留闯
 * @version 1.0
 */
public class DateTimeFormat {
	

	/**
	 * 提供私有构造器
	 */
	private DateTimeFormat() {
	};

	/**
	 * 格式化时间日期
	 * 
	 * @param currentdateTime 需要被格式化的时间
	 * @return 处理结果
	 */
	public static String datetimeFormat(String currentdateTime) {
		int length = currentdateTime.length();
		// 日期长度不合法
		if (length > 16 || length < 12) {
			return Instruction.INVALID_DATE_LENGTH.getOrder();
			// 时间日期必须以空格分隔
		} else if (!currentdateTime.contains(" ")) {
			return Instruction.NOT_CONTAINS_BLANK.getOrder();
		} else {
			// 对传入的日期进行分割
			String[] DateTime = currentdateTime.split(" ");
			if (DateTime.length == 2) {
				String date = DateTime[0];// 日期
				String time = DateTime[1];// 时间
				DateFormat d1 = DateFormat.getInstance();// 获取日期对象
				TimeFormat t1 = TimeFormat.getInstance();// 获取时间对象
				String dateresult = d1.dateFormat(date);// 格式化日期
				String timeresult = t1.timeFormat(time);
				// 判断返回的指令是否是错误提示
				for (int i = 0; i < Instruction.values().length; i++) {
					String order = Instruction.values()[i].getOrder();
					if (order.equals(dateresult) || order.equals(timeresult)) {
						return order;
					}
				}
				// 返回日期时间
				return "格式化时间结果:" + dateresult + " " + timeresult;
			} else {
				// 否则返回日期错误
				return Instruction.NOT_CONTAINS_BLANK.getOrder();
			}
		}
	}

}
 
对日期进行分割处理,处理后并使用DateTimeFormatter将日期格式化成字符串
 
package date;

import java.time.DayOfWeek;
import java.util.Arrays;
import java.util.Calendar;

import static java.util.Calendar.YEAR;
import static java.util.Calendar.MONTH;
import static java.util.Calendar.DATE;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;

/**
 * 格式化日期<br>
 * 2019年12月25日 上午9:53:30
 * 
 * @author 王留闯
 * @version 1.0
 */
public class DateFormat {
	/**
	 * 输入年
	 */
	private int year;
	/**
	 * 输入月
	 */
	private int month;
	/**
	 * 输入日
	 */
	private int date;
	/**
	 * 获取当前日期对象
	 */
	private Calendar calendar = Calendar.getInstance();
	/**
	 * 懒汉式创建单例类对象
	 */
	private static DateFormat instance = new DateFormat();
	/**
	 * 大月
	 */
	private int[] BigMonth = new int[] { 1, 3, 5, 7, 8, 10, 12 };
	/**
	 * 小月
	 */
	private int[] SmallMonth = new int[] { 4, 6, 9, 11 };

	/**
	 * 提供私有构造其器不让外界任意调用就该对象
	 */
	private DateFormat() {

	}

	/**
	 * 提供静态方法用于获取该类对象
	 * 
	 * @return 实例
	 */
	public static DateFormat getInstance() {
		return instance;
	}

	/**
	 * 获取年
	 * 
	 * @return 年
	 */
	public int getYear() {
		return year;
	}

	/**
	 * 设置年
	 * 
	 * @param year 年
	 * @return 处理结果
	 */
	public boolean setYear(int year) {
		return year >= 1970 && year <= this.calendar.get(YEAR) ? (this.year = year) != 0 : false;
	}

	/**
	 * 获取月
	 * 
	 * @return 月
	 */
	public int getMonth() {
		return month;
	}

	/**
	 * 设置月
	 * 
	 * @param month 月
	 * @return 处理结果
	 */
	public boolean setMonth(int month) {
		return month > 0 && month <= 12 ? (this.month = month) != 0 : false;
	}

	/**
	 * 获取日
	 * 
	 * @return 输入日
	 */
	public int getDate() {
		return date;
	}

	/**
	 * 设置日
	 * 
	 * @param date 日
	 * @return 处理结果
	 */
	public boolean setDate(int date) {
		return date > 0 && date <= 31 ? (this.date = date) != 0 : false;
	}

	/**
	 * 分割日期
	 * 
	 * @param regex 需要分割的日期
	 * @return 返回分割后的元素
	 */
	private String[] split(String regex) {
		String r = "[\\./,-]{1}";
		String s = "\\d{1,2}";

		return regex.matches("\\d{4}" + "(" + r + s + "){2}") ? regex.split(r) : new String[0];
	}

	/**
	 * 判断传日期全部是数字
	 * 
	 * @param date 日期
	 * @return 处理结果
	 */
	private boolean charArray(String date) {
		// 将日期转换成char数组
		char[] c = date.toCharArray();
		// 是否for循环遍历数组是否全是数字
		for (int i = 0; i < c.length; i++) {
			// 在ASCLL码中0-9数字代表48-57
			if (c[i] < 48 || c[i] > 57) {
				return false;
			}
		}
		return true;
	}

	/**
	 * 用于判断年月日是否合法并初始化
	 * 
	 * @param date 日期
	 * @return 处理结果
	 */
	private boolean datelegal(String date) {
		// 将日期进行分割
		String[] currentDate = this.split(date);
		// 判断把年月日是否是数字
		for (int i = 0; i < currentDate.length; i++) {
			if (this.charArray(currentDate[i]) == false || currentDate[i].equals("")) {
				return false;
			}
		}
		// 判断分割后的日期是否是3份
		if (currentDate.length != 3) {
			return false;
			// 对年月日进行初始化
		} else if (initDate(Integer.valueOf(currentDate[0]), Integer.valueOf(currentDate[1]),
				Integer.valueOf(currentDate[2]))) {
			return true;
		} else {
			return false;
		}
	}

	/**
	 * 初始化年月日
	 * 
	 * @param year  输入年
	 * @param month 输入月
	 * @param day   输入天
	 * @return 处理结果
	 */
	private boolean initDate(int year, int month, int day) {
		return setMonth(month) && setYear(year) && setDate(day);
	}

	/**
	 * 格式化日期
	 * 
	 * @param currentDate 当前输入日期
	 * @return 处理日期结果
	 */
	public String dateFormat(String currentDate) {
		// 判断传入日期是否合法
		if (this.datelegal(currentDate) == false) {
			return Instruction.INVALID_DATE.getOrder();
			// 判断月份天数是否合法
		} else if (MonthDateFormat() == false) {
			return Instruction.INVALID_DATE.getOrder();
		}
		// 用于代表模式字符串参数
		String patternString = null;
		// 创建模式字符串创建DateTimeFormatter格式器
		DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("y-M-d");
		// 通过parse()方法将日期字符串解析成日期对象
		LocalDate localDate = LocalDate.parse(currentDate, dateTimeFormatter);
		// 判断传入年和当前年是否是同一年
		if (year == this.calendar.get(YEAR)) {
			// 判断传入时间是否和当前时间是同一月,Calendar月份是重0开始的所以获取Calendar对象月份+就是当前月
			if (month == this.calendar.get(MONTH) + 1) {
				int day = this.calendar.get(DATE);// 获取当前天
				// 输入时间等于当前时间说明是当前天
				if (date == day) {
					patternString = "今天";
					// 输出时间加一天等于当前时间说明是昨天
				} else if (date + 1 == day) {
					patternString = "昨天";
					// 输入日期减一天等于当前时间说明是明天
				} else if (date - 1 == day) {
					patternString = "明天";
					// 输入天数减去当前时间大于等于-7并且小于等于负二说明是昨天之前返回星期
				} else if (date - day >= -7 && date - day <= -2) {
					patternString = "E";
				} else {
					// 返回月日
					patternString = "M月d日";
				}
			} else {
				// 相同年返回月日
				patternString = "M月d日";
			}
		} else {
			// 不同年返回年月日
			patternString = "y年M月d日";
		}
		// 使用模式字符串创建DateTimrFormatter对象
		DateTimeFormatter formatter = DateTimeFormatter.ofPattern(patternString);
		// 根据模式字符串将解析后的时间再次解析成字符串
		String date = localDate.format(formatter);
		// 返回适用DateTimeFormatter解析后的字符串
		return date;

	}

	/**
	 * 格式化日期时间判断传入时间是否合法
	 * 
	 * @return 处理结果
	 */
	private boolean MonthDateFormat() {
		// 判断大月
		if (Arrays.binarySearch(BigMonth, month) >= 0 && date > 0 && date <= 31) {
			return true;
			// 判断小月
		} else if (Arrays.binarySearch(SmallMonth, month) >= 0 && date > 0 && date <= 30) {
			return true;
			// 判断闰年
		} else if ((month == 2 && year % 400 == 0 && date > 0 && date <= 29)
				|| (month == 2 && year % 4 == 0 && year % 100 != 0 && date > 0 && date <= 29)) {
			return true;
//			判断平年
		} else if (month == 2 && year % 4 != 0 && date > 0 && date <= 28) {
			return true;
		} else {
			return false;
		}
	}
}

 
使用正则表达式匹配时间,并使用DateTimeFormatter格式化成时间字符串
 
package date;

import java.nio.channels.NonWritableChannelException;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.util.Spliterator;
/**
 * 格式化时间<br>
 * 2019年12月26日 上午10:26:29
 * 
 * @author 王留闯
 * @version 1.0
 */
public class TimeFormat {

	/**
	 * 创建单列类对象
	 */
	private static TimeFormat instance = new TimeFormat();

	/**
	 * 提供私有构造器,不让外界随意创建对象
	 */
	private TimeFormat() {

	}

	/**
	 * 用于获取单列类对象
	 * 
	 * @return 对象
	 */
	public static TimeFormat getInstance() {
		return instance;
	}

	/**
	 * 初始化时间
	 * 
	 * @param time 需要初始化的时间
	 * @return 处理后的时间
	 */
	public String timeFormat(String time) {
		// 使用正则表达式判断传入时间是否合法
		if (!time.matches("(^[0-1]?[0-9]|^[2][0-3]):[0-5]?[0-9]")) {
			return Instruction.INVALID_TIME.getOrder();
		} else {
			// 使用模式字符串解析传入的时间对象
			DateTimeFormatter formatter = DateTimeFormatter.ofPattern("H:m");
			// 将传入的时间解析成日期
			LocalTime localTime = LocalTime.parse(time, formatter);
			// 根据需要的结果格式化日期对象
			DateTimeFormatter formatter2 = DateTimeFormatter.ofPattern("a HH:mm");
			// 再次将获取到的时间将转换成字符串
			String timeString = localTime.format(formatter2);
//            返回得到的时间
			return timeString;
		}
	}

}

1. Date 对象方法
 
toLocaleString()
根据本地时间格式，把 Date 对象转换为字符串。  "2018/10/8 上午8:00:00"
toLocaleTimeString()
根据本地时间格式，把 Date 对象的时间部分转换为字符串。 "上午8:00:00"
toLocaleDateString()
根据本地时间格式，把 Date 对象的日期部分转换为字符串。  "2018/10/8"
new Date('2018-10-08').toLocaleTimeString()
// "上午8:00:00"

new Date('2018-10-08').toLocaleDateString()
// "2018/10/8"

new Date('2018-10-08').toLocaleString()
// "2018/10/8 上午8:00:00"
 
 注意点：
 
（1）该方法存在兼容性问题，不同的浏览器以及浏览器不同版本下获得的格式可能不同（部分可能为2018-10-08，而非2018/10/08）
 
（2）unix时间戳是秒（10位的数字），而js转化new Date()的时候使用的是毫秒，需要*1000
 
2. moment.js 类库格式化时间日期
 
 
 
moment.js 是一个JavaScript 日期处理类库，支持日期时间格式化、相对时间、日历时间和多语言支持。
 
 
格式化示例： 
 
moment().format('MMMM Do YYYY, h:mm:ss a'); // 十月 8日 2018, 2:21:57 下午
moment().format('dddd');                    // 星期一
moment().format("MMM Do YY");               // 10月 8日 18
moment().format('YYYY [escaped] YYYY');     // 2018 escaped 2018
moment().format();                          // 2018-10-08T14:21:57+08:00