标题 使用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;
}
}
}
