ඇන්ඩ්‍රොයිඩ් යෙදුමක වත්මන් වේලාව සහ දිනය ලබා ගන්නේ කෙසේද?

ඔබට භාවිතා කළ හැකිය:

import java.util.Calendar

Date currentTime = Calendar.getInstance().getTime();

ඔබට අවශ්‍ය සියල්ල සඳහා දින දර්ශනයේ නියතයන් ඕනෑ තරම් තිබේ.

සංස්කරණය කරන්න: දින දර්ශන පන්ති ලේඛන
පරීක්ෂා කරන්න

ඔබට ( නමුත් තවදුරටත් නොකළ යුතුය - පහත බලන්න!) Android.text.format.Time භාවිතා කළ හැකිය .

Time now = new Time();
now.setToNow();

ඉහත සබැඳියෙන්:

කාල පංතිය යනු java.util.Calendar සහ java.util.GregorianCalendar පන්ති සඳහා වේගවත් ආදේශනයකි. කාල පංතියේ නිදසුනක් දෙවන නිරවද්‍යතාවයෙන් නිශ්චිතව දක්වා ඇති මොහොතක් නිරූපණය කරයි.

සටහන 1: මම මෙම පිළිතුර ලියා වසර කිහිපයක් ගත වී ඇති අතර, එය පැරණි, ඇන්ඩ්‍රොයිඩ් විශේෂිත සහ දැන් අතහැර දැමූ පන්තියක් ගැන ය. ගූගල් දැන් පවසන්නේ "ඔහුගේ පන්තියට ගැටළු ගණනාවක් ඇති අතර ඒ වෙනුවට ග්‍රෙගෝරියන් කැලැන්ඩරය භාවිතා කිරීම රෙකමදාරු කරනු ලැබේ ".

සටහන 2:Time පන්තියට toMillis(ignoreDaylightSavings)ක්‍රමවේදයක් තිබුණද , මෙය හුදෙක් මිලි තත්පර වලින් කාලය අපේක්ෂා කරන ක්‍රම වෙත යොමු වීමේ පහසුවකි. කාල අගය හරියටම තත්පරයකට පමණි ; මිලි තත්පර කොටස සැමවිටම 000වේ. පුඩුවක් තුළ ඔබ කරන්නේ නම්

Time time = new Time();   time.setToNow();
Log.d("TIME TEST", Long.toString(time.toMillis(false)));
... do something that takes more than one millisecond, but less than one second ...

එහි ප්‍රති sequ ලය වන අනුක්‍රමය 1410543204000ඊළඟ තත්පර ආරම්භ වන තෙක් එකම අගය 1410543205000පුනරාවර්තනය වේ.

නිශ්චිත රටාවකින් දිනය හා වේලාව ලබා ගැනීමට ඔබට අවශ්‍ය නම් ඔබට පහත සඳහන් දෑ භාවිතා කළ හැකිය:

SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd_HHmmss", Locale.getDefault());
String currentDateandTime = sdf.format(new Date());

හෝ,

දිනය :

String currentDate = new SimpleDateFormat("dd-MM-yyyy", Locale.getDefault()).format(new Date());

කාලය:

String currentTime = new SimpleDateFormat("HH:mm:ss", Locale.getDefault()).format(new Date());

අභිරුචි කළ ආකෘතියකට වැඩි කැමැත්තක් දක්වන අයට, ඔබට මෙය භාවිතා කළ හැකිය:

DateFormat df = new SimpleDateFormat("EEE, d MMM yyyy, HH:mm");
String date = df.format(Calendar.getInstance().getTime());

ඔබට ඩේට් ෆෝමැට් රටා තිබිය හැකි අතර:

"yyyy.MM.dd G 'at' HH:mm:ss z" ---- 2001.07.04 AD at 12:08:56 PDT
"hh 'o''clock' a, zzzz" ----------- 12 o'clock PM, Pacific Daylight Time
"EEE, d MMM yyyy HH:mm:ss Z"------- Wed, 4 Jul 2001 12:08:56 -0700
"yyyy-MM-dd'T'HH:mm:ss.SSSZ"------- 2001-07-04T12:08:56.235-0700
"yyMMddHHmmssZ"-------------------- 010704120856-0700
"K:mm a, z" ----------------------- 0:08 PM, PDT
"h:mm a" -------------------------- 12:08 PM
"EEE, MMM d, ''yy" ---------------- Wed, Jul 4, '01

ඇත්ත වශයෙන්ම, උපාංගයේ වත්මන් කාල කලාපය සැකසීම වඩා ආරක්ෂිතයි Time.getCurrentTimezone(), නැතිනම් ඔබට UTC හි වත්මන් කාලය ලැබෙනු ඇත.

Time today = new Time(Time.getCurrentTimezone());
today.setToNow();

එවිට, ඔබට අවශ්‍ය සියලුම දින ක්ෂේත්‍ර ලබා ගත හැකිය, උදාහරණයක් ලෙස:

textViewDay.setText(today.monthDay + "");             // Day of the month (1-31)
textViewMonth.setText(today.month + "");              // Month (0-11)
textViewYear.setText(today.year + "");                // Year 
textViewTime.setText(today.format("%k:%M:%S"));  // Current time

සියලු විස්තර සඳහා android.text.format.Time පන්තිය බලන්න .

යාවත්කාලීන කරන්න

බොහෝ අය පෙන්වා දෙන පරිදි, ගූගල් පවසන්නේ මෙම පන්තියට ගැටළු ගණනාවක් ඇති අතර එය තවදුරටත් භාවිතා නොකළ යුතු බවයි:

මෙම පන්තියට ගැටළු ගණනාවක් ඇති අතර ඒ වෙනුවට ග්‍රෙගෝරියන් දින දර්ශනය භාවිතා කිරීම රෙකමදාරු කරනු ලැබේ.

දන්නා ගැටළු:

Time තිහාසික හේතූන් මත කාල ගණනය කිරීම් සිදු කරන විට සියලු ගණිතය දැනට සිදුවන්නේ බිට් 32 පූර්ණ සංඛ්‍යා භාවිතා කරමිනි. මෙය 1902 සිට 2037 දක්වා නිරූපණය කළ හැකි විශ්වාසදායක කාල පරාසය සීමා කරයි. විස්තර සඳහා 2038 වර්ෂය පිළිබඳ විකිපීඩියා ලිපිය බලන්න. මෙම හැසිරීම මත රඳා නොසිටින්න; එය අනාගතයේදී වෙනස් විය හැකිය. ඩීඑස්ටී සංක්‍රාන්තියක් හේතුවෙන් මඟ හැරුණු බිත්ති කාලය වැනි නොපවතින දිනයක ස්විච් ටයිමසෝන් (නූල්) ඇමතීමෙන් 1969 දී දිනයක් ලැබෙනු ඇත (එනම් -1, හෝ 1970 ජනවාරි 1 දිනට පෙර තත්පර 1). බොහෝ හැඩතල ගැන්වීම් / විග්‍රහයන් ASCII පෙළ උපකල්පනය කරන අතර ඒ නිසා ASCII නොවන ස්ක්‍රිප්ට් සමඟ භාවිතා කිරීමට සුදුසු නොවේ.

වත්මන් දිනය සහ වේලාව සඳහා, භාවිතා කරන්න:

String mydate = java.text.DateFormat.getDateTimeInstance().format(Calendar.getInstance().getTime());

කුමන ප්‍රතිදානයන්:

Feb 27, 2012 5:41:23 PM

මේ ආකාරයෙන් උත්සාහ කරන්න දිනය සහ වේලාව ලබා ගැනීම සඳහා සියලු ආකෘතීන් පහත දක්වා ඇත.

    Calendar c = Calendar.getInstance();
    SimpleDateFormat dateformat = new SimpleDateFormat("dd-MMM-yyyy hh:mm:ss aa");
    String datetime = dateformat.format(c.getTime());
    System.out.println(datetime);

tl; dr

Instant.now()  // Current moment in UTC.

…හෝ…

ZonedDateTime.now( ZoneId.of( "America/Montreal" ) )  // In a particular time zone

විස්තර

අනෙක් පිළිතුරු නිවැරදි වුවත් යල් පැන ගිය ඒවා ය. පැරණි දින-කාලීන පංති දුර්වල ලෙස සැලසුම් කර ඇති, ව්‍යාකූල සහ කරදරකාරී බව ඔප්පු වී ඇත.

java.time

එම පැරණි පංති java.time රාමුව මගින් ප්‍රතිස්ථාපනය කර ඇත .

• ජාවා 8 සහ ඊට පසු: java.time රාමුව ගොඩනගා ඇත.
• ජාවා 7 සහ 6: java.time හි පසුපෙළ භාවිතා කරන්න .
• ඇන්ඩ්‍රොයිඩ්: එම පසුපෙළේ ඔතා ඇති අනුවාදය භාවිතා කරන්න .

මෙම නව පංති ජේඑස්ආර් 310 විසින් නිර්වචනය කරන ලද සහ ඉතා සාර්ථක ජෝඩා-ටයිම් ව්‍යාපෘතියෙන් ආනුභාව ලත් අතර එය ත්‍රි ටෙන්-එක්ස්ට්‍රා ව්‍යාපෘතිය මගින් ව්‍යාප්ත කර ඇත .

ඔරකල් නිබන්ධනය බලන්න .

Instant

ක Instantදී කාල සටහනකට මත මොහොතක් UTC යෝජනාව දක්වා සමග නැනෝ තත්පර .

 Instant instant = Instant.now(); // Current moment in UTC.

වේලා කලාපය

ZoneIdලබා ගැනීම සඳහා කාල කලාපයක් ( ) යොදන්න ZonedDateTime. ඔබ කාල කලාපය මඟ හැරියහොත් ඔබගේ ජේවීඑම් හි වර්තමාන පෙරනිමි කාල කලාපය ව්‍යංගයෙන් අදාළ වේ. අපේක්ෂිත / අපේක්ෂිත කාල කලාපය පැහැදිලිව සඳහන් කිරීම වඩා හොඳය.

, හෝ , වැනි ආකෘතියේ නිසි කාල කලාප නම් භාවිතා කරන්න . ප්‍රමිතිගත හෝ අද්විතීය නොවන හෝ 3-4 අකුරු කෙටියෙන් භාවිතා නොකරන්න .continent/regionAmerica/MontrealEurope/BrusselsAsia/KolkataESTIST

ZoneId zoneId = ZoneId.of( "America/Montreal" ); // Or "Asia/Kolkata", "Europe/Paris", and so on.
ZonedDateTime zdt = ZonedDateTime.ofInstant( instant , zoneId );

නූල් ජනනය කිරීම

Stringදිනය-කාල අගයෙහි පෙළ නිරූපණයක් ලෙස ඔබට පහසුවෙන් උත්පාදනය කළ හැකිය . ඔබට සම්මත ආකෘතියක්, ඔබේම අභිරුචි ආකෘතියක් හෝ ස්වයංක්‍රීයව දේශීයකරණය කළ ආකෘතියක් සමඟ යා හැකිය.

ISO 8601

toStringපොදු සහ සංවේදී ISO 8601 ප්‍රමිතිය භාවිතයෙන් පෙළ හැඩතල ගැන්වීමේ ක්‍රම ඔබට ඇමතිය හැකිය .

String output = instant.toString();

2016-03-23T03: 09: 01.613Z

මේ සඳහා ZonedDateTime, toStringකාල කලාපයේ නම වර්ග වරහන් වල ඇතුළත් කිරීමෙන් ක්‍රමය ISO 8601 ප්‍රමිතිය පුළුල් කරයි. අතිශයින්ම ප්‍රයෝජනවත් හා වැදගත් තොරතුරු, නමුත් සම්මත නොවේ.

2016-03-22T20: 09: 01.613-08: 00 [ඇමරිකාව / ලොස්_ ඇන්ජලීස්]

අභිරුචි ආකෘතිය

නැතහොත් DateTimeFormatterපන්තිය සමඟ ඔබේම විශේෂිත හැඩතල ගැන්වීමේ රටාව සඳහන් කරන්න .

DateTimeFormatter formatter = DateTimeFormatter.ofPattern( "dd/MM/yyyy hh:mm a" );

නියම කල Localeමානව භාෂාව (ඉංග්රීසි, සඳහා ප්රංශ දින / මාසය ද එවැනි වර්ෂය සහ මාසය සහ දිනය අනුපිළිවෙල ලෙස සංස්කෘතික නියාමයන් නිර්වචනය නම පරිවර්තනය භාවිතා කිරීමට, ආදිය). Localeකාල කලාපයට කිසිදු සම්බන්ධයක් නැති බව සලකන්න .

formatter = formatter.withLocale( Locale.US ); // Or Locale.CANADA_FRENCH or such.
String output = zdt.format( formatter );

දේශීයකරණය

වඩා හොඳ, java.time ස්වයංක්‍රීයව දේශීයකරණය කිරීමේ කාර්යය කිරීමට ඉඩ දෙන්න.

DateTimeFormatter formatter = DateTimeFormatter.ofLocalizedDateTime( FormatStyle.MEDIUM );
String output = zdt.format( formatter.withLocale( Locale.US ) );  // Or Locale.CANADA_FRENCH and so on.

Java.time ගැන

මෙම java.time රාමුව ජාවා 8 බවට ඉදි කර, පසුව වේ. මෙම පංති , සහ , වැනි කරදරකාරී පැරණි උරුම දිනය-කාලීන පන්ති ආදේශ කරයි .java.util.DateCalendarSimpleDateFormat

මෙම Joda කාලීන දැන් ව්යාපෘතිය, නඩත්තු ආකාරයෙන් , එම රටවලට සංක්රමණය උපදෙස් java.time පන්ති.

වැඩි විස්තර දැනගැනීම සඳහා ඔරකල් නිබන්ධනය බලන්න . බොහෝ උදාහරණ සහ පැහැදිලි කිරීම් සඳහා Stack Overflow සොයන්න. පිරිවිතර JSR 310 වේ.

ඔබට ඔබේ දත්ත සමුදාය සමඟ java.time වස්තු කෙලින්ම හුවමාරු කර ගත හැකිය . එය භාවිතා කරන්න JDBC රියදුරු හා අනුකූල JDBC 4.2 හෝ ඊට පසු. නූල් අවශ්‍ය නැත, අවශ්‍ය නොවේjava.sql.* පන්ති .

Java.time පන්ති ලබා ගන්නේ කොහෙන්ද?

• ජාවා එස්ඊ 8 , ජාවා එස්ඊ 9 , ජාවා එස්ඊ 10 සහ පසුව
  • සාදන ලද.
  • එකතු කරන ලද සම්මත ජාවා API හි කොටසක්.
  • ජාවා 9 සුළු විශේෂාංග සහ නිවැරදි කිරීම් එකතු කරයි.
• ජාවා එස්ඊ 6 සහ ජාවා එස්ඊ 7
  • ජාවා.ටයිම් ක්‍රියාකාරිත්වයේ වැඩි කොටසක් ත්‍රි ටෙන්-බැක්පෝට් හි ජාවා 6 සහ 7 වෙත ආපසු ගෙන යනු ලැබේ .
• Android
  • Java.time පන්ති වල ඇන්ඩ්‍රොයිඩ් මිටි ක්‍රියාත්මක කිරීමේ පසු සංස්කරණ.
  • පෙර ඇන්ඩ්‍රොයිඩ් සඳහා (<26), ත්රීටෙන්ඒබීපී ව්යාපෘතිය ත්රිටෙන්-බැක්පෝට් (ඉහත සඳහන් කළ) අනුවර්තනය කරයි . ThreeTenABP භාවිතා කරන්නේ කෙසේදැයි බලන්න … .

System.currentTimeMillis()ජාවා හි සම්මත වන වර්තමාන කාලය භාවිතා කිරීමට . එවිට ඔබට දිනයක් නිර්මාණය කිරීමට එය භාවිතා කළ හැකිය

Date currentDate = new Date(System.currentTimeMillis());

කාලය නිර්මාණය කිරීම සඳහා අන් අය සඳහන් කළ පරිදි

Time currentTime = new Time();
currentTime.setToNow();

ඔබට කේතය භාවිතා කළ හැකිය:

Calendar c = Calendar.getInstance();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String strDate = sdf.format(c.getTime());

ප්‍රතිදානය:

2014-11-11 00:47:55

ඔබට තවත් ආකෘතිකරණ විකල්ප SimpleDateFormatකිහිපයක් මෙතැනින් ලැබේ.

පහසුය, වත්මන් කාලය සඳහා වෙනම අගයන් ලබා ගැනීමට ඔබට කාලය වෙන් කළ හැකිය, පහත පරිදි:

Calendar cal = Calendar.getInstance(); 

  int millisecond = cal.get(Calendar.MILLISECOND);
  int second = cal.get(Calendar.SECOND);
  int minute = cal.get(Calendar.MINUTE);
        //12 hour format
  int hour = cal.get(Calendar.HOUR);
        //24 hour format
  int hourofday = cal.get(Calendar.HOUR_OF_DAY);

දිනය සඳහා පහත පරිදි වේ:

Calendar cal = Calendar.getInstance(); 

  int dayofyear = cal.get(Calendar.DAY_OF_YEAR);
  int year = cal.get(Calendar.YEAR);
  int dayofweek = cal.get(Calendar.DAY_OF_WEEK);
  int dayofmonth = cal.get(Calendar.DAY_OF_MONTH);

ඇන්ඩ්‍රොයිඩ් ප්‍රධාන වශයෙන් ජාවා බැවින් විකල්ප කිහිපයක් තිබේ, නමුත් ඔබට එය පෙළ දර්ශනයකින් ලිවීමට අවශ්‍ය නම්, පහත කේතය මඟින් උපක්‍රමය කරනු ඇත:

String currentDateTimeString = DateFormat.getDateInstance().format(new Date());

// textView is the TextView view that should display it
textView.setText(currentDateTimeString);

SimpleDateFormat databaseDateTimeFormate = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
SimpleDateFormat databaseDateFormate = new SimpleDateFormat("yyyy-MM-dd");
SimpleDateFormat sdf1 = new SimpleDateFormat("dd.MM.yy");
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy.MM.dd G 'at' hh:mm:ss z");
SimpleDateFormat sdf3 = new SimpleDateFormat("EEE, MMM d, ''yy");
SimpleDateFormat sdf4 = new SimpleDateFormat("h:mm a");
SimpleDateFormat sdf5 = new SimpleDateFormat("h:mm");
SimpleDateFormat sdf6 = new SimpleDateFormat("H:mm:ss:SSS");
SimpleDateFormat sdf7 = new SimpleDateFormat("K:mm a,z");
SimpleDateFormat sdf8 = new SimpleDateFormat("yyyy.MMMMM.dd GGG hh:mm aaa");


String currentDateandTime = databaseDateTimeFormate.format(new Date());     //2009-06-30 08:29:36
String currentDateandTime = databaseDateFormate.format(new Date());     //2009-06-30
String currentDateandTime = sdf1.format(new Date());     //30.06.09
String currentDateandTime = sdf2.format(new Date());     //2009.06.30 AD at 08:29:36 PDT
String currentDateandTime = sdf3.format(new Date());     //Tue, Jun 30, '09
String currentDateandTime = sdf4.format(new Date());     //8:29 PM
String currentDateandTime = sdf5.format(new Date());     //8:29
String currentDateandTime = sdf6.format(new Date());     //8:28:36:249
String currentDateandTime = sdf7.format(new Date());     //8:29 AM,PDT
String currentDateandTime = sdf8.format(new Date());     //2009.June.30 AD 08:29 AM

දිනය ආකෘතිය රටා

G   Era designator (before christ, after christ)
y   Year (e.g. 12 or 2012). Use either yy or yyyy.
M   Month in year. Number of M's determine length of format (e.g. MM, MMM or MMMMM)
d   Day in month. Number of d's determine length of format (e.g. d or dd)
h   Hour of day, 1-12 (AM / PM) (normally hh)
H   Hour of day, 0-23 (normally HH)
m   Minute in hour, 0-59 (normally mm)
s   Second in minute, 0-59 (normally ss)
S   Millisecond in second, 0-999 (normally SSS)
E   Day in week (e.g Monday, Tuesday etc.)
D   Day in year (1-366)
F   Day of week in month (e.g. 1st Thursday of December)
w   Week in year (1-53)
W   Week in month (0-5)
a   AM / PM marker
k   Hour in day (1-24, unlike HH's 0-23)
K   Hour in day, AM / PM (0-11)
z   Time Zone

final Calendar c = Calendar.getInstance();
    int mYear = c.get(Calendar.YEAR);
    int mMonth = c.get(Calendar.MONTH);
    int mDay = c.get(Calendar.DAY_OF_MONTH);

textView.setText(""+mDay+"-"+mMonth+"-"+mYear);

දිනය හා වේලාව ලබා ගැනීමට මෙය ප්‍රයෝජනවත් වන ක්‍රමයකි:

private String getDate(){
    DateFormat dfDate = new SimpleDateFormat("yyyy/MM/dd");
    String date=dfDate.format(Calendar.getInstance().getTime());
    DateFormat dfTime = new SimpleDateFormat("HH:mm");
    String time = dfTime.format(Calendar.getInstance().getTime());
    return date + " " + time;
}

ඔබට මෙම ක්‍රමය අමතා වත්මන් දිනය හා වේලාවන් ලබා ගත හැකිය:

2017/01//09 19:23

ආකෘතිය සහිත වත්මන් දිනය සහ වේලාව සඳහා, භාවිතා කරන්න

ජාවා වල

Calendar c = Calendar.getInstance();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String strDate = sdf.format(c.getTime());
Log.d("Date","DATE : " + strDate)

කොට්ලින් වල

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
    val current = LocalDateTime.now()
    val formatter = DateTimeFormatter.ofPattern("dd.MM.yyyy. HH:mm:ss")
    var myDate: String =  current.format(formatter)
    Log.d("Date","DATE : " + myDate)
} else {
    var date = Date()
    val formatter = SimpleDateFormat("MMM dd yyyy HH:mma")
    val myDate: String = formatter.format(date)
    Log.d("Date","DATE : " + myDate)
}

දිනය ආකෘති රටා

"yyyy.MM.dd G 'at' HH:mm:ss z" ---- 2001.07.04 AD at 12:08:56 PDT
"hh 'o''clock' a, zzzz" ----------- 12 o'clock PM, Pacific Daylight Time
"EEE, d MMM yyyy HH:mm:ss Z"------- Wed, 4 Jul 2001 12:08:56 -0700
"yyyy-MM-dd'T'HH:mm:ss.SSSZ"------- 2001-07-04T12:08:56.235-0700
"yyMMddHHmmssZ"-------------------- 010704120856-0700
"K:mm a, z" ----------------------- 0:08 PM, PDT
"h:mm a" -------------------------- 12:08 PM
"EEE, MMM d, ''yy" ---------------- Wed, Jul 4, '01

Time time = new Time();
time.setToNow();
System.out.println("time: " + time.hour+":"+time.minute);

මෙය ඔබට ලබා දෙනු ඇත, උදාහරණයක් ලෙස, 12:32.

Android.text.format.Time ආනයනය කිරීමට මතක තබා ගන්න;

    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
    Calendar cal = Calendar.getInstance();
    System.out.println("time => " + dateFormat.format(cal.getTime()));

    String time_str = dateFormat.format(cal.getTime());

    String[] s = time_str.split(" ");

    for (int i = 0; i < s.length; i++) {
         System.out.println("date  => " + s[i]);
    }

    int year_sys = Integer.parseInt(s[0].split("/")[0]);
    int month_sys = Integer.parseInt(s[0].split("/")[1]);
    int day_sys = Integer.parseInt(s[0].split("/")[2]);

    int hour_sys = Integer.parseInt(s[1].split(":")[0]);
    int min_sys = Integer.parseInt(s[1].split(":")[1]);

    System.out.println("year_sys  => " + year_sys);
    System.out.println("month_sys  => " + month_sys);
    System.out.println("day_sys  => " + day_sys);

    System.out.println("hour_sys  => " + hour_sys);
    System.out.println("min_sys  => " + min_sys);

ඔබට වත්මන් දිනය අවශ්‍ය නම්:

Calendar cc = Calendar.getInstance();
int year = cc.get(Calendar.YEAR);
int month = cc.get(Calendar.MONTH);
int mDay = cc.get(Calendar.DAY_OF_MONTH);
System.out.println("Date", year + ":" + month + ":" + mDay);

ඔබට වත්මන් කාලය අවශ්‍ය නම්:

 int mHour = cc.get(Calendar.HOUR_OF_DAY);
 int mMinute = cc.get(Calendar.MINUTE);
 System.out.println("time_format" + String.format("%02d:%02d", mHour , mMinute));

ඔබට android.os.SystemClock ද භාවිතා කළ හැකිය. උදාහරණයක් ලෙස SystemClock.elapsedRealtime () මඟින් දුරකථනය නිදා සිටියදී වඩාත් නිවැරදි කාල කියවීම් ලබා දෙනු ඇත.

අභිරුචි කළ කාලය සහ දිනය ආකෘතිය සඳහා:

    SimpleDateFormat dateFormat= new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZZZZZ",Locale.ENGLISH);
    String cDateTime=dateFormat.format(new Date());

ප්‍රතිදානය පහත ආකෘතියට සමාන ය: 2015-06-18T10: 15: 56-05: 00

Date todayDate = new Date();
todayDate.getDay();
todayDate.getHours();
todayDate.getMinutes();
todayDate.getMonth();
todayDate.getTime();

Time now = new Time();
now.setToNow();

මෙය මා වෙනුවෙන්ද උත්සාහ කරන්න.

මෙය භාවිතා කිරීමෙන් දිනය ලබා ගත හැකිය:

Time t = new Time(Time.getCurrentTimezone());
t.setToNow();
String date = t.format("%Y/%m/%d");

මෙම උදාහරණයේ දී මෙන් මෙය ඔබට හොඳ ස්වරූපයෙන් ප්‍රති result ලයක් ලබා දෙනු ඇත: "2014/02/09".

ඔබට පහත කේතය භාවිතා කළ හැකිය:

 DateFormat df = new SimpleDateFormat("HH:mm"); // Format time
 String time = df.format(Calendar.getInstance().getTime());

 DateFormat df1 = new SimpleDateFormat("yyyy/MM/dd"); // Format date
 String date = df1.format(Calendar.getInstance().getTime());

ඒපීඅයි හි සමහර පිළිතුරු සමඟ මට ගැටලු ඇති බැවින් මම මෙම කේතය විලයනය කරමි, එය ඔවුන්ට සේවය කරයි යැයි මම විශ්වාස කරමි:

    Time t = new Time(Time.getCurrentTimezone());
    t.setToNow();
    String date1 = t.format("%Y/%m/%d");

    Date date = new Date(System.currentTimeMillis());
    SimpleDateFormat dateFormat = new SimpleDateFormat("hh:mm aa",
            Locale.ENGLISH);
    String var = dateFormat.format(date);
    String horafecha = var+ " - " + date1;

    tvTime.setText(horafecha);

නිමැවුම්: 03:25 PM - 2017/10/03

මේක උත්සාහ කරන්න

String mytime = (DateFormat.format("dd-MM-yyyy hh:mm:ss", new java.util.Date()).toString());

පහත දැක්වෙන ක්‍රමවේදය මඟින් වත්මන් දිනය සහ වේලාව නූල් වලින් ලබා දෙනු ඇත, ඔබගේ සත්‍ය කාල කලාපයට අනුව විවිධ කාල කලාප භාවිතා කරන්න. මම GMT භාවිතා කර ඇත

public static String GetToday(){
    Date presentTime_Date = Calendar.getInstance().getTime();
    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    dateFormat.setTimeZone(TimeZone.getTimeZone("GMT"));
    return dateFormat.format(presentTime_Date);
}

නව API අනුව ඔබ දින දර්ශන පන්තිය භාවිතා කළ යුතුය. දිනය පන්තිය දැන් අතහැර දමා ඇත.

Calendar cal = Calendar.getInstance();

String date = ""+cal.get(Calendar.DATE)+"-"+(cal.get(Calendar.MONTH)+1)+"-"+cal.get(Calendar.YEAR);

String time = ""+cal.get(Calendar.HOUR_OF_DAY)+":"+cal.get(Calendar.MINUTE);

පහත කේතය භාවිතා කිරීමට උත්සාහ කරන්න:

 Date date = new Date();
 SimpleDateFormat dateFormatWithZone = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'",Locale.getDefault());  
 String currentDate = dateFormatWithZone.format(date);