`
lysvanilla
  • 浏览: 80867 次
  • 性别: Icon_minigender_1
  • 来自: 湖南
社区版块
存档分类
最新评论

java常用日期操作对象

java 
阅读更多
Java代码 复制代码 收藏代码
  1. import java.util.Calendar;
  2. import java.text.FieldPosition;
  3. import java.text.ParsePosition;
  4. import java.text.SimpleDateFormat;
  6. /**
  7. * 对日期的操作，如格式化，向前，向后推算日期
  8. *
  9. * @作者 刘明晶，华龙
  10. *
  11. * @时间 2008年11月17日
  12. *
  13. */
  14. public class DateUtil {
  16. static final SimpleDateFormat sdf0 = new SimpleDateFormat("yyyy年MM月dd日");
  17. static final SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd");
  18. static final SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  20. /**
  21. * 判断指定日期、日期时间、时间是否比当前日期时间后。
  22. *
  23. * @param theTime 指定日期、日期时间、时间。
  24. * @return 更后返回true，否则返回false。
  25. */
  26. public static boolean isAfter(String theTime) {
  27. switch (theTime.length()) {
  28. case 5:
  29. return (get("HH:mm").compareTo(theTime) > 0);
  30. case 8:
  31. return (get("HH:mm:ss").compareTo(theTime) > 0);
  32. case 11:
  33. if (theTime.charAt(2) == ' ')
  34. return (get("dd HH:mm:ss").compareTo(theTime) > 0);
  35. if (theTime.charAt(5) == ' ')
  36. return (get("MM-dd HH:mm").compareTo(theTime) > 0);
  37. case 14:
  38. return (get("MM-dd HH:mm:ss").compareTo(theTime) > 0);
  39. case 17:
  40. return (get("yy-MM-dd HH:mm:ss").compareTo(theTime) > 0);
  41. case 19:
  42. return (get("yyyy-MM-dd HH:mm:ss").compareTo(theTime) > 0);
  43. }
  44. return false;
  45. }
  47. /**
  48. * 判断指定日期、日期时间、时间是否比当前日期时间前。
  49. *
  50. * @param theTime 指定日期、日期时间、时间。
  51. * @return 更前返回true，否则返回false。
  52. */
  53. public static boolean isBefore(String theTime) {
  54. switch (theTime.length()) {
  55. case 5:
  56. return (get("HH:mm").compareTo(theTime) < 0);
  57. case 8:
  58. return (get("HH:mm:ss").compareTo(theTime) < 0);
  59. case 11:
  60. if (theTime.charAt(2) == ' ')
  61. return (get("dd HH:mm:ss").compareTo(theTime) < 0);
  62. if (theTime.charAt(5) == ' ')
  63. return (get("MM-dd HH:mm").compareTo(theTime) < 0);
  64. case 14:
  65. return (get("MM-dd HH:mm:ss").compareTo(theTime) < 0);
  66. case 17:
  67. return (get("yy-MM-dd HH:mm:ss").compareTo(theTime) < 0);
  68. case 19:
  69. return (get("yyyy-MM-dd HH:mm:ss").compareTo(theTime) >= 0);
  70. }
  71. return false;
  72. }
  74. /**
  75. * 按照数据库日期预定的格式取得当前的日期字符串。
  76. *
  77. * * @return “yyyy-MM-dd”格式的当前时间字符串。
  78. */
  79. public static String getDate() {
  80. return sdf2.format(new java.util.Date());
  81. }
  83. /**
  84. * 获取当时指定毫秒数后的日期对象。
  85. *
  86. * @param seconds 指定毫秒数。
  87. * @return 当时指定毫秒数后的日期对象。
  88. */
  89. public static java.util.Date getDate(long seconds) {
  90. return new java.util.Date(new java.util.Date().getTime() + seconds* 1000);
  91. }
  93. /**
  94. * 按照数据库日期预定的格式取得当前的日期字符串。
  95. *
  96. * * @return “yyyy-MM-dd”格式的当前时间字符串。
  97. */
  98. public static String getDate(Calendar ca) {
  99. return sdf2.format(ca.getTime());
  100. }
  102. /**
  103. * 按照数据库日期预定的格式取得当前的日期字符串。
  104. *
  105. * * @return “yyyy-MM-dd”格式的当前时间字符串。
  106. */
  107. public static String getDate(java.util.Date date) {
  108. return sdf2.format(date);
  109. }
  111. /**
  112. * 按照指定的日期/时间格式返回日期/时间字符串。
  113. *
  114. * @param dateFormatString 格式字符串。
  115. * @return 格式化后的日期字符串。
  116. */
  117. public static String get(String dateFormatString) {
  118. try {
  119. return new java.text.SimpleDateFormat(dateFormatString)
  120. .format(new java.util.Date());
  121. } catch (Exception e) {
  122. }
  123. return null;
  124. }
  126. /**
  127. * 按照给定的 日期/时间 格式 生成 以java.util.Date对象给出的日期/时间 的字符串。
  128. *
  129. * @param date 指定的日期对象。
  130. * @param dateFormatString 格式字符串。
  131. * @return 格式化后的日期字符串。
  132. */
  133. public static String get(java.util.Date date, String dateFormatString) {
  134. try {
  135. return new java.text.SimpleDateFormat(dateFormatString)
  136. .format(date);
  137. } catch (Exception e) {
  138. }
  139. return null;
  140. }
  142. /**
  143. * 按照给定的 日期/时间 格式 生成 以java.util.Calendar对象给出的日期/时间 的字符串。
  144. *
  145. * @param calendar 指定的日历对象。
  146. * @param dateFormatString 格式字符串。
  147. * @return 格式化后的日期字符串。
  148. */
  149. public static String get(java.util.Calendar calendar, String dateFormatString) {
  150. try {
  151. return new java.text.SimpleDateFormat(dateFormatString).format(calendar
  152. .getTime());
  153. } catch (Exception e) {
  154. }
  155. return null;
  156. }
  158. /**
  159. * 自动分析多种格式的日期、日期时间、时间字符串对象解析为Calendar对象，最小级别是秒级。
  160. * 目前支持格式：
  161. * yyyy-MM-dd HH:mm:ss
  162. * MM-dd HH:mm:ss 默认为当年
  163. * dd HH:mm:ss 默认为当年当月
  164. * dd HH:mm 默认为当年当月 零秒
  165. * MM-dd HH:mm 默认为当年 零秒
  166. * yyyy-MM-dd 默认为零时零分零秒
  167. * MM-dd 默认为当年 零时零分零秒
  168. * HH:mm:ss 默认为当年当月当日
  169. * HH:mm 默认为当年当月当日 零秒
  170. *
  171. * yyyy/MM/dd HH:mm:ss
  172. * yy/MM/dd HH:mm:ss
  173. * MM/dd HH:mm:ss
  174. * dd HH:mm:ss
  175. *
  176. * yyyy年MM月dd日HH点mm分ss秒
  177. * yy年MM月dd日HH点mm分ss秒
  178. * MM月dd日HH点mm分ss秒
  179. * dd日HH点mm分ss秒
  180. * HH点mm分ss秒
  181. * HH点mm分
  182. * @param datetime 日期、日期时间、时间字符串。
  183. * @return 解析成功返回日历对象，失败返回null。
  184. */
  185. public static Calendar parse(String datetime) {
  187. if(datetime!=null){
  188. //当不是标准格式时，则进行格式化
  189. if (datetime.length()!=19) {
  190. datetime=formatToEnglish(datetime);
  191. }
  192. try {
  193. //创建一个日历对象
  194. Calendar rightNow = Calendar.getInstance();
  196. //设置日历翻到指定日期时间
  197. rightNow.setTime(sdf1.parse(datetime));
  199. //返回设置好的日期
  200. return rightNow;
  202. } catch (Exception e) { }
  203. }
  205. return null;
  207. }
  209. /**
  210. * 用指定的日期对象得到日期时间的字符串形式。
  211. *
  212. * @param date java.util.Date对象。
  213. * @return 日期时间的字符串形式。
  214. */
  215. public static String getDateTime(java.util.Date date) {
  216. return sdf1.format(date);
  217. }
  219. /**
  220. * 用给定的日期得到指定延迟秒数的日期时间字符串。
  221. *
  222. * @param date java.util.Date对象。
  223. * @param seconds 秒数。
  224. * @return 延迟后的日期时间。
  225. */
  226. public static String getDateTime(java.util.Date date, int seconds) {
  227. return sdf1.format(new java.util.Date(date.getTime() + seconds * 1000));
  228. }
  230. /**
  231. * 获得今日与指定日历之间的天数。
  232. *
  233. * @param last 指定的日历。
  234. * @return 当日与指定日历之间的天数。
  235. */
  236. public static int getDays(Calendar last) {
  237. Calendar right = Calendar.getInstance();
  239. long theTime = right.getTimeInMillis() - last.getTimeInMillis();
  241. return (int) (theTime / (3600000 * 24));
  242. }
  244. private static int seed = 0;
  246. /**
  247. * 获取毫秒级的指定长度的字符串。
  248. * @param length 指定的字符串长度。
  249. * @return 毫秒级的指定长度的字符串。
  250. */
  251. public static String getRandomString(int length) {
  252. seed++;
  254. Calendar right = Calendar.getInstance();
  255. String tmp = Long.toString(right.getTimeInMillis() * seed + seed);
  257. length = tmp.length() - length;
  259. return (length < 0) ? tmp : tmp.substring(length);
  260. }
  262. /**
  263. * 用指定格式的日期时间来的得到日期时间对象。
  264. *
  265. * @param dateFormatString 日期时间格式字符串。
  266. * @return 返回java.util.Date类型日期时间对象。
  267. */
  268. public static java.util.Date getToday(String dateFormatString) {
  269. try {
  270. return parse(
  271. new java.text.SimpleDateFormat(dateFormatString)
  272. .format(Calendar.getInstance().getTime()))
  273. .getTime();
  274. } catch (Exception e) {
  275. }
  277. return null;
  278. }
  280. /**
  281. * 得到指定格式的当日的后一天的日期时间对象。
  282. *
  283. * @param dateFormatString 日期时间格式字符串。
  284. * @return 返回java.util.Date类型日期时间对象。
  285. */
  286. public static java.util.Date getTomorrow(String dateFormatString) {
  287. try {
  288. return parse(
  289. new java.text.SimpleDateFormat(dateFormatString)
  290. .format(new java.util.Date(new java.util.Date()
  291. .getTime() + 24 * 3600 * 1000))).getTime();
  292. } catch (Exception e) {
  293. }
  295. return null;
  296. }
  298. /**
  299. * 返回今天之前或之后若干天的日期字符串。
  300. * @param days 指定的天数，“days<0”表示前days天；“days>0”表示后days天，“days=0”表示当天。
  301. * @return 返回格式为“yyyy-MM-dd”的日期。
  302. */
  303. public static String getDate(int days) {
  304. Calendar now = Calendar.getInstance();
  305. now.add(Calendar.DAY_OF_MONTH, days);
  306. return sdf2.format(now.getTime());
  307. }
  309. /**
  310. * 得到指定date日期之前或之后若干天的日期字符串。
  311. * @param date 指定的日期字符串。
  312. * @param days 指定的天数，“days<0”表示前days天；“days>0”表示后days天，“days=0”表示当天。
  313. * @return 字符串形式的日期。
  314. */
  315. public static String getDate(String date,int days){
  316. java.util.Date dateTemp = sdf2.parse(date, new ParsePosition(0));
  318. Calendar calendar = Calendar.getInstance();
  319. calendar.setTime(dateTemp);
  321. // 要加减的日期
  322. calendar.add(Calendar.DATE, days);
  324. java.util.Date nowTime = calendar.getTime();
  326. StringBuffer buffer = sdf2.format(nowTime, new StringBuffer(""),new FieldPosition(0));
  328. return new String(buffer);
  329. }
  331. /**
  332. * 格式化以：“年”、“月”、“日”、“时”、“分”、“秒”、“-”、“－”、“:”、“/”、“ ”、“　”
  333. * 分割日期时间的日期时间字符串。统一格式化成英文的日期时间，例：2009-11-09 13:32:56。
  334. */
  335. public static String formatToEnglish(String datetime){
  336. String date=sdf2.format(Calendar.getInstance().getTime());
  338. String yy=date.substring(0,2);
  339. String year=date.substring(0,4);
  340. String month=date.substring(5,7);
  341. String day=date.substring(8,10);
  343. String datetimeBak=datetime.replace("日", " ");
  344. datetimeBak=datetimeBak.replace("　", " ");
  345. datetimeBak=datetimeBak.replaceAll(" +", " ");
  347. //把日期和时间切割成两部分
  348. String dt[]=datetimeBak.split(" ");
  350. String format=null;
  352. String temp[]=getArray(datetime);
  353. if(temp!=null&&dt!=null){
  355. switch (temp.length){
  356. case 1:
  357. //只有日
  358. if(temp[0].length()==1){
  359. temp[0]="0"+temp[0];
  360. }
  361. format=year+"-"+month+"-"+temp[1]+" 00:00:00";
  362. break;
  363. case 2:
  364. for (int i = 0; i < temp.length; i++) {
  365. if(temp[i].length()==1){
  366. temp[i]="0"+temp[i];
  367. }
  368. }
  370. //判断为日期或是时间
  371. if(dt.length==1){
  372. //判断为时间：由时、分、秒组成
  373. if(dt[0].contains(":")||dt[0].contains("：")||dt[0].contains("点")){
  374. format=year+"-"+month+"-"+day+" "+temp[0]+":"+temp[1]+":00";
  375. }
  376. //判断为日期：由月、日组成
  377. else{
  378. format=year+"-"+temp[0]+"-"+temp[1]+" 00:00:00";
  379. }
  380. }
  381. //判断为日期时间：由日、时组成
  382. else if(dt.length==2){
  383. format=year+"-"+month+"-"+temp[0]+" "+temp[1]+":00:00";
  384. }
  386. break;
  387. case 3:
  388. //判断为日期或是时间
  389. if(dt.length==1){
  390. //判断为时间：由时、分、秒组成
  391. if(dt[0].contains(":")||dt[0].contains("：")||dt[0].contains("点")){
  392. for (int i = 0; i < temp.length; i++) {
  393. if(temp[i].length()==1){
  394. temp[i]="0"+temp[i];
  395. }
  396. }
  397. format=year+"-"+month+"-"+day+" "+temp[0]+":"+temp[1]+":"+temp[2];
  398. }
  399. //判断为日期：由年、月、日组成
  400. else{
  401. for (int i = 0; i < temp.length; i++) {
  402. if(temp[0].length()!=4){
  403. temp[0]=yy+temp[0];
  404. }
  405. else if(temp[i].length()==1){
  406. temp[i]="0"+temp[i];
  407. }
  408. }
  409. format=temp[0]+"-"+temp[1]+"-"+temp[2]+" 00:00:00";
  410. }
  411. }
  412. //判断为日期时间：由日、时组成
  413. else if(dt.length==2){
  414. for (int i = 0; i < temp.length; i++) {
  415. if(temp[i].length()==1){
  416. temp[i]="0"+temp[i];
  417. }
  418. }
  420. String dateArray[]=getArray(dt[0]);
  421. String timeArray[]=getArray(dt[1]);
  422. //判断为月、日、时组成
  423. if(dateArray.length==2 && timeArray.length==1){
  424. format=year+"-"+temp[0]+"-"+temp[1]+" "+temp[2]+":00:00";
  425. }
  426. //判断为日、时、分组成
  427. else if(dateArray.length==1 && timeArray.length==2){
  428. format=year+"-"+month+"-"+temp[0]+" "+temp[1]+":"+temp[2]+":00";
  429. }
  430. }
  431. break;
  432. case 4:
  433. //判断为日期时间
  434. if(dt.length==2){
  436. String dateArray[]=getArray(dt[0]);
  437. String timeArray[]=getArray(dt[1]);
  439. //判断为年、月、日、时组成
  440. if(dateArray.length==3 && timeArray.length==1){
  441. for (int i = 0; i < temp.length; i++) {
  442. if(temp[0].length()!=4){
  443. temp[0]=yy+temp[0];
  444. }
  445. else if(temp[i].length()==1){
  446. temp[i]="0"+temp[i];
  447. }
  448. }
  449. format=temp[0]+"-"+temp[1]+"-"+temp[2]+" "+temp[3]+":"+"00:00";
  450. }
  451. else{
  452. for (int i = 0; i < temp.length; i++) {
  453. if(temp[i].length()==1){
  454. temp[i]="0"+temp[i];
  455. }
  456. }
  458. //判断为日、时、分、秒组成
  459. if(dateArray.length==1 && timeArray.length==3){
  460. format=year+"-"+month+"-"+temp[0]+" "+temp[1]+":"+temp[2]+":"+temp[3];
  461. }
  462. //判断为月、日、时、分组成
  463. else if(dateArray.length==2 && timeArray.length==2){
  464. format=year+"-"+temp[0]+"-"+temp[1]+" "+temp[2]+":"+temp[3]+":00";
  465. }
  466. }
  467. }
  469. break;
  470. case 5:
  471. if(dt.length==2){
  472. String dateArray[]=getArray(dt[0]);
  473. String timeArray[]=getArray(dt[1]);
  474. //判断为月、日、时、分、秒组成
  475. if(dateArray.length==2 && timeArray.length==3){
  476. for (int i = 0; i < temp.length; i++) {
  477. if(temp[i].length()==1){
  478. temp[i]="0"+temp[i];
  479. }
  480. }
  481. format=year+"-"+temp[0]+"-"+temp[1]+" "+temp[2]+":"+temp[3]+":"+temp[4];
  482. }
  483. //判断为年、月、日、时、分组成
  484. else if(dateArray.length==3 && timeArray.length==2){
  485. for (int i = 0; i < temp.length; i++) {
  486. if(temp[0].length()!=4){
  487. temp[0]=yy+temp[0];
  488. }
  489. else if(temp[i].length()==1){
  490. temp[i]="0"+temp[i];
  491. }
  492. }
  493. format=temp[0]+"-"+temp[1]+"-"+temp[2]+" "+temp[3]+":"+temp[4]+":00";
  494. }
  495. }
  496. break;
  497. case 6:
  498. for (int i = 0; i < temp.length; i++) {
  499. if(temp[0].length()!=4){
  500. temp[0]=yy+temp[0];
  501. }
  502. else if(temp[i].length()==1){
  503. temp[i]="0"+temp[i];
  504. }
  505. }
  506. format=temp[0]+"-"+temp[1]+"-"+temp[2]+" "+temp[3]+":"+temp[4]+":"+temp[5];
  507. break;
  508. }
  509. }
  511. return format;
  512. }
  514. /**
  515. * 把多种中文中易出现格式的日期时间中各项转换成数组。
  516. */
  517. private static String[] getArray(String datetime){
  518. String array[]=null;
  519. if(datetime!=null){
  521. //把半角空格替换掉
  522. datetime=datetime.replace(" ", "-");
  524. //把全角空格替换掉
  525. datetime=datetime.replace("　", "-");
  526. datetime=datetime.replace("年", "-");
  527. datetime=datetime.replace("月", "-");
  528. datetime=datetime.replace("日", "-");
  529. datetime=datetime.replace("点", "-");
  530. datetime=datetime.replace("分", "-");
  531. datetime=datetime.replace("秒", "");
  532. datetime=datetime.replace(",", "-");
  533. datetime=datetime.replace("，", "-");
  534. datetime=datetime.replace(".", "-");
  535. datetime=datetime.replace(":", "-");
  536. datetime=datetime.replace("：", "-");
  537. datetime=datetime.replace("－", "-");
  538. datetime=datetime.replace("/", "-");
  539. //多个“-”替换成一个“-”
  540. datetime=datetime.replaceAll("-+", "-");
  542. //把日期时间分割成每个项
  543. array=datetime.split("-");
  544. }
  546. return array;
  547. }
  549. /**
  550. * 格式化以：“年”、“月”、“日”、“时”、“分”、“秒”、“-”、“－”、“:”、“/”、“ ”、“　”
  551. * 分割日期时间的日期时间字符串。统一格式化成中文的日期时间，例：2009年11月09日13时32分56秒。
  552. */
  553. public static String formatToChinese(String datetime){
  554. datetime=formatToEnglish(datetime);
  555. if(datetime==null||datetime.equals("")){
  556. return null;
  557. }
  559. String str[]=datetime.split(":|-| ");
  561. return str[0]+"年"+str[1]+"月"+str[2]+"日 "+str[3]+"点"+str[4]+"分"+str[5]+"秒";
  562. }
分享到：
| 常用java工具类(一)
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Java日期常用操作方法工具类

    使用`format(Date date)`方法可以将日期对象转换为字符串，`parse(String text)`则可以将符合指定格式的字符串转换回日期对象。需要注意的是，`SimpleDateFormat`不是线程安全的，所以在多线程环境下需要额外处理。 ...

    Java常用日期辅助类

    在给定的标题“Java常用日期辅助类”中，我们可以推测这篇博文可能探讨了Java中的一些核心日期处理工具，如`java.util.Date`，`java.time`包中的类，以及自定义的日期助手类`DateHelper.java`。 `java.util.Date`是...

    Java中对日期的常用处理（转）

    总结起来，Java中对日期的处理涵盖了多种场景，从基本的日期对象创建、格式化、比较，到复杂的日期时间计算和时区处理。`DateUtil.java`可能封装了这些常见操作，方便在项目中复用。了解并熟练掌握这些知识点，对于...

    欧柏泰克：Java常用类库--日期操作类

    欧柏泰克：Java常用类库--日期操作类 在 Java 语言中，日期...Date 类、Calendar 类和 DateFormat 类是 Java 语言中常用的日期操作类，每个类都有其特点和应用场景，在实际开发中可以根据需要选择合适的日期操作类。

    java操作date对象

    【Java 操作 Date 对象详解】 在 Java 中，处理日期和时间主要依赖于 `java.util.Date` 和 `java.text.DateFormat` 这两个核心类。在本文中，我们将深入探讨如何使用这些类来获取、格式化和操作日期。 1. **获取...

    java中常用操作

    在Java编程语言中，"常用操作"涵盖了...总之，Java中的常用操作涉及广泛，包括基本语法、面向对象编程、集合操作、I/O、异常处理、多线程以及工具类的使用。理解并掌握这些知识点，将使你在Java编程领域更加得心应手。

    Java的日期格式化常用方法

    本文将深入探讨Java中日期格式化的常用方法，主要关注`SimpleDateFormat`和`java.time`包下的`DateTimeFormatter`。 首先，`SimpleDateFormat`是旧版日期时间API的一部分，尽管在Java 8之后被推荐使用新的`java....

    java swing 时间日期选择控件

    标签“java日期控件”强调了这个主题关注的是Java中与日期选择相关的控件，不仅仅是Swing，也可能是JavaFX或其他库提供的日期选择组件。但在这里，我们主要讨论的是Swing环境下的实现。 在压缩包的"swing 时间控件...

    java常用系统类库实验

    通过这两个实验，学生不仅能够掌握Java中常用类库的使用，还能够提高解决问题的能力，学会如何利用Java标准库来简化编程任务，提高代码的效率和可读性。此外，实验中的方法覆盖练习也有助于学生深入理解面向对象编程...

    Java类库 java中常用的类 可以参考

    本文档旨在介绍 Java 中一些常用的类库，帮助初学者更好地理解和使用这些类库。尽管文档内容并不全面，但包含了大多数常用的类库，对于新手来说较为易懂。 #### 二、Java 常用类库详解 ##### 1. `java.applet` - ...

    JAVA中常用类的常用方法.pdf

    JAVA中常用类的常用方法主要涵盖了java语言中基础类库的关键类以及它们提供的主要方法。以下是针对文档内容的详细解释： 1. java.lang.Object类 Object类是Java中所有类的超类，它提供了多种方法，这些方法在Java中...

    java中关于时间日期操作的常用函数

    ### Java中关于时间日期操作的常用函数 #### 1. 计算某一月份的最大天数 在Java中，可以通过`Calendar`类来获取指定月份的最大天数。这在处理诸如日历显示、日期验证等场景时非常有用。 ```java Calendar time = ...

    java中的日期处理类总结

    Java中的日期处理涉及到多个类，包括Date、Calendar、GregorianCalendar以及日期格式化类如DateFormat和SimpleDateFormat。这些类主要用于管理、操作和格式化日期和时间。以下是对这些类的详细说明： 1. **Date类**...

    一些java常用的工具类

    JUnit是Java中广泛使用的单元测试框架，它提供了断言、测试套件等功能，帮助开发者编写可测试的代码。 总之，Java工具类是提高开发效率的关键，它们封装了常见的操作，减少了代码重复，提高了代码可读性和维护性。...

    Java中日期处理的代码

    示例代码中定义了多个常用的日期格式字符串，包括： - `FORMAT_ONE = "yyyy-MM-dd HH:mm:ss"`：完整的日期时间格式（年月日时分秒）。 - `FORMAT_TWO = "yyyy-MM-dd HH:mm"`：不含秒数的日期时间格式。 - `FORMAT_...

    java常用的日期工具类

    本文将深入探讨Java中常用的日期工具类，并通过示例代码`DateUtil.java`来进一步解释。 1. **`java.util.Date`**： `java.util.Date`是Java最早提供的日期类，它代表了从1970年1月1日00:00:00 GMT到当前时间的毫秒...

    java常用类库java常用类库java常用类库

    ArrayList、LinkedList、HashSet、HashMap等是常用的集合类，它们提供了动态存储和操作对象的方式。其中，ArrayList适合快速访问，LinkedList适合频繁插入和删除，HashSet存储不重复元素，HashMap则是键值对的映射。...

    java操作日期时间工具类

    Java提供了多种工具类来帮助开发者进行日期时间的操作，其中最常用的是`java.util.Date`、`java.util.Calendar`以及`java.time`包中的类。本篇将重点介绍Java操作日期时间的工具类，特别是通过`DateUtil.java`这个...

    实验5 JAVA常用类.doc

    - **String** 类在Java中是不可变的，这意味着一旦创建了String对象，就不能改变它的值。常用的方法包括 `concat()`、`substring()`、`indexOf()`、`replace()` 等。 - **StringBuffer/StringBuilder** 是可变的...

    java中队日期的操作

    Java中常用的日期类有`java.util.Date`和`java.time.LocalDate`（自Java 8开始）。在这个例子中，我们主要使用`Date`类和`Calendar`类。`Date`对象表示特定的瞬间，精确到毫秒。`Calendar`是一个抽象类，提供了日期...

Magicbox
Global site tag (gtag.js) - Google Analytics