java获取时间、获取日期
java获取时间、获取日期
1. java获得毫秒：System.currentTimeMillis()
2. java获得纳秒：System.nanoTime() (用于获取很精确的时间，推荐！)
3. java获得当前日期：
4. GregorianCalendar date_1=(GregorianCalendar)Calendar.getInstance();
5. java.sql.Date date_2= new java.sql.Date(date_1.getTime().getTime());
6.
7.
8. ---------------------------------------------------------------------------
------------
9.
10.import java.text.ParseException;
11.import java.text.SimpleDateFormat;
12.import java.util.Calendar;
13.import java.util.Date;
14.
15.public class DateTest {
16.public static void main(String[] args) throws ParseException {
17. Calendar now = Calendar.getInstance();
18. System.out.println("年: " + now.get(Calendar.YEAR));
19. System.out.println("月: " + (now.get(Calendar.MONTH) + 1));
20. System.out.println("日: " + now.get(Calendar.DAY_OF_MONTH));
21. System.out.println("时: " + now.get(Calendar.HOUR_OF_DAY));
22. System.out.println("分: " + now.get(Calendar.MINUTE));
23. System.out.println("秒: " + now.get(Calendar.SECOND));
24. System.out.println("当前时间毫秒数：" + now.getTimeInMillis());
25. System.out.println(now.getTime());
26.
27. Date d = new Date();
28. System.out.println(d);
29. SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
30.//SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss")
;
31. String dateNowStr = sdf.format(d);
32. System.out.println("格式化后的日期：" + dateNowStr);
33.
34. String str = "2012-08-20 17:52:07"; //要跟上面定义的格式一样
35. Date today = sdf.parse(str);
36. System.out.println("字符串转成日期：" + today);
37. }
38.}
39.输出结果：
40.
41.年: 2012
42.月: 8
43.日: 20
44.时: 17
45.分: 53
46.秒: 46
47.当前时间毫秒数：1345456426312
48.Mon Aug 2017:53:46 CST 2012
49.Mon Aug 2017:53:46 CST 2012
50.格式化后的日期：2012-08-2017:53:46
51.字符串转成日期：Mon Aug 2017:52:07 CST 2012
52.
53.----------------------------------------------------------------------------
-----------
54.
55.import java.text.DateFormat;
56.import java.text.ParsePosition;
57.import java.text.SimpleDateFormat;
58.import java.util.Calendar;
59.import java.util.Date;
60.import java.util.GregorianCalendar;
61.
62.public class TimeTest {
63.//用来全局控制上一周，本周，下一周的周数变化
64.private int weeks = 0;
65.private int MaxDate;//一月最大天数
66.private int MaxYear;//一年最大天数
67.public static void main(String[] args) {
68. TimeTest tt = new TimeTest();
69. System.out.println("获取当天日期:"+tt.getNowTime("yyyy-MM-dd"));
70. System.out.println("获取本周一日期:"+tt.getMondayOFWeek());
71. System.out.println("获取本周日的日期:"+tt.getCurrentWeekday());
72. System.out.println("获取上周一日期:"+tt.getPreviousWeekday());
73. System.out.println("获取上周日日期:"+tt.getPreviousWeekSunday());
74. System.out.println("获取下周一日期:"+tt.getNextMonday());
75. System.out.println("获取下周日日期:"+tt.getNextSunday());
76. System.out.println("获得相应周的周六的日
期:"+tt.getNowTime("yyyy-MM-dd"));
77. System.out.println("获取本月第一天日期:"+tt.getFirstDayOfMonth());
78. System.out.println("获取本月最后一天日期:"+tt.getDefaultDay());
79. System.out.println("获取上月第一天日
期:"+tt.getPreviousMonthFirst());
80. System.out.println("获取上月最后一天的日
期:"+tt.getPreviousMonthEnd());
81. System.out.println("获取下月第一天日期:"+tt.getNextMonthFirst());
82. System.out.println("获取下月最后一天日期:"+tt.getNextMonthEnd());
83. System.out.println("获取本年有多少天:"+tt.getMaxYear());
84. System.out.println("获取本年的第一天日
期:"+tt.getCurrentYearFirst());
85. System.out.println("获取本年最后一天日
期:"+tt.getCurrentYearEnd());
86. System.out.println("获取去年的第一天日
期:"+tt.getPreviousYearFirst());
87. System.out.println("获取去年的最后一天日
期:"+tt.getPreviousYearEnd());
88. System.out.println("获取明年第一天日期:"+tt.getNextYearFirst());
89. System.out.println("获取明年最后一天日期:"+tt.getNextYearEnd());
90. System.out.println("获取本季度第一天到最后一
天:"+tt.getThisSeasonTime(11));
91. System.out.println("获取两个日期之间间隔天数
2011-12-1~2012-7.29:"+TimeTest.getTwoDay("2012-7-29","2011-12-1"));
92. }
93.
94.
95./**
96. * 得到二个日期间的间隔天数
97. */
98.public static String getTwoDay(String sj1, String sj2) {
99. SimpleDateFormat myFormatter = new SimpleDateFormat("yyyy-MM-dd");
100.long day = 0;
101.try {
102. java.util.Date date = myFormatter.parse(sj1);
103. java.util.Date mydate = myFormatter.parse(sj2);
104. day = (date.getTime() - mydate.getTime()) / (24 * 60 * 60 * 1000 );
105. } catch (Exception e) {
106.return"";
107. }
108.return day + "";
109. }
110.
111.
112./**
113. * 根据一个日期，返回是星期几的字符串
114. */
115.public static String getWeek(String sdate) {
116.// 再转换为时间
117. Date date = TimeTest.strToDate(sdate);
118. Calendar c = Calendar.getInstance();
119. c.setTime(date);
120.// int hour=c.get(Calendar.DAY_OF_WEEK);
121.// hour中存的就是星期几了，其范围 1~7
122.// 1=星期日 7=星期六，其他类推
123.return new SimpleDateFormat("EEEE").format(c.getTime());
124. }
125.
126./**
127. * 将短时间格式字符串转换为时间 yyyy-MM-dd
128. */
129.public static Date strToDate(String strDate) {
130. SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
131. ParsePosition pos = new ParsePosition(0);
132. Date strtodate = formatter.parse(strDate, pos);
133.return strtodate;
134. }
135.
136./**
137. * 两个时间之间的天数
138. */
139.public static long getDays(String date1, String date2) {
140.if (date1 == null || date1.equals(""))
141.return0;
142.if (date2 == null || date2.equals(""))
143.return0;
144.// 转换为标准时间
145. SimpleDateFormat myFormatter = new SimpleDateFormat("yyyy-MM-dd");
146. java.util.Date date = null;
147. java.util.Date mydate = null;
148.try {
149. date = myFormatter.parse(date1);
150. mydate = myFormatter.parse(date2);
151. } catch (Exception e) {
152. }
153.long day = (date.getTime() - mydate.getTime()) / (24 * 60 * 60 * 1 000);
154.return day;
155. }
156.
157.
158.
159.
160.// 计算当月最后一天,返回字符串
161.public String getDefaultDay(){
162. String str = "";
163. SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd"); 164.
165. Calendar lastDate = Calendar.getInstance();
166. lastDate.set(Calendar.DATE,1);//设为当前月的1号
167. lastDate.add(Calendar.MONTH,1);//加一个月，变为下月的1号
168. lastDate.add(Calendar.DATE,-1);//减去一天，变为当月最后一天
169.
170. str=sdf.format(lastDate.getTime());
171.return str;
172. }
173.
174.// 上月第一天
175.public String getPreviousMonthFirst(){
176. String str = "";
177. SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd"); 178.
179. Calendar lastDate = Calendar.getInstance();
180. lastDate.set(Calendar.DATE,1);//设为当前月的1号
181. lastDate.add(Calendar.MONTH,-1);//减一个月，变为下月的1号
182.//lastDate.add(Calendar.DATE,-1);//减去一天，变为当月最后一天183.
184. str=sdf.format(lastDate.getTime());
185.return str;
186. }
187.
188.//获取当月第一天
189.public String getFirstDayOfMonth(){
190. String str = "";
191. SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd"); 192.
193. Calendar lastDate = Calendar.getInstance();
194. lastDate.set(Calendar.DATE,1);//设为当前月的1号
195. str=sdf.format(lastDate.getTime());
196.return str;
197. }
198.
199.// 获得本周星期日的日期
200.public String getCurrentWeekday() {
201. weeks = 0;
202.int mondayPlus = this.getMondayPlus();
203. GregorianCalendar currentDate = new GregorianCalendar();
204. currentDate.add(GregorianCalendar.DATE, mondayPlus+6);
205. Date monday = currentDate.getTime();
206.
207. DateFormat df = DateFormat.getDateInstance();
208. String preMonday = df.format(monday);
209.return preMonday;
210. }
211.
212.
213.//获取当天时间
214.public String getNowTime(String dateformat){
215. Date now = new Date();
216. SimpleDateFormat dateFormat = new SimpleDateFormat(dateform at);//可以方便地修改日期格式
217. String hehe = dateFormat.format(now);
218.return hehe;
219. }
220.
221.// 获得当前日期与本周日相差的天数
222.private int getMondayPlus() {
223. Calendar cd = Calendar.getInstance();
224.// 获得今天是一周的第几天，星期日是第一天，星期二是第二天......
225.int dayOfWeek = cd.get(Calendar.DAY_OF_WEEK)-1; //因为按中国礼拜一作为第一天所以这里减1
226.if (dayOfWeek == 1) {
227.return0;
228. } else {
229.return1 - dayOfWeek;
230. }
231. }
232.
233.//获得本周一的日期
234.public String getMondayOFWeek(){
235. weeks = 0;
236.int mondayPlus = this.getMondayPlus();
237. GregorianCalendar currentDate = new GregorianCalendar();
238. currentDate.add(GregorianCalendar.DATE, mondayPlus);
239. Date monday = currentDate.getTime();
240.
241. DateFormat df = DateFormat.getDateInstance();
242. String preMonday = df.format(monday);
243.return preMonday;
244. }
245.
246.//获得相应周的周六的日期
247.public String getSaturday() {
248.int mondayPlus = this.getMondayPlus();
249. GregorianCalendar currentDate = new GregorianCalendar();
250. currentDate.add(GregorianCalendar.DATE, mondayPlus + 7 * weeks + 6) ;
251. Date monday = currentDate.getTime();
252. DateFormat df = DateFormat.getDateInstance();
253. String preMonday = df.format(monday);
254.return preMonday;
255. }
256.
257.// 获得上周星期日的日期
258.public String getPreviousWeekSunday() {
259. weeks=0;
260. weeks--;
261.int mondayPlus = this.getMondayPlus();
262. GregorianCalendar currentDate = new GregorianCalendar();
263. currentDate.add(GregorianCalendar.DATE, mondayPlus+weeks); 264. Date monday = currentDate.getTime();
265. DateFormat df = DateFormat.getDateInstance();
266. String preMonday = df.format(monday);
267.return preMonday;
268. }
269.
270.// 获得上周星期一的日期
271.public String getPreviousWeekday() {
272. weeks--;
273.int mondayPlus = this.getMondayPlus();
274. GregorianCalendar currentDate = new GregorianCalendar();
275. currentDate.add(GregorianCalendar.DATE, mondayPlus + 7 * weeks);
276. Date monday = currentDate.getTime();
277. DateFormat df = DateFormat.getDateInstance();
278. String preMonday = df.format(monday);
279.return preMonday;
280. }
281.
282.// 获得下周星期一的日期
283.public String getNextMonday() {
284. weeks++;
285.int mondayPlus = this.getMondayPlus();
286. GregorianCalendar currentDate = new GregorianCalendar();
287. currentDate.add(GregorianCalendar.DATE, mondayPlus + 7); 288. Date monday = currentDate.getTime();
289. DateFormat df = DateFormat.getDateInstance();
290. String preMonday = df.format(monday);
291.return preMonday;
292. }
293.
294.// 获得下周星期日的日期
295.public String getNextSunday() {
296.
297.int mondayPlus = this.getMondayPlus();
298. GregorianCalendar currentDate = new GregorianCalendar();
299. currentDate.add(GregorianCalendar.DATE, mondayPlus + 7+6); 300. Date monday = currentDate.getTime();
301. DateFormat df = DateFormat.getDateInstance();
302. String preMonday = df.format(monday);
303.return preMonday;
304. }
305.
306.
307.
308.private int getMonthPlus(){
309. Calendar cd = Calendar.getInstance();
310.int monthOfNumber = cd.get(Calendar.DAY_OF_MONTH);
311. cd.set(Calendar.DATE, 1);//把日期设置为当月第一天
312. cd.roll(Calendar.DATE, -1);//日期回滚一天，也就是最后一天
313. MaxDate=cd.get(Calendar.DATE);
314.if(monthOfNumber == 1){
315.return -MaxDate;
316. }else{
317.return1-monthOfNumber;
318. }
319. }
320.
321.//获得上月最后一天的日期
322.public String getPreviousMonthEnd(){
323. String str = "";
324. SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
325.
326. Calendar lastDate = Calendar.getInstance();
327. lastDate.add(Calendar.MONTH,-1);//减一个月
328. lastDate.set(Calendar.DATE, 1);//把日期设置为当月第一天
329. lastDate.roll(Calendar.DATE, -1);//日期回滚一天，也就是本月最后一天330. str=sdf.format(lastDate.getTime());
331.return str;
332. }
333.
334.//获得下个月第一天的日期
335.public String getNextMonthFirst(){
336. String str = "";
337. SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd"); 338.
339. Calendar lastDate = Calendar.getInstance();
340. lastDate.add(Calendar.MONTH,1);//减一个月
341. lastDate.set(Calendar.DATE, 1);//把日期设置为当月第一天
342. str=sdf.format(lastDate.getTime());
343.return str;
344. }
345.
346.//获得下个月最后一天的日期
347.public String getNextMonthEnd(){
348. String str = "";
349. SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd"); 350.
351. Calendar lastDate = Calendar.getInstance();
352. lastDate.add(Calendar.MONTH,1);//加一个月
353. lastDate.set(Calendar.DATE, 1);//把日期设置为当月第一天
354. lastDate.roll(Calendar.DATE, -1);//日期回滚一天，也就是本月最后一天355. str=sdf.format(lastDate.getTime());
356.return str;
357. }
358.
359.//获得明年最后一天的日期
360.public String getNextYearEnd(){
361. String str = "";
362. SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd"); 363.
364. Calendar lastDate = Calendar.getInstance();
365. lastDate.add(Calendar.YEAR,1);//加一个年
366. lastDate.set(Calendar.DAY_OF_YEAR, 1);
367. lastDate.roll(Calendar.DAY_OF_YEAR, -1);
368. str=sdf.format(lastDate.getTime());
369.return str;
370. }
371.
372.//获得明年第一天的日期
373.public String getNextYearFirst(){
374. String str = "";
375. SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd"); 376.
377. Calendar lastDate = Calendar.getInstance();
378. lastDate.add(Calendar.YEAR,1);//加一个年
379. lastDate.set(Calendar.DAY_OF_YEAR, 1);
380. str=sdf.format(lastDate.getTime());
381.return str;
382.
383. }
384.
385.//获得本年有多少天
386.private int getMaxYear(){
387. Calendar cd = Calendar.getInstance();
388. cd.set(Calendar.DAY_OF_YEAR,1);//把日期设为当年第一天
389. cd.roll(Calendar.DAY_OF_YEAR,-1);//把日期回滚一天。
390.int MaxYear = cd.get(Calendar.DAY_OF_YEAR);
391.return MaxYear;
392. }
393.
394.private int getYearPlus(){
395. Calendar cd = Calendar.getInstance();
396.int yearOfNumber = cd.get(Calendar.DAY_OF_YEAR);//获得当天是一年中的第几天
397. cd.set(Calendar.DAY_OF_YEAR,1);//把日期设为当年第一天
398. cd.roll(Calendar.DAY_OF_YEAR,-1);//把日期回滚一天。
399.int MaxYear = cd.get(Calendar.DAY_OF_YEAR);
400.if(yearOfNumber == 1){
401.return -MaxYear;
402. }else{
403.return1-yearOfNumber;
404. }
405. }
406.//获得本年第一天的日期
407.public String getCurrentYearFirst(){
408.int yearPlus = this.getYearPlus();
409. GregorianCalendar currentDate = new GregorianCalendar();
410. currentDate.add(GregorianCalendar.DATE,yearPlus);
411. Date yearDay = currentDate.getTime();
412. DateFormat df = DateFormat.getDateInstance();
413. String preYearDay = df.format(yearDay);
414.return preYearDay;
415. }
416.
417.
418.//获得本年最后一天的日期 *
419.public String getCurrentYearEnd(){
420. Date date = new Date();
421. SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy");
//可以方便地修改日期格式
422. String years = dateFormat.format(date);
423.return years+"-12-31";
424. }
425.
426.
427.//获得上年第一天的日期 *
428.public String getPreviousYearFirst(){
429. Date date = new Date();
430. SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy");
//可以方便地修改日期格式
431. String years = dateFormat.format(date); int years_value = Integer .parseInt(years);
432. years_value--;
433.return years_value+"-1-1";
434. }
435.
436.//获得上年最后一天的日期
437.public String getPreviousYearEnd(){
438. weeks--;
439.int yearPlus = this.getYearPlus();
440. GregorianCalendar currentDate = new GregorianCalendar();
441. currentDate.add(GregorianCalendar.DATE,yearPlus+MaxYear*weeks+(MaxY
ear-1));
442. Date yearDay = currentDate.getTime();
443. DateFormat df = DateFormat.getDateInstance();
444. String preYearDay = df.format(yearDay);
445. getThisSeasonTime(11);
446.return preYearDay;
447. }
448.
449.//获得本季度
450.public String getThisSeasonTime(int month){
451.int array[][] = {{1,2,3},{4,5,6},{7,8,9},{10,11,12}};
452.int season = 1;
453.if(month>=1&&month<=3){
454. season = 1;
455. }
456.if(month>=4&&month<=6){
457. season = 2;
458. }
459.if(month>=7&&month<=9){
460. season = 3;
461. }
462.if(month>=10&&month<=12){
463. season = 4;
464. }
465.int start_month = array[season-1][0];
466.int end_month = array[season-1][2];
467.
468. Date date = new Date();
469. SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy");
//可以方便地修改日期格式
470. String years = dateFormat.format(date);
471.int years_value = Integer.parseInt(years);
472.
473.int start_days =1;//years+"-"+String.valueOf(start_month)+"-1";//ge tLastDayOfMonth(years_value,start_month);
474.int end_days = getLastDayOfMonth(years_value,end_month);
475. String seasonDate = years_value+"-"+start_month+"-"+start_days+";"+ years_value+"-"+end_month+"-"+end_days;
476.return seasonDate;
477.
478. }
479.
480./**
481. * 获取某年某月的最后一天
482. * @param year 年
483. * @param month 月
484. * @return 最后一天
485. */
486.private int getLastDayOfMonth(int year, int month) {
487.if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8
488. || month == 10 || month == 12) {
489.return31;
490. }
491.if (month == 4 || month == 6 || month == 9 || month == 11) { 492.return30;
493. }
494.if (month == 2) {
495.if (isLeapYear(year)) {
496.return29;
497. } else {
498.return28;
499. }
500. }
501.return0;
502. }
503./**
504. * 是否闰年
505. * @param year 年
506. * @return
507. */
508.public boolean isLeapYear(int year) {
509.return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
510. }
511.}
JAVA中获取当前时间
Java中获得当前时间的方法 2008年06月16日星期一下午 10:06 有两种方法： 方法一：用java.util.Date类来实现，并结合java.text.DateFormat类来实现时间的格式化，看下面代码： import java.util.*; import java.text.*; //以下默认时间日期显示方式都是汉语语言方式 //一般语言就默认汉语就可以了，时间日期的格式默认为MEDIUM风格，比如：2008-6-16 20:54:53 //以下显示的日期时间都是再Date类的基础上的来的，还可以利用Calendar类来实现见类TestDate2.java public class TestDate { public static void main(String[] args) { Date now = new Date(); Calendar cal = Calendar.getInstance(); DateFormat d1 = DateFormat.getDateInstance(); //默认语言（汉语）下的默认风格（MEDIUM风格，比如：2008-6-16 20:54:53） String str1 = d1.format(now); DateFormat d2 = DateFormat.getDateTimeInstance(); String str2 = d2.format(now); DateFormat d3 = DateFormat.getTimeInstance(); String str3 = d3.format(now); DateFormat d4 = DateFormat.getInstance(); //使用SHORT风格显示日期和时间 String str4 = d4.format(now); DateFormat d5 = DateFormat.getDateTimeInstance(DateFormat.FULL,DateFormat.FULL); //显示日期，周，时间（精确到秒） String str5 = d5.format(now); DateFormat d6 = DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG); //显示日期。时间（精确到秒） String str6 = d6.format(now); DateFormat d7 = DateFormat.getDateTimeInstance(DateFormat.SHORT,DateFormat.SHORT); //显示日期，时间（精确到分） String str7 = d7.format(now); DateFormat d8 = DateFormat.getDateTimeInstance(DateFormat.MEDIUM,DateFormat.MEDIUM);
基于java Web 的在线拍卖系统
华北科技学院 课程设计说明书 技能训练类（三） 学号：201207034102 班级: 信管B121 姓名：何欢 设计题目:_____在线拍卖系统________________ 设计地点:____基础五_______________________ 设计时间: 2015.3.10 至2015.4.17 成绩评定： 1、工作量： A（），B（），C（），D（）,F( ) 2、难易度：A（），B（），C（），D（）,F( ) 3、答辩情况： 基本操作：A（），B（），C（），D（）,F( ) 代码理解：A（），B（），C（），D（）,F( ) 4、报告规范度：A（），B（），C（），D（）,F( ) 5、学习态度：A（），B（），C（），D（）,F( ) 总评成绩:_________________________________ 指导教师:_________________________________
1、课程设计的目的 技能训练的内容围绕一个信息管理系统的实际开发过程进行组织，重点在于程序设计开发部分。信息管理系统的题目由教师指定或学生自行拟定，学生根据教师提出的系统在应用环境、系统规模、数据量、业务流程等方面的要求，进行需求分析、数据库设计、数据库实施、程序开发和测试，最终完成系统。 技能训练的目的和要求： （1）使学生巩固和加强《java基础》与《》课程的理论知识。 （2）使学生掌握程序设计开发的步骤。 （3）使学生掌握model2以上的开发系统的方法。 （4）使学生掌握使用数据库管理信息数据的方法。 （5）使学生掌握使用JA V A等程序设计语言连接和操作数据库的方法。 （6）使学生掌握调试程序的基本方法及上机操作方法。 （7）使学生初步掌握开发一个小型信息管理系统的基本步骤，引导学生根据实际业务流程和需求进行系统分析与设计，并建立需要的数据库，最后通过编写代码和调试完成系统。 2、软件需求分析和总体设计 2.1软件功能 拍卖系统是一个在线系统，系统设计为B/S模式，用户在浏览器请求服务端的资源。包含的功能有： ①查看竟得物品 ②浏览流拍物品 ③管理种类 ④管理物品 ⑤浏览拍卖物品 ⑥查看自己的竞标 功能模块框图下图所示（图2-1-1）：
Java课程设计飞机航班管理系统
一．引言 1.1项目的名称 飞机航班信息管理系统 1.2项目背景和目标 飞机航班信息管理系统主要能够查询飞机的航班情况，飞行线路，票价，折扣 等等情况，并能够在数据库中更新维护飞机航班的信息，对飞机航班数据库进 行管理，如航班的增加，删除和修改等。我们的目标就是为该系统提供后台连 接数据库程序设计以及前台用户界面设计。 1.3项目的可行性研究 设计此系统需要java面向对象编程基础，数据库应用知识以及功能分析。根据目前所开设的课程，学生已经具备这样的知识，有能力综合java编程知识和数据库应用知识做出一个这样的飞机航班信息管理系统。 二、需求分析 2．1系统概述 此系统提供给系统管理员和用户。系统管理员登陆后可以对飞机航班信息进行管理，如：添加飞机航班信息，删除飞机航班信息，修改飞机航班属性。用户登陆后能进行飞机航班信息查询，订票以及退订。 2．2系统运行环境 Java运行在eclipse软件上，数据库用mysql数据库 2．3功能需求描述 用户选择相关的服务项目可以查看相关航班基本信息，并且可以根据自己需求选择相应服务，系统的信息更新时，相关的信息经过相应处理后，会存入到飞机航班数据库中的航班信息记录表中；系统管理员根据航空公司实际情况可以更新航班信息，并通过修改信息处理后被保存到飞机航班表中。 三、系统设计 开发与设计的总体思想 飞机航班信息管理系统主要分为用户和系统管理员2类，因此也将该系统分为2个相应的大的功能模块。 用户可以通过服务项目选择查询相关航班情况，进行订票，退订等服务项目。系统会将数据库中相应信息反馈给顾客。 系统管理员负责管系统信息的及时更新，可以根据航空公司航班的具体的情况更新数据库。 系统模块结构图
java获取当前时间
有两种方法： 方法一：用java.util.Date类来实现，并结合java.text.DateFormat类来实现时间的格式化，看下面代码： import java.util.*; import java.text.*; //以下默认时间日期显示方式都是汉语语言方式 //一般语言就默认汉语就可以了，时间日期的格式默认为MEDIUM风格，比如：2008-6-16 20:54:53 //以下显示的日期时间都是再Date类的基础上的来的，还可以利用Calendar类来实现见类TestDate2.java public class TestDate { public static void main(String[] args) { Date now = new Date(); Calendar cal = Calendar.getInstance(); DateFormat d1 = DateFormat.getDateInstance(); //默认语言（汉语）下的默认风格（MEDIUM风格，比如：2008-6-16 20:54:53） String str1 = d1.format(now); DateFormat d2 = DateFormat.getDateTimeInstance(); String str2 = d2.format(now); DateFormat d3 = DateFormat.getTimeInstance(); String str3 = d3.format(now); DateFormat d4 = DateFormat.getInstance(); //使用SHORT风格显示日期和时间 String str4 = d4.format(now); DateFormat d5 = DateFormat.getDateTimeInstance(DateFormat.FULL,DateFormat.FULL); //显示日期，周，时间（精确到秒） String str5 = d5.format(now); DateFormat d6 = DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG); //显示日期。时间（精确到秒） String str6 = d6.format(now); DateFormat d7 = DateFormat.getDateTimeInstance(DateFormat.SHORT,DateFormat.SHORT); //显示日期，时间（精确到分） String str7 = d7.format(now);
java获得当前服务器的操作系统
import java.util.Properties; public class Test{ public static void main (String args[]){ Properties props=System.getProperties(); //系统属性 System.out.println("Java的运行环境版本："+props.getProperty("java.version")); System.out.println("Java的运行环境供应商："+props.getProperty("java.vendor")); System.out.println("Java供应商的URL："+props.getProperty("java.vendor.url")); System.out.println("Java的安装路径："+props.getProperty("java.home")); System.out.println("Java的虚拟机规范版本："+props.getProperty("java.vm.specification.version")); System.out.println("Java的虚拟机规范供应商："+props.getProperty("java.vm.specification.vendor")); System.out.println("Java的虚拟机规范名称："+props.getProperty("https://www.360docs.net/doc/a816820455.html,")); System.out.println("Java的虚拟机实现版本："+props.getProperty("java.vm.version")); System.out.println("Java的虚拟机实现供应商："+props.getProperty("java.vm.vendor")); System.out.println("Java的虚拟机实现名称："+props.getProperty("https://www.360docs.net/doc/a816820455.html,")); System.out.println("Java运行时环境规范版本："+props.getProperty("java.specification.version")); System.out.println("Java运行时环境规范供应商："+props.getProperty("java.specification.vender")); System.out.println("Java运行时环境规范名称："+props.getProperty("https://www.360docs.net/doc/a816820455.html,"));
Java中获取比毫秒更精确的时间
] java中获取比毫秒更为精确的时间 (2012-07-03 11:54:33) 转载▼ 分类：实践经验 标签： 杂谈 from: https://www.360docs.net/doc/a816820455.html,/paul_lh/article/details/6419982 关键词：java 毫秒微秒纳秒System.currentTimeMillis() 误差 在对新写的超快xml解析器和xpath引擎进行效率测试时，为获取执行时间，开始也没多想就用了System.currentTimeMillis() 来做的。由此碰到一个极其诡异的问题，同样的代码循环执行数次，分析每一次的执行时间，发现一大部分执行时间为小于1毫秒，但其间也发现有相当一部分的执行时间有非常大的跳跃，而且时间都近似16毫秒左右。这个1毫秒和16毫秒结果，以计算机的运行速度看，差距是惊人的，必须找出其原因。 根据经验，在16毫秒时间内，cpu可以运算的指令数量是相当惊人的，所以可以基本断定这16ms的差距，应当不是cpu在执行指令，另外因为测试过程中gc输出也已经打开，未见gc发生，所以怀疑可能是发生了什么io阻塞，比如文件读写、加载类库、或者什么网络操作等，由于笔者测试的系统的环境比较复杂，其间有用到ehCache，数据库操作等，排查起来非常不容易。 在困扰了好一阵之后，忽然想到可能计时系统有误差，这才翻回来查了下 System.currentTimeMillis() 的文档，原来这个方法调用了个native方法，获取的时间精度会依赖于操作系统的实现机制。奶奶的！ 既然不准，就看看有没更准的方法，在jdk5源码中，挨着System.currentTimeMillis() 定义就是System.nanoTime() 方法，靠，一下来了个精准1000000倍的取纳秒的方法，不过看
操作系统时间片轮转RR进程调度算法java版
实验二间片轮转RR 进程调度算法 1、实验目的通过这次实验，加深对进程概念的理解，进一步掌握进程状态 的转变、进程调度的策略及对系统性能的评价方法。 2、试验内容 问题描述：设计程序模拟进程的时间片轮转RR调度过程。假设有n 个进程分别在T1, ?,T n 时刻到达系统，它们需要的服务时间分别为 S1, ?,n S。分别利用不同的时间片大小q，采用时间片轮转RR进程调度算法进行调度，计算每个进程的完成时间、周转时间和带权周转时间，并且统计n个进程的平均周转时间和平均带权周转时间。 3、程序要求： 1）进程个数n；每个进程的到达时间T1, ?,T n 和服务时间S1, ?,n S；输入时间片大小q。 2）要求时间片轮转法RR调度进程运行，计算每个进程的周转时间和带权周转时间，并且计算所有进程的平均周转时间和带权平均周转时间； 3）输出：要求模拟整个调度过程，输出每个时刻的进程运行状态，如“时刻3：进程 B 开始运行”等等； 4）输出：要求输出计算出来的每个进程的周转时间、带权周转时间、所有进程的平均周转时间以及带权平均周转时间。 4、需求分析 (1)输入的形式和输入值的范围 时间片真实进程数各进程的到达时间各进程的服务时间
(2)输出的形式模拟整个调度过程、周转时间、带权周转时间、所有进程的平均周转时间以及带权平均周转时间。 (3)测试用例 由于自己自编写代码方面与他人有一定的差距，因此在做实验的过程中我在网上搜了很多相关的资料，了解实现该算法的原理及各部分实现的代码，同时参考了几个别人写好的源代码，然后自己在理解的基础上不断的根据要求修改写程序，不过其中碰见的很多的问题。我已经自己调了好多错误，在一遍遍的调试和修改中，发现自己的经验在快速增长，这个感觉真的很不错。然而，实验的运行结果还不是 很完美，每个进程在最后一个时间片的运行过程中，进程列表的更新总是修改错误。不过在在本次试验中学到了不少东西，一点点的在进 6、测试结果 输入时间片,进程数,进程到达时间,服务时间
Java取日期的所有时间点可根据年月日
package com.util; import java.text.DateFormat; import java.text.ParseException; import java.text.ParsePosition; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; import java.util.GregorianCalendar; public class TimeUtil { //用来全局控制上一周，本周，下一周的周数变化 private int weeks = 0; private int MaxDate;//一月最大天数 private int MaxYear;//一年最大天数 /** * @param args */ public static void main(String[] args) { TimeUtil tt = new TimeUtil(); // System.out.println("获取当天日期:"+tt.getNowTime("yyyy-MM-dd")); // System.out.println("获取本周一日期:"+tt.getMondayOFWeek()); // System.out.println("获取本周日的日期~:"+tt.getCurrentWeekday()); // System.out.println("获取上周一日期:"+tt.getPreviousWeekday()); // System.out.println("获取上周日日期:"+tt.getPreviousWeekSunday()); // System.out.println("获取下周一日期:"+tt.getNextMonday()); // System.out.println("获取下周日日期:"+tt.getNextSunday()); // System.out.println("获得相应周的周六的日期:"+tt.getNowTime("yyyy-MM-dd")); // System.out.println("获取本月第一天日期:"+tt.getFirstDayOfMonth()); // System.out.println("获取本月最后一天日期:"+tt.getDefaultDay()); // System.out.println("获取上月第一天日期:"+tt.getPreviousMonthFirst()); // System.out.println("获取上月最后一天的日期:"+tt.getPreviousMonthEnd()); // System.out.println("获取下月第一天日期:"+tt.getNextMonthFirst()); // System.out.println("获取下月最后一天日期:"+tt.getNextMonthEnd()); // System.out.println("获取本年的第一天日期:"+tt.getCurrentYearFirst()); DateFormat fmt =new SimpleDateFormat("yyyy-MM-dd"); Date date = null; try { date = fmt.parse("2008-02-21"); } catch (ParseException e) {
Java实验三常用系统类的使用
实验三常用系统类的使用 一、实验目的 了解Java 常用的系统类，包括字符串类、输入输出流类、数学函数类、日期类、随机数类以及向量类（学习继承内容后做）等的基本使用方法。理解Java 系统类的构成。二、实验要求 1．掌握不同类型的输入输出流类，标准数据流、文件流、数据输入输出流、对象流等。 2．掌握数学函数类的使用方法。 3．掌握日期类的使用方法。 4．掌握向量类的使用方法。 使用数学函数类 Math 是一个最终类，含有基本数学运算函数，如指数运算、对数运算、求平方根、三角函数、随机数等，可以直接在程序中加Math.前缀调用。 1．创建使用Math 类的应用程序KY5_8.java，源程序如下。 import java.util.*; class KY5_8 { public static void main(String args[]) { Random r1=new Random(1234567890L); Random r2=new Random(1234567890L); boolean b=r1.nextBoolean(); // 随机数不为0 时取真值 int i1=r1.nextInt(100); // 产生大于等于0 小于100 的随机数 int i2=r2.nextInt(100); // 同上 double i3=r1.nextDouble(); // 产生大于等于0.0 小于1.0 的随机数 double i4=r2.nextDouble(); // 同上 double d1=Math.sin(Math.toRadians(30.0)); double d2=Math.log(Math.E); double d3=Math.pow(2.0, 3.0); int r=Math.round(33.6F); System.out.println("b 的随机数不为0 时"+b); System.out.println("i1 的随机数为"+i1); System.out.println("i2 的随机数为"+i2); System.out.println("d1 的随机数为"+i3); System.out.println("d2 的随机数为"+i4); System.out.println("30 弧度的正弦值：Math.sin(Math.toRadians(30.0))＝"+d1); System.out.println("E 的对数值：Math.log(Math.E)＝"+d2); System.out.println("2 的3 次方：Math.pow(2.0, 3.0)＝"+d3); System.out.println("33.6F 四舍五入：Math.round(33.6F)＝"+r); } }
java显示当前时间
显示当前时间： System.CurrentTimeMillis();来获取所过的毫秒数 java.sql.date是java.util.date的子集，在sql语句中的date都是sql.date Date 类从Java 开发包(JDK) 1.0 就开始进化, 当时它只包含了几个取得或者设置一个日期数据的各个部分的方法, 比如说月, 日, 和年. 这些方法现在遭到了批评并且已经被转移到了Calendar类里去了, 我们将在本文中进一步讨论它. 这种改进旨在更好的处理日期数据的国际化格式. 就象在JDK 1.1中一样, Date 类实际上只是一个包裹类, 它包含的是一个长整型数据, 表示的是从GMT(格林尼治标准时间)1970年, 1 月1日00:00:00这一刻之前或者是之后经历的毫秒数. 创建一个日期对象 让我们看一个使用系统的当前日期和时间创建一个日期对象并返回一个长整数的简单例子. 这个时间 通常被称为Java 虚拟机(JVM)主机环境的系统时间. import java.util.Date; public class DateExample1 { public static void main(String[] args) { // Get the system date/time Date date = new Date(); System.out.println(date.getTime());
} } 在星期六, 2001年9月29日, 下午大约是6:50的样子, 上面的例子在系统输出设备上显示的结果是1001803809710. 在这个例子中,值得注意的是我们使用了Date 构造函数创建一个日期对象, 这个构造函数没有接受任何参数. 而这个构造函数在内部使用了System.currentTimeMillis() 方法来从系统获取日期. 那么, 现在我们已经知道了如何获取从1970年1月1日开始经历的毫秒数了. 我们如何才能以一种用户明白的格式来显示这个日期呢? 在这里类java.text.SimpleDateFormat 和它的抽象基类 java.text.DateFormat 就派得上用场了. 日期数据的定制格式 假如我们希望定制日期数据的格式, 比方星期六-9月-29日-2001年. 下面的例子展示了如何完成这个工作: import java.text.SimpleDateFormat; import java.util.Date; public class DateExample2 { public static void main(String[] args) { SimpleDateFormatbartDateFormat=newSimpleDateFormat("EEEE-MMMM -dd-yyyy"); Date date = new Date(); System.out.println(bartDateFormat.format(date)); } } 只要通过向SimpleDateFormat 的构造函数传递格式字符串"EEE-MMMM-dd-yyyy", 我们就能够指明自己想要的格式. 你应该可以看见, 格式字符串中的ASCII 字符告诉格式化函数下面显示日期数据的哪一个部分. EEEE是星期, MMMM是月, dd是日, yyyy是年. 字符的个数决定了日期是如何格式化的.传递"EE-MM-dd-yy"会显示Sat-09-29-01. 请察看Sun 公司的Web 站点获取日期格式化选项的完整的指示. 将文本数据解析成日期对象 假设我们有一个文本字符串包含了一个格式化了的日期对象, 而我们希望解析这个字符串并从文本日期数据创建一个日期对象. 我们将再次以格式化字符串"MM-dd-yyyy" 调用SimpleDateFormat类, 但是这一次, 我们使用格式化解析而不是生成一个文本日期数据. 我们的例子, 显示在下面, 将解析文本字符串 "9-29-2001"并创建一个值为001736000000 的日期对象. 例子程序:
操作系统课程设计时间片轮转算法java实现
操作系统课程设计时间 片轮转算法j a v a实现 Document serial number【UU89WT-UU98YT-UU8CB-UUUT-UUT108】
学校代码： 10128 课程设计 题目：处理机管理模拟系统的设计与 实现 学生姓名： 学院：信息工程学院 系别：软件工程系 专业：软件工程 班级： 指导教师：副教授 讲师 2013年1月8日
内蒙古工业大学课程设计任务书（四） 学院（系）：信息学院软件工程系课程名称：操作系统课程设计指导教师（签名）： 专业班级：学生姓名：学号：
摘要 操作系统是计算机系统的关键组成部分，负责管理与配置内存、决定系统资源供需的优先次序、控制输入与输出设备、操作网络与管理文件系统等基本任务。对于不同的系统和系统目标，通常采用不同的调度算法，如在批处理系统中，为照顾为数众多的短作业，采用短作业优先调度算法；在分时系统中，为保证系统具有合理的响应时间，采用时间片轮转法进行调度。采用算法时，则要考虑多方面因素，以便达到最佳效果。本次课程设计采用时间片轮转调度算法来实现模拟进程调度任务的执行过程。 用Java模拟进程调度过程，可以方便地将运行结果直观地表示出来。Java语言独有的多线程操作，可以实现许多其他语言不能实现的功能，极大地方便了程序开发人员对程序的开发。此外，利用JavaGUI编程，可以使系统提供的界面更加友好。实验中，应用文件I/O操作、线程、AWT、Swing、内部类、接口、异常处理等技术，开发此系统。 关键字：时间片轮转； Java编程； GUI图形用户界面；文件操作；
Abstract The operating system is a key component of the computer system, responsible for the management and configuration memory, decided to system resources supply and demand priority, control input and output equipment, operation and management of network file system, and other basic different systems and system target, computers usually use different scheduling algorithm, such as in a Batch Processing System, in order to take care of a lot of short operation, using Short Job First algorithm;In systems with time sharing, to ensure the system has reasonable response time, need time slice Round Robin algorithm for scheduling. The algorithm, we should consider various factors, in order to achieve the best Course Design uses time slice Round Robin algorithm to simulate the process scheduling task execution process. With Java simulation process scheduling process, which can be conveniently will run results intuitively said addition, the use of JavaGUI programming, can make the system to provide the interface more , application file I/O operation, threads, AWT, Swing, internal class, interface, abnormal processing technology, the development of this system. Keywords: time slice Round Robin; Java Programming; ; File Operation;
Java 日期时间
Java 日期时间 java.util 包提供了Date 类来封装当前的日期和时间。Date 类提供两个构造函数来实例化Date 对象。 第一个构造函数使用当前日期和时间来初始化对象。 Date( ) 第二个构造函数接收一个参数，该参数是从1970年1月1日起的毫秒数。 Date(long millisec) Date对象创建以后，可以调用下面的方法。 序号方法和描述 1 boolean after(Date date) 若当调用此方法的Date对象在指定日期之后返回true,否则返回false。 2 boolean before(Date date) 若当调用此方法的Date对象在指定日期之前返回true,否则返回false。 3 Object clone( ) 返回此对象的副本。 4 int compareTo(Date date) 比较当调用此方法的Date对象和指定日期。两者相等时候返回0。调用对象在指定日期之前则返回负数。调用对象在指定日期之后则返回正数。
5 int compareTo(Object obj) 若obj 是Date 类型则操作等同于compareTo(Date) 。否则它抛出ClassCastException 。 6 boolean equals(Object date) 当调用此方法的Date 对象和指定日期相等时候返回true,否则返回false 。 7 long getTime( ) 返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。 8 int hashCode( ) 返回此对象的哈希码值。 9 void setTime(long time) 用自1970年1月1日00:00:00 GMT 以后time 毫秒数设置时间和日期。 10 String toString( ) 把此 Date 对象转换为以下形式的 String ： dow mon dd hh:mm:ss zzz yyyy 其中： dow 是一周中的某一天 (Sun, Mon, Tue, Wed, Thu, Fri, Sat)。 获取当前日期时间 Java 中获取当前日期和时间很简单，使用 Date 对象的 toString() 方法来打印当前日期和时间，如下所示： 实例
Java日志系统框架的设计与实现
Java日志系统框架的设计与实现 在Java领域，存在大量的日志组件，open-open收录了21个日志组件。日志系统作为一种应用程序服务，对于跟踪调试、程序状态记录、崩溃数据恢复都有着重要的作用，我们可以把Java日志系统看作是必不可少的跟踪调试工具。 1.简介 日志系统是一种不可或缺的跟踪调试工具，特别是在任何无人职守的后台程序以及那些没有跟踪调试环境的系统中有着广泛的应用。长期以来，日志系统作为一种应用程序服务，对于跟踪调试、程序状态记录、崩溃数据恢复都有非常现实的意义。这种服务通常以两种方式存在： 1.日志系统作为服务进程存在。Windows中的的事件日志服务就属于这种类型，该类型的日志系统通常通过消息队列机制将所需要记录的日志由日志发送端发送给日志服务。日志发送端和日志保存端通常不在同一进程当中，日志的发送是异步过程。这种日志服务通常用于管理员监控各种系统服务的状态。 2.日志系统作为系统调用存在。Java世界中的日志系统和Unix环境下诸多守护进程所使用的日志系统都属于这种类型。日志系统的代码作为系统调用被编译进日志发送端，日志系统的运行和业务代码的运行在同一进程空间。日志的发送多数属于同步过程。这种日志服务由于能够同步反映处系统运行状态，通常用于调试跟踪和崩溃恢复。 本文建立的日志系统基本属于第二种类型，但又有所不同。该日志系统将利用Java线程技术实现一个既能够反映统一线程空间中程序运行状态的同步日志发送过程，又能够提供快速的日志记录服务，还能够提供灵活的日志格式配置和过滤机制。 1.1系统调试的误区 在控制台环境上调试Java程序时，此时往控制台或者文本文件输出一段文字是查看程序运行状态最简单的做法，但这种方式并不能解决全部的问题。有时候，对于一个我们无法实时查看系统输出的系统或者一个确实需要保留我们输出信息的系统，良好的日志系统显得相当必要。因此，不能随意的输出各种不规范的调试信息，这些随意输出的信息是不可控的，难以清除，可能为后台监控、错误排除和错误恢复带来相当大的阻力。 1.2日志系统框架的基本功能 一个完备的日志系统框架通常应当包括如下基本特性： 所输出的日志拥有自己的分类：这样在调试时便于针对不同系统的不同模块进行查询，从而快速定位到发生日志事件的代码。
java把当前时间转换成一个无符号的字符串
用java实现把当前时间转换成无符号的字符串 import java.util.Date; import java.text.SimpleDateFormat; public class CurrentTime { public String getCurrentTime()//获得当前时间 { Date now = new Date(); SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss"); String time= dateFormat.format( now ); return time; } public String splitString(String str,String n)//字符拆分方法 { String st[]=str.split(n); str=""; for(int i=0;i 实验六常用系统类 【开发语言及实现平台或实验环境】 Windows2000 或XP，JDK1.6与Jcreator4.0 【实验目的】 1．了解Java 常用的系统类，包括Java Applet、字符串类、输入输出流类、数学函数类、日期类、随机数类以及向量类等的基本使用方法。 2．理解Java 系统类的构成。 【实验要求】 1. 进一步了解Applet 类。 2. 掌握字符串类的使用方法。 3. 掌握数学函数类的使用方法。 4. 掌握日期类的使用方法。 5. 掌握向量类的使用方法 【实验内容】 （一）了解Applet 的生命周期 程序运行从开始大结束的过程称为程序的生命周期。独立应用程序的生命周期从main （）方法开始，直到运行结束。而Applet 应用程序的生命周期与浏览器相关。作为浏览器的一部分，Applet 程序何时运行，何时结束都由浏览器控制，Applet 对象只是作为浏览器窗口中运行的一个线程。浏览器与Applet 具有如下关系。 ●在浏览器中打开包含Applet 对象的页面时，创建并初始化其中的Applet 对象。 ●显示Applet 时，启动Applet 线程运行。 ●不显示Applet 时，停止 Applet 线程运行。 ●在浏览器中关闭页面窗口时，销毁Applet 对象。 与此相应，Applet 类中声明了与生命周期相关的4 个方法：init（）、start（）、stop（）、destroy（）。4 个方法代表Applet 的4 个活动阶段。 1．创建揭示Applet 生命周期的程序LX5_1.java。 （1）程序功能：本程序包含Applet 的4 个与生命周期相关的方法init（）、start（）、stop（）、destroy（）。程序中创建了自定义方法addWords（）来显示相应的字符串。addWords 方法首先在标准输出即屏幕上显示字符串参数，然后将字符串添加到字符串缓冲区buffer，通过调用repaint 方法重画页面，首先自动调用updata 方法将当前画面清空，然后再调用paint 方法在指定位置显示字符串。 （2）编写LX5_1.java 程序文件，源代码如下。 import java.applet.Applet; import java.awt.Graphics; public class LX5_1 extends Applet { StringBuffer buffer=new StringBuffer(); public void init() { addWords("执行了初始化方法 init()..."); } public void start() { addWords("执行了开始方法start()..."); 第6章时刻、日期和数字 6.1 Date类 Date a=new Date(); (1)Date类在java.util包中。使用Date类的无参数构造方法创建的对象能够猎取本地当前时刻。Date对象表示时刻的默认顺序是星期、月、日、小时、分、秒、年。 例如：Sat Apr 28 21：59：38 CST 2001 (2)我们可能希望按着某种适应来输出时刻，比如时刻的顺序：年月星期日或年月星期日小时分秒。 这时能够使用DataFormat的子类SimpleDateFormat来实现时期的格式化。SimpleDateFormat有一个常用构造方法： public SimpleDateFormat(String pattern)。 该构造方法能够用参数pattern指定的格式创建一个对象，该对象调用 format(Date date) 方法格式化时刻对象date。需要注意的是，pattern中应当含有一些有效的字符序列。例如： ● y或yy 表示用两位数字输出年份 yyyy表示用4位数字输出年份。 ● M或MM 表示用两位数字或文本输出月份，假如想用汉字输出月份，pattern中应连续包含至少3个M，如MMM。 ● d或dd 表示用两位数字输出日。 ● H或HH 表示用两位数字输出小时。 ● m或mm 表示用两位数字输出分。 ● s或ss 表示用两位数字输出秒。 ● E 表示用字符串输出星期。在下面的例子dateformat.java中，我们用3种格式输出时刻。 (3)Java日期时刻及其格式化能够用System类的静态方法public static long currentTimeMillis()猎取系统当前时刻，那个时刻是从1970年1月1日0点到目前时刻所走过的毫秒数 本文由我司收集整编，推荐下载，如有疑问，请与我司联系Java 获取Linux 和Window 系统CPU、内存和磁盘总使用率的情况 2017/05/08 0 这是一个工具类，获取的内容： CPU 使用率：得到的是当前CPU 的使用情况，这是算出的是两次500 毫秒时间 差的CPU 使用率 内存使用率：[1 - 剩余的物理内存/(总的物理内存+虚拟内存) ] * 100 磁盘总使用率：[1 - 磁盘空余大小/磁盘总大小] * 100 下面开始贴代码：使用暂时没有发现什么问题，如果有问题，咱们可以一起讨论package com.util; import java.io.BufferedReader;import java.io.File;import java.io.FileInputStream;import java.io.InputStreamReader;import java.io.LineNumberReader;import https://www.360docs.net/doc/a816820455.html,ng.management.ManagementFactory;import java.math.BigDecimal;import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;import java.util.StringTokenizer; import org.apache.log4j.Logger; import com.sun.management.OperatingSystemMXBean; public class ComputerMonitorUtil { private static String osName = System.getProperty(“https://www.360docs.net/doc/a816820455.html,”);private static final int CPUTIME = 500;private static final int PERCENT = 100;private static final int FAULTLENGTH = 10;private static final Logger logger = Logger.getLogger(ComputerMonitorUtil.class); /** * 功能：获取Linux 和Window 系统cpu 使用率* */public static double getCpuUsage() {// 如果是window 系统if (osName.toLowerCase().contains(“windows”)||osName.toLowerCase().contains(“win”)) {try {String procCmd = System.getenv(“windir”)+“//system32//wbem//wmic.exe process get Caption,CommandLine,KernelModeTime,ReadOperationCount,ThreadCount,UserModeTiJava实验 常用系统类
Java之时间、日期与数字
Java获取Linux和Window系统CPU、内存和磁盘总使用率的情况