String'ජනවාරි 2, 2010' ආකෘතියෙන් Dateජාවා භාෂාවට පරිවර්තනය කිරීමට හොඳම ක්‍රමය කුමක්ද?
අවසානයේදී, මට භාවිතා කළ හැකි වන පරිදි මාසය, දිනය සහ වර්ෂය පූර්ණ සංඛ්‍යා ලෙස බිඳ දැමීමට මට අවශ්‍යය
Date date = new Date();
date.setMonth()..
date.setYear()..
date.setDay()..
date.setlong currentTime = date.getTime();
දිනය නියමිත වේලාවට පරිවර්තනය කිරීමට.
Dateකර ඇත.
java.util.Date, java.util.Calendarසහ java.text.SimpleTextFormatදැන් උරුමය විසින් විස්ථාපනය කර, java.time පන්ති. ඔරකල්ගේ නිබන්ධනය බලන්න .
Answers:
එය දුෂ්කර ක්‍රමය වන අතර, java.util.Dateජාවා 1.1 (1997) සිට එම සැකසුම් ක්‍රම ඉවත් කර ඇත. ආදාන නූලට ගැලපෙන ආකෘති රටාවක් භාවිතා SimpleDateFormatකරමින් දිනය සරලව සංයුති කරන්න .
ආදාන නූල ලෙස ඔබේ “2010 ජනවාරි 2” විශේෂිත අවස්ථාවෙහිදී:
MMMMරටාව භාවිතා කරන්නdරටාව භාවිතා කරන්න .yyyyරටාව භාවිතා කරන්න .String string = "January 2, 2010";
DateFormat format = new SimpleDateFormat("MMMM d, yyyy", Locale.ENGLISH);
Date date = format.parse(string);
System.out.println(date); // Sat Jan 02 00:00:00 GMT 2010
පැහැදිලි Localeතර්කයේ වැදගත්කම සැලකිල්ලට ගන්න . ඔබ එය මඟ හැරියහොත් , එය ආදාන නූලෙහි මාසයේ නමෙහි භාවිතා වන පරිදි අනිවාර්යයෙන්ම ඉංග්‍රීසි නොවන පෙරනිමි පෙදෙසක් භාවිතා කරයි . පෙදෙසි ආදාන නූල සමඟ නොගැලපේ නම්, java.text.ParseExceptionආකෘති රටාව වලංගු යැයි පෙනුනද ඔබ ව්‍යාකූල ලෙස ලබා ගනී .
ජාවාඩොක් වෙතින් අදාළ වන සාරය මෙන්න , පවතින සියලුම ආකෘති රටා ලැයිස්තුගත කරන්න:
Letter Date or Time Component Presentation Examples
------ ---------------------- ------------------ -------------------------------------
G Era designator Text AD
y Year Year 1996; 96
Y Week year Year 2009; 09
M/L Month in year Month July; Jul; 07
w Week in year Number 27
W Week in month Number 2
D Day in year Number 189
d Day in month Number 10
F Day of week in month Number 2
E Day in week Text Tuesday; Tue
u Day number of week Number 1
a Am/pm marker Text PM
H Hour in day (0-23) Number 0
k Hour in day (1-24) Number 24
K Hour in am/pm (0-11) Number 0
h Hour in am/pm (1-12) Number 12
m Minute in hour Number 30
s Second in minute Number 55
S Millisecond Number 978
z Time zone General time zone Pacific Standard Time; PST; GMT-08:00
Z Time zone RFC 822 time zone -0800
X Time zone ISO 8601 time zone -08; -0800; -08:00රටා සිද්ධි සංවේදී බවත්, අක්ෂර හතරක් හෝ ඊට වැඩි පෙළ පදනම් කරගත් රටා සම්පූර්ණ ස්වරූපය නියෝජනය කරන බවත් සලකන්න. නොමැති නම් කෙටි හෝ සංක්ෂිප්ත පෝරමයක් භාවිතා කරයි. එබැවින් උදා MMMMMහෝ ඊට වැඩි ගණනක් අනවශ්‍යය.
SimpleDateFormatඅද දක්වා දී ඇති නූලක් විග්‍රහ කිරීම සඳහා වලංගු රටා පිළිබඳ උදාහරණ කිහිපයක් මෙන්න :
Input string Pattern
------------------------------------ ----------------------------
2001.07.04 AD at 12:08:56 PDT yyyy.MM.dd G 'at' HH:mm:ss z
Wed, Jul 4, '01 EEE, MMM d, ''yy
12:08 PM h:mm a
12 o'clock PM, Pacific Daylight Time hh 'o''clock' a, zzzz
0:08 PM, PDT K:mm a, z
02001.July.04 AD 12:08 PM yyyyy.MMMM.dd GGG hh:mm aaa
Wed, 4 Jul 2001 12:08:56 -0700 EEE, d MMM yyyy HH:mm:ss Z
010704120856-0700 yyMMddHHmmssZ
2001-07-04T12:08:56.235-0700 yyyy-MM-dd'T'HH:mm:ss.SSSZ
2001-07-04T12:08:56.235-07:00 yyyy-MM-dd'T'HH:mm:ss.SSSXXX
2001-W27-3 YYYY-'W'ww-uවැදගත් සටහනක් බව ය SimpleDateFormatඇත නොහැකි ආරක්ෂිත නූල. වෙනත් වචන වලින් කිවහොත්, ඔබ එය කිසි විටෙකත් ස්ථිතික හෝ නිදර්ශන විචල්‍යයක් ලෙස ප්‍රකාශයට පත් කොට විවිධ ක්‍රම / නූල් වලින් නැවත භාවිතා නොකළ යුතුය. දේශීය විෂය පථය තුළ ඔබ සැමවිටම එය අලුත්ම නිර්මාණය කළ යුතුය.
ඔබ ජාවා 8 හෝ ඊට වඩා අළුත් නම්, භාවිතා කරන්න DateTimeFormatter(මෙහි ද, සියලු පෙර සැකසූ ආකෘති සහ පවතින ආකෘති රටා බැලීමට සබැඳිය ක්ලික් කරන්න; නිබන්ධනය මෙහි ඇත ). මෙම නව API එක ජෝඩා ටයිම් විසින් දේවානුභාවයෙන් .
String string = "January 2, 2010";
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MMMM d, yyyy", Locale.ENGLISH);
LocalDate date = LocalDate.parse(string, formatter);
System.out.println(date); // 2010-01-02සටහන: ඔබේ හැඩතල රටාවේ කාල කොටසද අඩංගු වේ නම්, ඒ LocalDateTime#parse(text, formatter)වෙනුවට භාවිතා කරන්න LocalDate#parse(text, formatter). තවද, ඔබේ ආකෘතියේ රටාව කාල කලාපයද අඩංගු වේ නම්, ඒ ZonedDateTime#parse(text, formatter)වෙනුවට භාවිතා කරන්න.
ජාවාඩොක් වෙතින් අදාළ වන සාරය මෙන්න , පවතින සියලුම ආකෘති රටා ලැයිස්තුගත කරන්න:
Symbol Meaning Presentation Examples
------ -------------------------- ------------ ----------------------------------------------
G era text AD; Anno Domini; A
u year year 2004; 04
y year-of-era year 2004; 04
D day-of-year number 189
M/L month-of-year number/text 7; 07; Jul; July; J
d day-of-month number 10
Q/q quarter-of-year number/text 3; 03; Q3; 3rd quarter
Y week-based-year year 1996; 96
w week-of-week-based-year number 27
W week-of-month number 4
E day-of-week text Tue; Tuesday; T
e/c localized day-of-week number/text 2; 02; Tue; Tuesday; T
F week-of-month number 3
a am-pm-of-day text PM
h clock-hour-of-am-pm (1-12) number 12
K hour-of-am-pm (0-11) number 0
k clock-hour-of-am-pm (1-24) number 0
H hour-of-day (0-23) number 0
m minute-of-hour number 30
s second-of-minute number 55
S fraction-of-second fraction 978
A milli-of-day number 1234
n nano-of-second number 987654321
N nano-of-day number 1234000000
V time-zone ID zone-id America/Los_Angeles; Z; -08:30
z time-zone name zone-name Pacific Standard Time; PST
O localized zone-offset offset-O GMT+8; GMT+08:00; UTC-08:00;
X zone-offset 'Z' for zero offset-X Z; -08; -0830; -08:30; -083015; -08:30:15;
x zone-offset offset-x +0000; -08; -0830; -08:30; -083015; -08:30:15;
Z zone-offset offset-Z +0000; -0800; -08:00;එය වඩාත් ජනප්‍රිය රටා සඳහා පූර්ව නිශ්චිත ආකෘති කිහිපයක් ඇති බව සලකන්න . එබැවින් උදා වෙනුවට DateTimeFormatter.ofPattern("EEE, d MMM yyyy HH:mm:ss Z", Locale.ENGLISH);ඔබට භාවිතා කළ හැකිය DateTimeFormatter.RFC_1123_DATE_TIME. මෙය කළ හැකි වන්නේ ඒවා ඊට පටහැනිව SimpleDateFormatනූල් ආරක්ෂිත බැවිනි. අවශ්‍ය නම් ඔබට ඔබේම අර්ථ දැක්විය හැකිය.
විශේෂිත ආදාන නූල් ආකෘතියක් සඳහා, ඔබ පැහැදිලිව භාවිතා කිරීමට අවශ්‍ය නැත : 2016-09-26T17: 44: 57Z වැනි DateTimeFormatterසම්මත ISO 8601 දිනයක්, LocalDateTime#parse(text)එය දැනටමත් ISO_LOCAL_DATE_TIMEආකෘතිය භාවිතා කරන බැවින් කෙලින්ම විග්‍රහ කළ හැකිය . ඒ හා සමානව, LocalDate#parse(text)කාල සංරචකය නොමැතිව ISO දිනයක් විග්‍රහ කරයි (බලන්න ISO_LOCAL_DATE), සහ ZonedDateTime#parse(text)ඕෆ්සෙට් සහ කාල කලාපය එකතු කළ ISO දිනයක් විග්‍රහ කරයි (බලන්න ISO_ZONED_DATE_TIME).
O, එය UTC+08:00වෙනුවට මුද්‍රණය කිරීමට ඉඩ දෙන්නේ කෙසේද GMT+08:00. මට කිසිම උදාහරණයක් ගන්න බැරි වුණා.
20-JUN-16 12.00.00.000000000 AM, මෙය දිනය බවට පරිවර්තනය කිරීමට උදව් අවශ්‍යයි. ඔබගේ උදව් බොහෝ අගය කරනු ලැබේ !!
ඔව්, ජාවා දිනය සාකච්ඡාව, නැවතත්. දිනය හැසිරවීම සමඟ කටයුතු කිරීම සඳහා අපි දිනය , දින දර්ශනය , ග්‍රෙගෝරියන් දින දර්ශනය සහ සරල ඩේට් ෆෝමැට් භාවිතා කරමු . උදාහරණයක් ලෙස ඔබේ ජනවාරි දිනය ආදානය ලෙස භාවිතා කිරීම:
Calendar mydate = new GregorianCalendar();
String mystring = "January 2, 2010";
Date thedate = new SimpleDateFormat("MMMM d, yyyy", Locale.ENGLISH).parse(mystring);
mydate.setTime(thedate);
//breakdown
System.out.println("mydate -> "+mydate);
System.out.println("year -> "+mydate.get(Calendar.YEAR));
System.out.println("month -> "+mydate.get(Calendar.MONTH));
System.out.println("dom -> "+mydate.get(Calendar.DAY_OF_MONTH));
System.out.println("dow -> "+mydate.get(Calendar.DAY_OF_WEEK));
System.out.println("hour -> "+mydate.get(Calendar.HOUR));
System.out.println("minute -> "+mydate.get(Calendar.MINUTE));
System.out.println("second -> "+mydate.get(Calendar.SECOND));
System.out.println("milli -> "+mydate.get(Calendar.MILLISECOND));
System.out.println("ampm -> "+mydate.get(Calendar.AM_PM));
System.out.println("hod -> "+mydate.get(Calendar.HOUR_OF_DAY));එවිට ඔබට එය වැනි දෙයක් සමඟ හැසිරවිය හැකිය:
Calendar now = Calendar.getInstance();
mydate.set(Calendar.YEAR,2009);
mydate.set(Calendar.MONTH,Calendar.FEBRUARY);
mydate.set(Calendar.DAY_OF_MONTH,25);
mydate.set(Calendar.HOUR_OF_DAY,now.get(Calendar.HOUR_OF_DAY));
mydate.set(Calendar.MINUTE,now.get(Calendar.MINUTE));
mydate.set(Calendar.SECOND,now.get(Calendar.SECOND));
// or with one statement
//mydate.set(2009, Calendar.FEBRUARY, 25, now.get(Calendar.HOUR_OF_DAY), now.get(Calendar.MINUTE), now.get(Calendar.SECOND));
System.out.println("mydate -> "+mydate);
System.out.println("year -> "+mydate.get(Calendar.YEAR));
System.out.println("month -> "+mydate.get(Calendar.MONTH));
System.out.println("dom -> "+mydate.get(Calendar.DAY_OF_MONTH));
System.out.println("dow -> "+mydate.get(Calendar.DAY_OF_WEEK));
System.out.println("hour -> "+mydate.get(Calendar.HOUR));
System.out.println("minute -> "+mydate.get(Calendar.MINUTE));
System.out.println("second -> "+mydate.get(Calendar.SECOND));
System.out.println("milli -> "+mydate.get(Calendar.MILLISECOND));
System.out.println("ampm -> "+mydate.get(Calendar.AM_PM));
System.out.println("hod -> "+mydate.get(Calendar.HOUR_OF_DAY));String str_date = "11-June-07";
DateFormat formatter;
Date date;
formatter = new SimpleDateFormat("dd-MMM-yy");
date = formatter.parse(str_date);ජාවා 8 සමඟ අපට නව දිනය / වේලාව API ( JSR 310 ) ලැබේ.
ජෝඩා-වේලාව මත රඳා නොසිට ජාවා 8 හි දිනය විග්‍රහ කිරීමට පහත දැක්වෙන ක්‍රමය භාවිතා කළ හැකිය :
String str = "January 2nd, 2010";// if we 2nd even we have changed in pattern also it is not working please workout with 2nd
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MMMM Q, yyyy", Locale.ENGLISH);
LocalDate date = LocalDate.parse(str, formatter);// access date fields
int year = date.getYear(); // 2010
int day = date.getDayOfMonth(); // 2
Month month = date.getMonth(); // JANUARY
int monthAsInt = month.getValue(); // 1LocalDate යනු දිනයක් නියෝජනය කිරීම සඳහා සම්මත ජාවා 8 පන්තියයි (කාලය නොමැතිව). දිනය සහ වේලාව තොරතුරු අඩංගු අගයන් විග්‍රහ කිරීමට ඔබට අවශ්‍ය නම් ඔබ LocalDateTime භාවිතා කළ යුතුය . කාල කලාප සහිත අගයන් සඳහා ZonedDateTime භාවිතා කරන්න . දෙකම parse()සමාන ක්‍රමයක් සපයයි LocalDate:
LocalDateTime dateWithTime = LocalDateTime.parse(strWithDateAndTime, dateTimeFormatter);
ZonedDateTime zoned = ZonedDateTime.parse(strWithTimeZone, zoneFormatter);DateTimeFormatter Javadoc වෙතින් ලැයිස්තු හැඩතල ගැන්වීම :
All letters 'A' to 'Z' and 'a' to 'z' are reserved as pattern letters.
The following pattern letters are defined:
Symbol Meaning Presentation Examples
------ ------- ------------ -------
G era text AD; Anno Domini; A
u year year 2004; 04
y year-of-era year 2004; 04
D day-of-year number 189
M/L month-of-year number/text 7; 07; Jul; July; J
d day-of-month number 10
Q/q quarter-of-year number/text 3; 03; Q3; 3rd quarter
Y week-based-year year 1996; 96
w week-of-week-based-year number 27
W week-of-month number 4
E day-of-week text Tue; Tuesday; T
e/c localized day-of-week number/text 2; 02; Tue; Tuesday; T
F week-of-month number 3
a am-pm-of-day text PM
h clock-hour-of-am-pm (1-12) number 12
K hour-of-am-pm (0-11) number 0
k clock-hour-of-am-pm (1-24) number 0
H hour-of-day (0-23) number 0
m minute-of-hour number 30
s second-of-minute number 55
S fraction-of-second fraction 978
A milli-of-day number 1234
n nano-of-second number 987654321
N nano-of-day number 1234000000
V time-zone ID zone-id America/Los_Angeles; Z; -08:30
z time-zone name zone-name Pacific Standard Time; PST
O localized zone-offset offset-O GMT+8; GMT+08:00; UTC-08:00;
X zone-offset 'Z' for zero offset-X Z; -08; -0830; -08:30; -083015; -08:30:15;
x zone-offset offset-x +0000; -08; -0830; -08:30; -083015; -08:30:15;
Z zone-offset offset-Z +0000; -0800; -08:00;සමහර පිළිතුරු තාක්ෂණික වශයෙන් නිවැරදි වුවත් ඒවා සුදුසු නොවේ.
ජෝඩා-ටයිම් පිළිබඳ සටහන් කිහිපයක් අනුගමනය කරයි.
දී Joda කාලීන , එය දිනයවේලාව වස්තුව සැබවින්ම එහි ම ෙමම කාල කලාපය දන්නවා. මෙම වන java.util.Date පන්ති වෙනස් ලෙසකින් පෙනෙන්නට කාල කලාපය ඇති වෙන්නේ නැහැ.
පහත දැක්වෙන උදාහරණ කේතයේ සටහන් කරන්න, අපි කාල කලාප වස්තුවක් නූල් විග්‍රහ කරන ආකෘතියට යවන ආකාරය. එම කාල කලාපය එම කාල කලාපය තුළ සිදුවූවක් ලෙස අර්ථ දැක්වීමට භාවිතා කරයි. එබැවින් ඔබ එම සංගීත ආදානයෙන් නිරූපණය වන කාල කලාපය ගැන සිතා බලා තීරණය කළ යුතුය.
ඔබගේ ආදාන නූලෙහි ඔබට කාල කොටසක් නොමැති බැවින්, ජෝඩා-ටයිම් නිශ්චිත කාල කලාපයේ දවසේ පළමු මොහොත දවසේ වේලාව ලෙස පවරයි. සාමාන්‍යයෙන් මෙය අදහස් කරන්නේ 00:00:00නමුත් සැමවිටම නොවේ, දිවා ආලෝකය ඉතිරි කිරීමේ කාලය (DST) හෝ වෙනත් විෂමතා නිසා. මාර්ගය වන විට, ඇමතීමෙන් ඔබට ඕනෑම ඩේට් ටයිම් අවස්ථාවකට එය කළ withTimeAtStartOfDayහැකිය.
ආකෘති රටාවක භාවිතා වන අක්ෂර ජෝඩා-ටයිම් හි java.util.Date/Calendar හි ඇති ඒවාට සමාන නමුත් හරියටම සමාන නොවේ. ලේඛනය ප්‍රවේශමෙන් කියවන්න.
අපි සාමාන්‍යයෙන් ජෝඩා-ටයිම් හි වෙනස් කළ නොහැකි පන්ති භාවිතා කරමු. පවත්නා දින-කාල වස්තුවක් වෙනස් කරනවා වෙනුවට, වෙනස් කිරීම් අපේක්‍ෂා කළ ස්ථාන හැර අනෙක් බොහෝ අංග පිටපත් කර අනෙක් වස්තුව මත පදනම්ව නව නැවුම් අවස්ථාවක් නිර්මාණය කරන ක්‍රම අපි හඳුන්වමු. උදාහරණයක් ලෙස withZoneපහත දැක්වෙන අන්තිම පේළියට ඇමතුම . නිශ්චලතාව ජෝඩා -වේලාව ඉතා නූල්-ආරක්ෂිත කිරීමට උපකාරී වන අතර සමහර වැඩ වඩාත් පැහැදිලි කර ගත හැකිය.
ජෝඩා-ටයිම් වස්තූන් ගැන නොදන්නා වෙනත් පංති / රාමුවක් සමඟ භාවිතා කිරීම සඳහා ඔබට java.util.Date වස්තු අවශ්‍ය වේ. වාසනාවකට මෙන්, ඉදිරියට හා පසුපසට ගමන් කිරීම ඉතා පහසුය.
Java.util.Date වස්තුවක සිට (මෙහි නම් කර ඇත date) ජෝඩා-ටයිම් ඩේට් ටයිම් වෙත…
org.joda.time.DateTime dateTime = new DateTime( date, timeZone );ජෝඩා-ටයිම් සිට java.util.Date වස්තුවකට අනෙක් දිශාවට යාම…
java.util.Date date = dateTime.toDate();String input = "January 2, 2010";
java.util.Locale locale = java.util.Locale.US;
DateTimeZone timeZone = DateTimeZone.forID( "Pacific/Honolulu" ); // Arbitrarily chosen for example.
DateTimeFormatter formatter = DateTimeFormat.forPattern( "MMMM d, yyyy" ).withZone( timeZone ).withLocale( locale );
DateTime dateTime = formatter.parseDateTime( input );
System.out.println( "dateTime: " + dateTime );
System.out.println( "dateTime in UTC/GMT: " + dateTime.withZone( DateTimeZone.UTC ) );ධාවනය වන විට…
dateTime: 2010-01-02T00:00:00.000-10:00
dateTime in UTC/GMT: 2010-01-02T10:00:00.000Zසිම්පල් ඩේට් ෆෝමැට් පන්තිය සමඟ ගනුදෙනු කරන අතරතුර, දිනය නූල්-ආරක්ෂිත නොවන බව මතක තබා ගැනීම වැදගත් වන අතර ඔබට එක් දින වස්තුවක් බහු නූල් සමඟ බෙදා ගත නොහැක.
"M" සහ "M" අතර විශාල වෙනසක් ඇත, එහිදී කුඩා නඩුව මිනිත්තු සඳහා භාවිතා වන අතර ප්‍රාග්ධන නඩුව මාසයක් සඳහා භාවිතා වේ. "D" සහ "D" සමඟ සමාන වේ. මෙය බොහෝ විට නොසලකා හරින සියුම් දෝෂ ඇති කළ හැකිය. වැඩි විස්තර සඳහා ජාවාඩොක් හෝ ජාවා හි නූල් දිනය බවට පරිවර්තනය කිරීමට මාර්ගෝපදේශය බලන්න .
DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
Date date;
try {
date = dateFormat.parse("2013-12-4");
System.out.println(date.toString()); // Wed Dec 04 00:00:00 CST 2013
String output = dateFormat.format(date);
System.out.println(output); // 2013-12-04
}
catch (ParseException e) {
e.printStackTrace();
}එය මට හොඳින් ක්‍රියාත්මක වේ.
අද දක්වා නූල් වෙනස් කිරීම සඳහා ඔබට SimpleDateformat භාවිතා කළ හැකිය
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
String strDate = "2000-01-01";
Date date = new Date(sdf.parse(strDate).getTime());එසේම, SimpleDateFormat නොව සේවාදායකයා-පැත්තේ තාක්ෂණය සමඟ ලබා ගත හැකි, වගේ GWT .
Calendar.getInstance () සඳහා යාම හොඳ අදහසකි, ඔබේ අවශ්‍යතාවය දින දෙකක් සංසන්දනය කිරීමයි; දිගු දිනක් යන්න.
අප භාවිතා කර ඇති සරල ආකෘති දෙකක්:
අපි සම්පූර්ණ දිනය සිට කාල ආකෘතිය දක්වා විග්‍රහ කරමු:
date="2016-05-06 16:40:32";
public static String setDateParsing(String date) throws ParseException {
// This is the format date we want
DateFormat mSDF = new SimpleDateFormat("hh:mm a");
// This format date is actually present
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-mm-dd hh:mm");
return mSDF.format(formatter.parse(date));
}මගේ නිහතමානී පරීක්ෂණ වැඩසටහන. ලොග්-ලිපිගොනු වල මා සොයා ගන්නා ආකෘති පත්‍රය හා දිගු දිනයන් බැලීමට මම එය භාවිතා කරමි (නමුත් ඒවා එහි තබා ඇත්තේ කවුද ...).
මගේ පරීක්ෂණ වැඩසටහන:
package be.test.package.time;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.TimeZone;
public class TimeWork {
public static void main(String[] args) {
TimeZone timezone = TimeZone.getTimeZone("UTC");
List<Long> longs = new ArrayList<>();
List<String> strings = new ArrayList<>();
//Formatting a date needs a timezone - otherwise the date get formatted to your system time zone.
//Use 24h format HH. In 12h format hh can be in range 0-11, which makes 12 overflow to 0.
DateFormat formatter = new SimpleDateFormat("dd-MM-yyyy HH:mm:ss.SSS");
formatter.setTimeZone(timezone);
Date now = new Date();
//Test dates
strings.add(formatter.format(now));
strings.add("01-01-1970 00:00:00.000");
strings.add("01-01-1970 00:00:01.000");
strings.add("01-01-1970 00:01:00.000");
strings.add("01-01-1970 01:00:00.000");
strings.add("01-01-1970 10:00:00.000");
strings.add("01-01-1970 12:00:00.000");
strings.add("01-01-1970 24:00:00.000");
strings.add("02-01-1970 00:00:00.000");
strings.add("01-01-1971 00:00:00.000");
strings.add("01-01-2014 00:00:00.000");
strings.add("31-12-1969 23:59:59.000");
strings.add("31-12-1969 23:59:00.000");
strings.add("31-12-1969 23:00:00.000");
//Test data
longs.add(now.getTime());
longs.add(-1L);
longs.add(0L); //Long date presentation at - midnight 1/1/1970 UTC - The timezone is important!
longs.add(1L);
longs.add(1000L);
longs.add(60000L);
longs.add(3600000L);
longs.add(36000000L);
longs.add(43200000L);
longs.add(86400000L);
longs.add(31536000000L);
longs.add(1388534400000L);
longs.add(7260000L);
longs.add(1417706084037L);
longs.add(-7260000L);
System.out.println("===== String to long =====");
//Show the long value of the date
for (String string: strings) {
try {
Date date = formatter.parse(string);
System.out.println("Formated date : " + string + " = Long = " + date.getTime());
} catch (ParseException e) {
e.printStackTrace();
}
}
System.out.println("===== Long to String =====");
//Show the date behind the long
for (Long lo : longs) {
Date date = new Date(lo);
String string = formatter.format(date);
System.out.println("Formated date : " + string + " = Long = " + lo);
}
}
}පරීක්ෂණ ප්‍රති results ල:
===== String to long =====
Formated date : 05-12-2014 10:17:34.873 = Long = 1417774654873
Formated date : 01-01-1970 00:00:00.000 = Long = 0
Formated date : 01-01-1970 00:00:01.000 = Long = 1000
Formated date : 01-01-1970 00:01:00.000 = Long = 60000
Formated date : 01-01-1970 01:00:00.000 = Long = 3600000
Formated date : 01-01-1970 10:00:00.000 = Long = 36000000
Formated date : 01-01-1970 12:00:00.000 = Long = 43200000
Formated date : 01-01-1970 24:00:00.000 = Long = 86400000
Formated date : 02-01-1970 00:00:00.000 = Long = 86400000
Formated date : 01-01-1971 00:00:00.000 = Long = 31536000000
Formated date : 01-01-2014 00:00:00.000 = Long = 1388534400000
Formated date : 31-12-1969 23:59:59.000 = Long = -1000
Formated date : 31-12-1969 23:59:00.000 = Long = -60000
Formated date : 31-12-1969 23:00:00.000 = Long = -3600000
===== Long to String =====
Formated date : 05-12-2014 10:17:34.873 = Long = 1417774654873
Formated date : 31-12-1969 23:59:59.999 = Long = -1
Formated date : 01-01-1970 00:00:00.000 = Long = 0
Formated date : 01-01-1970 00:00:00.001 = Long = 1
Formated date : 01-01-1970 00:00:01.000 = Long = 1000
Formated date : 01-01-1970 00:01:00.000 = Long = 60000
Formated date : 01-01-1970 01:00:00.000 = Long = 3600000
Formated date : 01-01-1970 10:00:00.000 = Long = 36000000
Formated date : 01-01-1970 12:00:00.000 = Long = 43200000
Formated date : 02-01-1970 00:00:00.000 = Long = 86400000
Formated date : 01-01-1971 00:00:00.000 = Long = 31536000000
Formated date : 01-01-2014 00:00:00.000 = Long = 1388534400000
Formated date : 01-01-1970 02:01:00.000 = Long = 7260000
Formated date : 04-12-2014 15:14:44.037 = Long = 1417706084037
Formated date : 31-12-1969 21:59:00.000 = Long = -7260000මූලාශ්‍ර සබැඳිය
සඳහා ඇන්ඩ්රොයිඩ්
Calendar.getInstance (). GetTime () ලබා දෙයි
Thu Jul 26 15:54:13 GMT+05:30 2018භාවිත
String oldDate = "Thu Jul 26 15:54:13 GMT+05:30 2018";
DateFormat format = new SimpleDateFormat("EEE LLL dd HH:mm:ss Z yyyy");
Date updateLast = format.parse(oldDate);නූල් සිට දිනය දක්වා පරිවර්තනය:
private Date StringtoDate(String date) throws Exception {
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
java.sql.Date sqlDate = null;
if( !date.isEmpty()) {
try {
java.util.Date normalDate = sdf1.parse(date);
sqlDate = new java.sql.Date(normalDate.getTime());
} catch (ParseException e) {
throw new Exception("Not able to Parse the date", e);
}
}
return sqlDate;
}DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
Date date1 = null;
Date date2 = null;
try {
date1 = dateFormat.parse(t1);
date2 = dateFormat.parse(t2);
} catch (ParseException e) {
e.printStackTrace();
}
DateFormat formatter = new SimpleDateFormat("dd-MMM-yyyy");
String StDate = formatter.format(date1);
String edDate = formatter.format(date2);
System.out.println("ST "+ StDate);
System.out.println("ED "+ edDate);SimpleDateFormatපංතිය සහ මිතුරන් භාවිතා කරමින් යල්පැනගිය සහ වැරදි උපදෙස් කිහිපයක් දැනටමත් ඔබ පුනරුච්චාරණය කරන්නේ නැද්ද? මම ඔබට පාවිච්චි කරන්න එපා නිර්දේශ SimpleDateFormat, DateFormatහා Date. ඒ වෙනුවට භාවිතා LocalDateTimeසහ DateTimeFormatterදෙදෙනාම, , java.time නූතන ජාවා දිනය හා වේලාව API .
මේක උත්සාහ කරන්න
String date = get_pump_data.getString("bond_end_date");
DateFormat format = new SimpleDateFormat("yyyy-MM-dd", Locale.ENGLISH);
Date datee = (Date)format.parse(date);