通过DateTimeFormatter格式器格式化日期时间

程序要求:用扫描器获取输入的时间(年月日时分),这个时间的格式是常用的格式,然后格式化这个时间,把格式化的时间输出到控制台,可以在控制台重复输入时间.格式化的时间参考企业微信聊天记录的展示时间.用DateTimeFormatter实现.

实现结果:

请输入要格式化的时间
格式:
2002-1-27 8:33
2002/1/27 8:33
2002.1.27 8:33
或：exit退出程序
2002-1-1 8:00
时间格式化完成:2002年01月01日 上午 08:08
请继续输入需要格式化的时间或
exit退出
2020-1-11 8:00
时间格式化完成:上午 08:08
请继续输入需要格式化的时间或
exit退出
2020-1-1- 8:00
时间格式化完成:01月01日 上午 08:08
请继续输入需要格式化的时间或
exit退出
2020-1-8 8:00 
时间格式化完成:周三 上午 08:08
请继续输入需要格式化的时间或
exit退出
2020-2-29 8:00
时间格式化完成:02月29日 上午 08:08
请继续输入需要格式化的时间或
exit退出
2019-2-29 8:00
0年是闰年2月不能超过29天,请重新输入

具体带代码实现细节:

package dateftreatment;

import java.util.Scanner;

/**
 * 测试类

 * 2019年12月26日下午2:29:32
 * 
 * @author zjx
 * @version 1.0
 */
public class Test {
//	静态初始化快
	static {
//		打印开始语句
		Hint.TO_START_INFORMATION.println();
	}

	@SuppressWarnings("resource")
	public static void main(String[] args) {
//		获取扫描器对象
		Scanner sc = new Scanner(System.in);
		while (sc.hasNextLine()) {
//			获取输入的内容
			String string = sc.nextLine().trim();
//			判断输入的是否是退出指令
			if (string.equals(Instruction.EXIT.getName())) {
				System.out.println("退出成功");
//				关闭虚拟机
				System.exit(0);
			}
//			调用工具类获取处理结果
			String timeResultString = TimeTool.formatterTool(string);
//			如果方法formatterTool返回值为null则跳过本次循环
			if (timeResultString == null) {
				continue;
			}
//			打印获取到的结果 
			System.out.println(timeResultString);
//			打印继续输入的提示信息
			Hint.CONTINUE_TO_INPUT.println();

		}

	}

package dateftreatment;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Arrays;

/**
 * 用于处理日期时间的工具类

 * 2019年12月26日下午2:36:00
 * 
 * @author zjx
 * @version 1.0
 */
public class TimeTool {
	/**
	 * 用来存放分割的日期和时间
	 */
	private static String[] dateAdTime = null;

	/**
	 * 处理日期和时间的格式化器
	 * 
	 * @param dateTime 需要处理的日期时间
	 * @return 处理好的日期时间
	 */
	public static String formatterTool(String dateTime) {
//		如果日期为空结束方法开始下次循环
		
		if (!Tool.judgeNull(dateTime)) {
			Hint.SENTENCED_TO_EMPTY.println();
			return null;
		}
//		判断传入日期的长度的是否合法
		if (!Tool.judgeLength(dateTime)) {
			return null;
		}
//		调用从写的分割方法进行参数分割判断
		dateAdTime = Tool.split(dateTime, " ", 2);
//		调用判断日期时间的类将返回值作为参数传入格式化器对日期时间进行格式化
		return formatter(DateOfTreatment.control(dateAdTime[0]), ProcessingTime.control(dateAdTime[1]));
	}

	/**
	 * 日式时间的格式化器 将判断后的日期时间重 新组合为一个String字符串 并用DateTimeFoematter个解析 格式化为一个日期时间对象
	 * 然后根据返回的参数对日期时间对象重新重新格式化成一个需要的日期时间对象
	 * 
	 * @param date 判断好的日期参数;
	 * @param Time 判断好的时间参数
	 * @return 格式化后的结果
	 */
	public static String formatter(String dateParameter, String TimeParameter) {
//		判断传入的程序是否为空
		if (dateParameter == null | TimeParameter == null) {
//			如果为空直接返回null出去
			return null;
		}
//		获取输入的日期
		String[] date = DateOfTreatment.storage;
//		创建一个时间格格式字符串
		String str = date[0] + "." + date[1] + "." + date[2] + " " + TimeParameter;
//		创建一个模式字符串格式化器
		DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy.MM.dd H:mm");
//		使用格式化器将字符串对象格式化成日期时间对象
		LocalDateTime localDateTime = LocalDateTime.parse(str, formatter);
//       不同年的情况 
		if (dateParameter.equals(Instruction.DIFFERENT_YEARS.getName())) {
//			创建一个带年月日时分的模式字符串将时间对象解析为字符串
			return "时间格式化完成:" + localDateTime.format(DateTimeFormatter.ofPattern("yyyy年MM月dd日 a HH:mm"));
//       不同月的情况或同一个月不同周的情况
		} else if (dateParameter.equals(Instruction.DIFFERENT_MONTH.getName())
				|| dateParameter.equals(Instruction.DIFFERENT_WEEKS.getName())) {
//			创建一个带月日时分的模式字符串将时间对象解析为字符串返回出去
			return "时间格式化完成:" + localDateTime.format(DateTimeFormatter.ofPattern("MM月dd日 a HH:mm"));
//			如果在同一天的情况下
		} else if (dateParameter.equals(Instruction.TODAY.getName())) {
//			创建一个带时分的模式字符串将时间对象解析为字符串
			return "时间格式化完成:" + localDateTime.format(DateTimeFormatter.ofPattern("a HH:mm"));
//      如果在昨天的情况下
		} else if (dateParameter.equals(Instruction.YESTERDAY.getName())) {
//			创建一个带时分的模式字符串将时间对象解析为字符串并在前面加昨天返回出去
			return "时间格式化完成:昨天 " + localDateTime.format(DateTimeFormatter.ofPattern("a HH:mm"));
//		传入的日期和当前时间在一周内
		} else if (dateParameter.equals(Instruction.THIS_WEEK.getName())) {
//			创建一个带星期时间的模式字符串串解析时间对象
			return "时间格式化完成:" + localDateTime.format(DateTimeFormatter.ofPattern("E a HH:mm"));
		}
		return str;

	}

}

package dateftreatment;

import java.time.MonthDay;
import java.time.Year;

/**
 * 处理日期的类

 * 2019年12月26日下午6:46:22
 * 
 * @author zjx
 * @version 1.0
 */
public class DateOfTreatment {
	/**
	 * 用于存储分割后的年月日
	 */
	public static String[] storage;
	/**
	 * 分割后的年
	 */
	public static int year;
	/**
	 * 分割后的月
	 */
	public static int month;
	/**
	 * 分割后的日
	 */
	public static int date;

	/**
	 * 设置年的方法
	 * 
	 * @param year 年
	 * @return 结果
	 */
	public static boolean setYear(String year) {
//		判断传入的日期时间是否空
		if (!Tool.judgeNull(year)) {
			return false;
		}
//		将传入的值转为int数值
		int a = Integer.valueOf(year);
//		判断日期是否合法
		if (a <= Year.now().getValue() && a >= 1970) {
			DateOfTreatment.year = a;
			return true;
		} else {
			Hint.INVALID_YEAR.println();
			return false;
		}
	}

	/**
	 * 设置月的方法
	 * 
	 * @param month 月
	 * @return 结果
	 */
	public static boolean setMonth(String month) {
//		判断传入的日期时间是否空
		if (!Tool.judgeNull(month)) {
			return false;
		}
//		将传入的值转为int数值
		int a = Integer.valueOf(month);
//		判断月份是否在12-1之间
		if (a < 13 && a > 0) {
			DateOfTreatment.month = a;
			return true;
		} else {
			Hint.INVALID_MONTH.println();
			return false;
		}
	}

	/**
	 * 设置日的方法
	 * 
	 * @param date 日
	 * @return 结果
	 */
	public static boolean setDate(String date) {
//		判断传入的日期时间是否空
		if (!Tool.judgeNull(date)) {
			return false;
		}
//		将传入的值转为int数值
		int a = Integer.valueOf(date);
//		判断日期是否合法
		if (a < 32 && a > 0) {
			DateOfTreatment.date = a;
			return true;
		} else {
			Hint.INVALID_DATE.println();
			return false;
		}
	}

	/**
	 * 处理日期的方法
	 * 
	 * @param date 传入的日期
	 * @return 处理结果
	 */
	public static String control(String date) {
		
//		对参数进行分割  
		storage = splitDate(date);
//		判断storage是否为空
		if (!Tool.judgeNull(storage)) {
			Hint.SENTENCED_TO_EMPTY.println();
			return null;
		}
//		判断存储是否成功
		if (!add()) {
			return null;
		}
//		判断平润年是否合法
		if (!LeapYear()) {
			return null;

		}
//		调用判断是否是当前年的方法把参数返回出去
		return disposeYear();

	}

	/**
	 * 分割日期的方法
	 * 
	 * @param date 需要分割的参数
	 * @return 分割结果
	 */
	public static String[] splitDate(String date) {
		if (!Tool.judgeNull(date)) {
			return null;
		}
//		处理结果
		String[] storage = null;
//		判断是否包含正确的分隔符如果包含 调用Toll工具类里的分割方法传入对应的分割符号进行分割
		if (date.contains("/")) {
			storage = Tool.split(date, "/", 3);
		} else if (date.contains("-")) {
			storage = Tool.split(date, "-", 3);
		} else if (date.contains("\\.")) {
			storage = Tool.split(date, "\\.", 3);
		} else {
			Hint.INVALID_DATE.println();
			return null;
		}
		return storage;

	}

	/**
	 * 把分割好的日期分别赋值存储给对应的变量
	 * 
	 * @return 存储结果
	 */
	public static boolean add() {
//		判断传入的数组是否是数字
		if (!Tool.CharArray(storage)) {

			return false;
		}

//		索引如果为0调用setYear方法对year进行赋值
		if (!setYear(storage[0])) {
			return false;
		}
//		索引如果为1调用setMonth方法对month进行赋值
		if (setMonth(storage[1])) {
//			如过传入的月是一位数就在他前面补0
			storage[1] = storage[1].length() == 1 ? "0" + storage[1] : storage[1];
		} else {

			return false;
		}
//		索引如果为1调用setDate方法对date进行赋
		if (setDate(storage[2])) {
//			如过传入的是一位数就在他前面补0
			storage[2] = storage[2].length() == 1 ? "0" + storage[2] : storage[2];
		} else {
			return false;
		}

		return true;
	}

	/**
	 * 判断平润年的方法
	 * 
	 * @return 处理结果
	 */
	public static boolean LeapYear() {
//		判断是否是二月
		if (month == 2) {
//			如果是二月并且当前年能被4整除并且不能被100整除或者能能被400整除返回0
			if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
//				判断润年二月是否在29天之内;
				if (!(date <= 29)) {
					Hint.INVALID_LEAP_YEAR.println();
					return false;
				}
			} else {
//				判断平年2月是否在28天之内
				if (date <= 28) {
				} else {
					Hint.INVALID_NONLEAP_YEAR.println();
					return false;
				}
			}
//			判断是否是大月 
		} else if (month == 4 || month == 6 || month == 9 || month == 11) {
//			判断小月是否在30天之内
			if (!(date <= 30)) {
				Hint.INVALID_MOONLET.println();
				return false;
			}
		}
		return true;
	}

	/**
	 * 判断是否是当前年
	 * 
	 * @return 处理结果
	 */
	public static String disposeYear() {
//		提取出的当前天数
		int day = MonthDay.now().getDayOfMonth();
//		拿传入的年和当前年进行比较
		if (!(year == Year.now().getValue())) {
//		如果传入的日期和当前年不是同一年则返回不同年
			return Instruction.DIFFERENT_YEARS.getName();
		}
//		判断是否是同一个月
		if (!(month == MonthDay.now().getMonth().getValue())) {
//			如果传入的月和当前月不是同一月则返回不同月
			return Instruction.DIFFERENT_MONTH.getName();
		}

//		判断是否为同一天
		if (date == MonthDay.now().getDayOfMonth()) {
			return Instruction.TODAY.getName();
//		判断是否为昨天
		} else if (date == (day - 1)) {
			return Instruction.YESTERDAY.getName();
		}
//		判断是否在一周内
		if ((day - 1) > date && (day - 6) < date) {
			return Instruction.THIS_WEEK.getName();
//			如果是不同周则返回不同周
		} else {
			return Instruction.DIFFERENT_WEEKS.getName();
		}
	}

}

package dateftreatment;

/**
 * 处理时间

 * 2019年12月27日下午8:58:51
 * 
 * @author zjx
 * @version 1.0
 */
public class ProcessingTime {

	/**
	 * 分割后的时间
	 */
	private static String[] time;

	/**
	 * 处理时间的总控制方法
	 * 
	 * @param Time 需要传入的参数
	 * @return 处理结果
	 */
	public static String control(String Time) {
//		判断是否为空 
		if (!(Tool.judgeNull(Time))) {
//			如果为空返回null 并打印友好提示
			Hint.SENTENCED_TO_EMPTY.println();
			return null;
		}
//		对参数进行分割  
		time = splitDate(Time);
//		判断传入的参数是否全是数字
		if (!(Tool.CharArray(time))) {
			return null;
		}

//		判断日期参数是否合法
		if (!judgeHour(time[0])) {
			return null;
		}
		if (!judgeMinute(time[1])) {
			return null;
		}
		return time[0] + ":" + time[1];
	}

	/**
	 * 分割时间的方法
	 * 
	 * @param date 需要分割的时间
	 * @return 分割的结果
	 */
	public static String[] splitDate(String time) {
//			判断日期是否为空
		if (!Tool.judgeNull(time)) {
			return null;
		}
//		判断传入的时间是否包含正确的分隔符
		if (time.contains(":")) {
//			调用工具类的分割方法对时间参数进行分割
			return Tool.split(time, ":", 2);
		} else {
			return null;
		}

	}

	/***
	 * 判断时间的小时是否合法
	 * 
	 * @param Hour 需要判断的参数
	 * @return 结果
	 */
	public static boolean judgeHour(String hour) {
//		把传入的转换成int类型的参数
		int hour1 = Integer.valueOf(hour);
//		判断时间是否在1-23之间
		if (hour1 >= 0 && hour1 < 24) {
//			如果时间参数为1则对他进行补充0
			time[0] = time[0].length() == 1 ? "0" + time[0] : time[0];
			return true;
		}
		Hint.INVALID_TIME.println();
		return false;

	}

	/***
	 * 判断时间的是否合法
	 * 
	 * @param minute 需要判断的参数
	 * @return 结果
	 */
	public static boolean judgeMinute(String minute) {
//		把传入的转换成int类型的分钟参数
		int minute1 = Integer.valueOf(minute);
//		判断时间是否在1-59之间
		if (minute1 >= 0 && minute1 < 60) {
//			如果时间参数为1位则对他进行补充0
			time[1] = time[1].length() == 1 ? "0" + time[0] : time[0];
			return true;
		}
//		不合法返回友好提示语句
		Hint.INVALID_TIME.println();
		return false;
	}

}

/**
 * 
 */
package dateftreatment;

import java.time.Year;

/**
 * 时间日期格式器的提示信息

 * 2020年1月9日下午9:12:55
 * 
 * @author zjx
 * @version 1.0
 */
public enum Hint {
	/**
	 * 开始程序的提示信息
	 */
	TO_START_INFORMATION(
			"请输入要格式化的时间\n格式:\n2002-1-27 8:33\n2002/1/27 8:33\n2002.1.27 8:33\n或：" + Instruction.EXIT.getName() + "退出程序"),
	/**
	 * 继续输入的提示信息
	 */
	CONTINUE_TO_INPUT("请继续输入需要格式化的时间或\n" + Instruction.EXIT.getName() + "退出"),
	/**
	 * 日期不合法的提示信息
	 */
	INVALID_DATE("输入的日期不合法,请重新输入"),
	/**
	 * 输入的时间不合法的提示信息
	 */
	INVALID_TIME("输入的时间不合法,请重新输入"),
	/**
	 * 参数为空的提示信息
	 */
	SENTENCED_TO_EMPTY("传入的参数不可为空,请重新输入"),
	/**
	 * 年不合法
	 */
	INVALID_YEAR("年份必须在1970-" + Year.now().getValue() + "年之间"),
	/**
	 * 月不合法
	 */
	INVALID_MONTH("月年份必须在1月-12月之间"),
	/**
	 * 小月不合法
	 */
	INVALID_MOONLET(DateOfTreatment.month + "是小月只能有30天,请重新输入"),
	/**
	 * 平年不合法
	 */
	INVALID_NONLEAP_YEAR(DateOfTreatment.year + "年是闰年" + "2月不能超过29天,请重新输入"),
	/**
	 * 闰年不合法
	 */
	INVALID_LEAP_YEAR(DateOfTreatment.year + "年是平年" + "2月不能超过28天,请重新输入"),
	/**
	 * 参数不是数字
	 */
	NOT_NUMBERS("传入的参数必须全是数字,请重新输入");
	;

	/**
	 * 提示信息
	 */
	private final String name;

	/**
	 * 有参构造器
	 * 
	 * @param name 参数
	 */
	private Hint(String name) {
		this.name = name;
	}

	/**
	 * 打印提示语的方法
	 */
	public void println() {
		System.out.println(this.name);
	}

}

package dateftreatment;

/**
 * 指令集

 * 2019年12月26日下午5:35:59
 * 
 * @author zjx
 * @version 1.0
 */
public enum Instruction {
	/**
	 * 退出的指令
	 */
	EXIT("exit"),
	/**
	 * 昨天
	 */
	YESTERDAY("昨天"),
	/**
	 * 今天
	 */
	TODAY("今天"),
	/**
	 * 当前 年
	 */
	YEAR("当前年"),
	/**
	 * 当前月
	 */
	MOVER("当前月"),
	/**
	 * 本周
	 */
	THIS_WEEK("本周"),
	/**
	 * 不同年
	 */
	DIFFERENT_YEARS("不同年"),
	/**
	 * 不同月
	 */
	DIFFERENT_MONTH("不同月"),
	/**
	 * 不同周
	 */
	DIFFERENT_WEEKS("不同周");

	;

	/**
	 * 指令
	 */
	private String name;

	/**
	 * 构造器
	 * 
	 * @param name 指令
	 */
	private Instruction(String name) {
		// TODO Auto-generated constructor stub
		this.name = name;
	}

	/**
	 * 获取指令的方法
	 * 
	 * @return 指令
	 */
	public String getName() {
		return this.name;
	}
}

/**
 * 
 */
package dateftreatment;

import java.util.Arrays;

/**
 * 工具类

 * 2020年1月10日上午10:49:00
 * 
 * @author zjx
 * @version 1.0
 */
public class Tool {

	/**
	 * 判断传入的日期时间是否合法的方法
	 *  最长16位:2002-01-27 18:22
	 *  最短12位:2002-1-7 8:2
	 * 
	 * @param DateTiem 需要判断的参数
	 * @return 判断结果
	 */
	public static boolean judgeLength(String DateTiem) {

//		判断传入的日期时间参数是否在16-12之间
		if (DateTiem.length() > 16 || (DateTiem.length() < 12)) {
//			判断传入的参数长度是否合法
			Hint.INVALID_DATE.println();
			return false;
		}
		return true;
	}

	/**
	 * 判断参数是否为空的方法`
	 * 
	 * @param parameter 需要判断的参数
	 * @return 处理结果结果
	 */
	public static boolean judgeNull(String parameter) {
//		判断传入参数是否为空
		if (parameter == null || parameter.equals("")) {

			return false;
		}
		return true;
	}

	/**
	 * 重载的判空的方法
	 * 
	 * @param parameter 需要判断的参数
	 * @return 参数
	 */
	public static boolean judgeNull(String[] parameter) {
//		判断传入参数是否为空
		if (parameter == null) {
			return false;
		}
		return true;
	}

	/**
	 * 用来分割参数并 判断分割后是否正确
	 * 
	 * @param parameter 需要进行分割的参数
	 * @param seprator  分隔符
	 * @param a         传入一个int参数与分割后数组的长度比较判断分割是否正确
	 * @return 处理分分割好的数组
	 */
	public static String[] split(String parameter, String seprator, int a) {
//		临时用来存放分割后数据
		String[] deal;
//		判断传入的参数是否包含空格
		if (parameter.contains(seprator)) {
//			对传入的参数进行分割赋值给deal变量
			deal = parameter.split(seprator);
//			判断分割后的长度是否为2
			if (!(deal.length == a) || deal == null) {
				return null;
			}
//		如果不包含返回null 
		} else {
			return null;

		}
		return deal;
	}

	/**
	 * 判断传日期是否为数字
	 * 
	 * @param date 日期
	 * @return 处理结果
	 */
	public static boolean CharArray(String[] date) {

//		对传进的参数进行遍历
		for (String string : date) {
//			判断参数是否为空
			if (!judgeNull(date)) {
				return false;
			}
			// 将日期转换成char数组
			char[] c = string.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;
	}

}