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

最新推荐文章于 2024-07-25 09:44:28 发布
最新推荐文章于 2024-07-25 09:44:28 发布
阅读量3.7k 收藏
点赞数 5
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hrkj_zjx/article/details/103933760
版权

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

/**
 * 测试类<br>
 * 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;

/**
 * 用于处理日期时间的工具类<br>
 * 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;

/**
 * 处理日期的类<br>
 * 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;

/**
 * 处理时间<br>
 * 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;

/**
 * 时间日期格式器的提示信息<br>
 * 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;

/**
 * 指令集<br>
 * 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;

/**
 * 工具类<br>
 * 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;
	}

}
小辣条吖
关注
  • 5
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
使用DateTimeFormatter格式化输入的日期时间
wcf_hrkj的博客
01-11 1567
使用DateTimeFormatter格式化输入的日期时间 要求: 用DateTimeFormatter实现: 用扫描器获取输入的时间(年月日时分),这个时间的格式是常用的格式,然后格式化这个时间,把格式化的时间输出到控制台,可以在控制台重复输入时间.格式化的时间参考企业微信聊天记录的展示时间 分析: 1.时间的常用格式为: xxxx-xx-xx xx:xx xxxx/xx/xx xx:xx...
使用DateTimeFormatter对象格式化时间日期
wangliuchuang的博客
01-11 7468
标题 使用DateTimeFormatter对象实现格式化时间日期 要求: 用DateTimeFormatter实现: 用扫描器获取输入的时间(年月日时分),这个时间的格式是常用的格式,然后格式化这个时间,把格式化的时间输出到控制台,可以在控制台重复输入时间.格式化的时间参考企业微信聊天记录的展示时间 实现步骤如下: 测试类测试代码 package date; import java.util....
java中日期转换Date、DateTime、TimeStamp、String之间相互转换
m0_64887997的博客
04-08 7595
【代码】java中日期转换Date、DateTime、TimeStamp、String之间相互转换。
Java格式化 - DateTimeFomatter类
IT深耕十余载，大道之简
06-06 416
类还提供了许多预定义的格式化程序，你可以直接使用它们，而无需定义自己的模式。：用于ISO格式的本地日期，如2023-10-23。：用于ISO格式的本地时间，如14:30:45。：用于ISO格式的本地日期和时间，如。// 输出类似于 "2023-10-23T14:30:45"
DateTimeFormatter日期格式化
csdn565973850的博客
11-24 1822
DateTimeFormatter日期格式化DateTimeFormatter工具类 DateTimeFormatter 使用旧的Date对象时，我们用SimpleDateFormat进行格式化显示。使用新的LocalDateTime或ZonedLocalDateTime时，我们要进行格式化显示，就要使用DateTimeFormatter。 和SimpleDateFormat不同的是，DateTimeFormatter不但是不变对象，它还是线程安全的。因为SimpleDateFormat不是线程安全的，使用
DateTimeFormatter：格式化或解析日期、时间
weixin_44530708的博客
05-10 2428
DateTimeFormatter：格式化或解析日期、时间
使用DateTimeFormatter实现格式化时间
zlc_hrkj的博客
01-11 5376
用扫描器获取输入的时间(年月日时分),这个时间的格式是常用的格式,然后格式化这个时间,把格式化的时间输出到控制台,可以在控制台重复输入时间.格式化的时间参考企业微信聊天记录的展示时间.用DateTimeFormatter实现,功能如下: 同年: 不同年: 同月:月日+上午/下午+时分 同年不同月:月日+时分 今天:上午/下午+时分 明天:明天+上午/下午+时分 昨天:昨天+上午/下午+时分 包括今...
Java使用DateTimeFormatter格式化输入的日期时间
08-25
在Java编程中，DateTimeFormatter是Java 8引入的java.time.format包中的类，用于格式化日期和时间。本文将深入探讨如何使用DateTimeFormatter对输入的日期时间进行格式化，以及如何根据不同的时间范围显示不同的时间...
Java使用DateTimeFormatter实现格式化时间
08-25
datetimeFormatter是Java中用于格式化日期和时间的工具类。通过使用DateTimeFormatter，可以将日期和时间按照指定的格式进行格式化，输出到控制台或其他设备上。在Java中，DateTimeFormatter是Java 8中引入的新类，...
懒人原生format方法格式化Date时间日期
06-06
此外，Java 8引入了新的日期时间API，包括`java.time.LocalDate`、`java.time.LocalDateTime`和`java.time.format.DateTimeFormatter`等类，它们提供了更强大且易于使用的日期时间处理功能。虽然`SimpleDateFormat`...
Java使用DateFormatter格式化日期时间的方法示例
08-30
2. **格式化日期时间**：使用`DateTimeFormatter.format()`方法将`LocalDateTime`、`LocalDate`或`LocalTime`对象转换为字符串。例如： ```java System.out.println(df.format(LocalDateTime.now())); ``` 3. **...
关于Springboot日期时间格式化处理方式总结
08-24
关于Springboot日期时间格式化处理... Springboot 日期时间格式化处理方式可以通过自定义参数转换器来实现，对于不同的日期时间格式，可以使用不同的 Converter 来进行转换。同时，正则匹配也可以用于适应多种场景。
DateTimeFormatter时间格式化-java8新特性
qq_42391042的博客
07-12 756
DateTimeFormatter时间格式化-java8新特性
DateTimeFormatter日期转换
HashShark的博客
11-11 4362
将Date类型的日期转换为字符串 // Date srcDate = new Date(); // 1.日期类型的源日期 Date srcDate = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse("2011-11-11 11:11:11"); // 2.解析字符串日期 LocalDateTime ldt = LocalDateTim...
DateTimeFormatter 时间戳与String类型日期/时间互转
热门推荐
sfy666666的博客
01-05 1万+
/** * 时间戳转日期/时间 * * @param seconds 时间戳 * @param pattern 时间格式 * @return 格式化的时间 */ @RequiresApi(api = Build.VERSION_CODES.O) public static String timeStamp2Date(l...
日期时间格式转化 String 转 Date
最新发布
weixin_45958839的博客
07-25 297
【代码】日期时间格式转化 String 转 Date。
字符串、日期互相转换
努力努力，努力努力的博客
07-29 611
字符串、各种日期类型转换
【关于java日期格式化或解析（DateTimeFormatter:格式化或解析日期、时间 类似于SimpleDateFormatter）】
Chos1JQ_java的博客
12-02 326
DateTimeFormatter formatter = DateTimeFormatter.ISO_DATE_TIME; //格式化 日期--->字符串 LocalDateTime localDateTime = LocalDateTime.now(); String str1 = formatter.format(localDateTime); System.out.println(localDateTime); System.out.println(str1); //解析 字符串--.
DateTimeFormatter格式化Date
01-25
DateTimeFormatter是Java 8中用于格式化和解析日期时间的类。它提供了一种灵活的方式来定义日期时间的格式，并将其转换为字符串或解析为日期时间对象。 下面是一个示例，演示如何使用DateTimeFormatter格式化Date对象： ```java import java.time.LocalDate; import java.time.format.DateTimeFormatter; public class Main { public static void main(String[] args) { // 创建一个DateTimeFormatter对象，指定日期格式 DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd"); // 创建一个LocalDate对象，表示当前日期 LocalDate date = LocalDate.now(); // 使用DateTimeFormatter格式化日期 String formattedDate = date.format(formatter); // 输出格式化后的日期字符串 System.out.println("Formatted date: " + formattedDate); } } ``` 输出结果将是当前日期的格式化字符串，例如："Formatted date: 2021-01-01"。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值