Saya tahu ini akan memberi saya hari bulan sebagai angka ( 11, 21, 23):

SimpleDateFormat formatDayOfMonth = new SimpleDateFormat("d");

Tetapi bagaimana Anda memformat hari dalam bulan untuk memasukkan indikator ordinal , katakanlah 11th, 21statau 23rd?

// https://github.com/google/guava
import static com.google.common.base.Preconditions.*;

String getDayOfMonthSuffix(final int n) {
    checkArgument(n >= 1 && n <= 31, "illegal day of month: " + n);
    if (n >= 11 && n <= 13) {
        return "th";
    }
    switch (n % 10) {
        case 1:  return "st";
        case 2:  return "nd";
        case 3:  return "rd";
        default: return "th";
    }
}

Tabel dari @kaliatech bagus, tetapi karena informasi yang sama diulang, itu membuka peluang untuk bug. Bug seperti itu sebenarnya ada dalam tabel untuk 7tn,, 17tndan 27tn(bug ini mungkin diperbaiki seiring berjalannya waktu karena sifat cair StackOverflow, jadi periksa riwayat versi pada jawaban untuk melihat kesalahannya).

Tidak ada dalam JDK untuk melakukan ini.

  static String[] suffixes =
  //    0     1     2     3     4     5     6     7     8     9
     { "th", "st", "nd", "rd", "th", "th", "th", "th", "th", "th",
  //    10    11    12    13    14    15    16    17    18    19
       "th", "th", "th", "th", "th", "th", "th", "th", "th", "th",
  //    20    21    22    23    24    25    26    27    28    29
       "th", "st", "nd", "rd", "th", "th", "th", "th", "th", "th",
  //    30    31
       "th", "st" };

 Date date = new Date();
 SimpleDateFormat formatDayOfMonth  = new SimpleDateFormat("d");
 int day = Integer.parseInt(formatDateOfMonth.format(date));
 String dayStr = day + suffixes[day];

Atau menggunakan Kalender:

 Calendar c = Calendar.getInstance();
 c.setTime(date);
 int day = c.get(Calendar.DAY_OF_MONTH);
 String dayStr = day + suffixes[day];

Per komentar oleh @ thorbjørn-ravn-andersen, tabel seperti ini dapat membantu ketika melokalisasi:

  static String[] suffixes =
     {  "0th",  "1st",  "2nd",  "3rd",  "4th",  "5th",  "6th",  "7th",  "8th",  "9th",
       "10th", "11th", "12th", "13th", "14th", "15th", "16th", "17th", "18th", "19th",
       "20th", "21st", "22nd", "23rd", "24th", "25th", "26th", "27th", "28th", "29th",
       "30th", "31st" };

private String getCurrentDateInSpecificFormat(Calendar currentCalDate) {
    String dayNumberSuffix = getDayNumberSuffix(currentCalDate.get(Calendar.DAY_OF_MONTH));
    DateFormat dateFormat = new SimpleDateFormat(" d'" + dayNumberSuffix + "' MMMM yyyy");
    return dateFormat.format(currentCalDate.getTime());
}

private String getDayNumberSuffix(int day) {
    if (day >= 11 && day <= 13) {
        return "th";
    }
    switch (day % 10) {
    case 1:
        return "st";
    case 2:
        return "nd";
    case 3:
        return "rd";
    default:
        return "th";
    }
}

Pertanyaan sudah agak tua. Seperti pertanyaan ini sangat berisik sehingga memposting apa yang saya lakukan diselesaikan dengan metode statis sebagai util. Cukup salin, tempel, dan gunakan!

 public static String getFormattedDate(Date date){
            Calendar cal=Calendar.getInstance();
            cal.setTime(date);
            //2nd of march 2015
            int day=cal.get(Calendar.DATE);

            if(!((day>10) && (day<19)))
            switch (day % 10) {
            case 1:  
                return new SimpleDateFormat("d'st' 'of' MMMM yyyy").format(date);
            case 2:  
                return new SimpleDateFormat("d'nd' 'of' MMMM yyyy").format(date);
            case 3:  
                return new SimpleDateFormat("d'rd' 'of' MMMM yyyy").format(date);
            default: 
                return new SimpleDateFormat("d'th' 'of' MMMM yyyy").format(date);
        }
        return new SimpleDateFormat("d'th' 'of' MMMM yyyy").format(date);
    }

Untuk pengujian purose

Contoh: memanggilnya dari metode utama!

Date date = new Date();
        Calendar cal=Calendar.getInstance();
        cal.setTime(date);
        for(int i=0;i<32;i++){
          System.out.println(getFormattedDate(cal.getTime()));
          cal.set(Calendar.DATE,(cal.getTime().getDate()+1));
        }

Keluaran:

22nd of February 2018
23rd of February 2018
24th of February 2018
25th of February 2018
26th of February 2018
27th of February 2018
28th of February 2018
1st of March 2018
2nd of March 2018
3rd of March 2018
4th of March 2018
5th of March 2018
6th of March 2018
7th of March 2018
8th of March 2018
9th of March 2018
10th of March 2018
11th of March 2018
12th of March 2018
13th of March 2018
14th of March 2018
15th of March 2018
16th of March 2018
17th of March 2018
18th of March 2018
19th of March 2018
20th of March 2018
21st of March 2018
22nd of March 2018
23rd of March 2018
24th of March 2018
25th of March 2018

String ordinal(int num)
{
    String[] suffix = {"th", "st", "nd", "rd", "th", "th", "th", "th", "th", "th"};
    int m = num % 100;
    return String.valueOf(num) + suffix[(m > 3 && m < 21) ? 0 : (m % 10)];
}

Saya ingin berkontribusi pada jawaban modern. The SimpleDateFormatkelas adalah OK untuk digunakan ketika pertanyaan itu ditanyakan 8 tahun yang lalu, tetapi Anda harus menghindari sekarang karena tidak hanya lama usang, tetapi juga terkenal merepotkan. Gunakan java.timesebagai gantinya.

Edit

DateTimeFormatterBuilder.appendText(TemporalField, Map<Long, String>)bagus untuk tujuan ini. Menggunakannya kami membangun formatter yang berfungsi untuk kami:

    Map<Long, String> ordinalNumbers = new HashMap<>(42);
    ordinalNumbers.put(1L, "1st");
    ordinalNumbers.put(2L, "2nd");
    ordinalNumbers.put(3L, "3rd");
    ordinalNumbers.put(21L, "21st");
    ordinalNumbers.put(22L, "22nd");
    ordinalNumbers.put(23L, "23rd");
    ordinalNumbers.put(31L, "31st");
    for (long d = 1; d <= 31; d++) {
        ordinalNumbers.putIfAbsent(d, "" + d + "th");
    }

    DateTimeFormatter dayOfMonthFormatter = new DateTimeFormatterBuilder()
            .appendText(ChronoField.DAY_OF_MONTH, ordinalNumbers)
            .appendPattern(" MMMM")
            .toFormatter();

    LocalDate date = LocalDate.of(2018, Month.AUGUST, 30);
    for (int i = 0; i < 6; i++) {
        System.out.println(date.format(dayOfMonthFormatter));
        date = date.plusDays(1);
    }

Output dari snippet ini adalah:

30th August
31st August
1st September
2nd September
3rd September
4th September

Jawaban lama

Kode ini lebih pendek, tetapi IMHO tidak begitu elegan.

    // ordinal indicators by numbers (1-based, cell 0 is wasted)
    String[] ordinalIndicators = new String[31 + 1];
    Arrays.fill(ordinalIndicators, 1, ordinalIndicators.length, "th");
    ordinalIndicators[1] = ordinalIndicators[21] = ordinalIndicators[31] = "st";
    ordinalIndicators[2] = ordinalIndicators[22] = "nd";
    ordinalIndicators[3] = ordinalIndicators[23] = "rd";

    DateTimeFormatter dayOfMonthFormatter = DateTimeFormatter.ofPattern("d");

    LocalDate today = LocalDate.now(ZoneId.of("America/Menominee")).plusWeeks(1);
    System.out.println(today.format(dayOfMonthFormatter) 
                        + ordinalIndicators[today.getDayOfMonth()]);

Menjalankan potongan ini sekarang

Tanggal 23

Salah satu dari banyak fitur java.timeadalah bahwa itu mudah dan dapat diandalkan untuk mendapatkan hari bulan sebagai int, yang jelas diperlukan untuk memilih akhiran yang tepat dari tabel.

Saya sarankan Anda juga menulis unit test.

PS Sebuah formatter yang sama juga dapat digunakan untuk parsing string tanggal yang berisi nomor urut seperti 1st, 2nd, dll Itu dilakukan dalam pertanyaan ini: Java - date Parse dengan detik opsional .

Tautan: Tutorial Oracle: Tanggal Waktu menjelaskan cara menggunakan java.time.

Jika Anda mencoba untuk menyadari i18n solusinya menjadi lebih rumit.

Masalahnya adalah bahwa dalam bahasa lain suffix tidak hanya bergantung pada nomor itu sendiri, tetapi juga pada kata benda yang diperhitungkan. Misalnya dalam bahasa Rusia "2-ой день", tetapi "2-ая неделя" (ini berarti "hari ke-2", tetapi "minggu ke-2"). Ini tidak berlaku jika kita memformat hanya beberapa hari, tetapi dalam kasus yang sedikit lebih umum Anda harus menyadari kompleksitas.

Saya pikir solusi yang bagus (saya tidak punya waktu untuk benar-benar menerapkan) akan memperluas SimpleDateFormetter untuk menerapkan MessageFormat lokal sadar sebelum melewati ke kelas induk. Dengan cara ini Anda dapat mendukung katakanlah untuk format Maret% M untuk mendapatkan "3-rd",% MM untuk mendapatkan "03-rd" dan% MMM untuk mendapatkan "ketiga". Dari luar kelas ini terlihat seperti SimpleDateFormatter biasa, tetapi mendukung lebih banyak format. Juga jika pola ini secara tidak sengaja diterapkan oleh SimpleDateFormetter biasa hasilnya akan diformat secara salah, tetapi masih dapat dibaca.

Banyak contoh di sini tidak akan berfungsi untuk 11, 12, 13. Ini lebih umum dan akan bekerja untuk semua kasus.

switch (date) {
                case 1:
                case 21:
                case 31:
                    return "" + date + "st";

                case 2:
                case 22:
                    return "" + date + "nd";

                case 3:
                case 23:
                    return "" + date + "rd";

                default:
                    return "" + date + "th";
}

Saya tidak dapat puas dengan jawaban yang menyerukan solusi hanya dalam bahasa Inggris berdasarkan format manual. Saya sudah mencari solusi yang tepat untuk sementara waktu sekarang dan akhirnya saya menemukannya.

Anda harus menggunakan RuleBasedNumberFormat . Ini berfungsi dengan baik dan menghormati Lokal.

Ada cara yang lebih sederhana dan pasti untuk melakukan ini. Fungsi yang harus Anda gunakan adalah getDateFromDateString (dateString); Ini pada dasarnya menghapus st / nd / rd / th dari string tanggal dan hanya menguraikannya. Anda dapat mengubah SimpleDateFormat Anda menjadi apa saja dan ini akan berhasil.

public static final SimpleDateFormat sdf = new SimpleDateFormat("d");
public static final Pattern p = Pattern.compile("([0-9]+)(st|nd|rd|th)");

private static Date getDateFromDateString(String dateString) throws ParseException {
     return sdf.parse(deleteOrdinal(dateString));
}

private static String deleteOrdinal(String dateString) {
    Matcher m = p.matcher(dateString);
    while (m.find()) {
        dateString = dateString.replaceAll(Matcher.quoteReplacement(m.group(0)), m.group(1));
    }
    return dateString;

}

Satu-satunya masalah dengan solusi yang disediakan oleh Greg adalah bahwa itu tidak memperhitungkan angka lebih besar dari 100 dengan angka "remaja" berakhir. Misalnya, 111 harus 111, bukan 111. Ini solusi saya:

/**
 * Return ordinal suffix (e.g. 'st', 'nd', 'rd', or 'th') for a given number
 * 
 * @param value
 *           a number
 * @return Ordinal suffix for the given number
 */
public static String getOrdinalSuffix( int value )
{
    int hunRem = value % 100;
    int tenRem = value % 10;

    if ( hunRem - tenRem == 10 )
    {
        return "th";
    }
    switch ( tenRem )
    {
    case 1:
        return "st";
    case 2:
        return "nd";
    case 3:
        return "rd";
    default:
        return "th";
    }
}

RuleBasedNumberFormat di perpustakaan ICU

Saya menghargai tautan ke perpustakaan proyek ICU dari @ Pierre-Olivier Dybman ( http://www.icu-project.org/apiref/icu4j/com/ibm/icu/text/RuleBasedNumberFormat.html ), namun masih harus mencari tahu cara menggunakannya, jadi contoh RuleBasedNumberFormatpenggunaannya di bawah ini.

Ini hanya akan memformat angka tunggal daripada seluruh tanggal, jadi Anda perlu membuat string gabungan jika mencari tanggal dalam format: Senin 3 Februari, misalnya.

Kode di bawah ini mengatur RuleBasedNumberFormatsebagai format Ordinal untuk Lokal yang diberikan, membuat java.time ZonedDateTime, dan kemudian memformat angka dengan ordinalnya menjadi string.

RuleBasedNumberFormat numOrdinalFormat = new RuleBasedNumberFormat(Locale.UK,
    RuleBasedNumberFormat.ORDINAL);
ZonedDateTime zdt = ZonedDateTime.now(ZoneId.of("Pacific/Auckland"));

String dayNumAndOrdinal = numOrdinalFormat.format(zdt.toLocalDate().getDayOfMonth());

Contoh output:

Ke-3

Atau

4

dll.

Berikut adalah pendekatan yang memperbarui pola DateTimeFormatter dengan akhiran sufiks yang benar jika menemukan pola d'00', misalnya untuk hari bulan 1 itu akan diganti dengan d'st'. Setelah polanya diperbarui, baru kemudian dapat dimasukkan ke DateTimeFormatter untuk melakukan sisanya.

private static String[] suffixes = {"th", "st", "nd", "rd"};

private static String updatePatternWithDayOfMonthSuffix(TemporalAccessor temporal, String pattern) {
    String newPattern = pattern;
    // Check for pattern `d'00'`.
    if (pattern.matches(".*[d]'00'.*")) {
        int dayOfMonth = temporal.get(ChronoField.DAY_OF_MONTH);
        int relevantDigits = dayOfMonth < 30 ? dayOfMonth % 20 : dayOfMonth % 30;
        String suffix = suffixes[relevantDigits <= 3 ? relevantDigits : 0];
        newPattern = pattern.replaceAll("[d]'00'", "d'" + suffix + "'");
    }

    return newPattern;
}

Itu memang mengharuskan pola asli diperbarui sebelum setiap panggilan pemformatan, misalnya

public static String format(TemporalAccessor temporal, String pattern) {
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern(updatePatternWithDayOfMonthSuffix(temporal, pattern));
    return formatter.format(temporal);
}

Jadi ini berguna jika pola format didefinisikan di luar kode Java, misalnya templat, di mana seolah-olah Anda dapat menentukan pola di Jawa maka jawabannya oleh @ OleV.V. mungkin lebih tepat

Saya menulis diri saya metode penolong untuk mendapatkan pola untuk ini.

public static String getPattern(int month) {
    String first = "MMMM dd";
    String last = ", yyyy";
    String pos = (month == 1 || month == 21 || month == 31) ? "'st'" : (month == 2 || month == 22) ? "'nd'" : (month == 3 || month == 23) ? "'rd'" : "'th'";
    return first + pos + last;
}

dan kemudian kita bisa menyebutnya sebagai

LocalDate localDate = LocalDate.now();//For reference
int month = localDate.getDayOfMonth();
DateTimeFormatter formatter = DateTimeFormatter.ofPattern(getPattern(month));
String date = localDate.format(formatter);
System.out.println(date);

outputnya adalah

December 12th, 2018

Coba fungsi di bawah ini:

public static String getFormattedDate(Date date) 
{
  Calendar cal = Calendar.getInstance();
  cal.setTime(date);
  //2nd of march 2015
  int day = cal.get(Calendar.DATE);
  if (!((day > 10) && (day < 19)))
   switch (day % 10) {
    case 1:
     return new SimpleDateFormat("d'st' 'of' MMMM yyyy").format(date);
    case 2:
     return new SimpleDateFormat("d'nd' 'of' MMMM yyyy").format(date);
    case 3:
     return new SimpleDateFormat("d'rd' 'of' MMMM yyyy").format(date);
    default:
     return new SimpleDateFormat("d'th' 'of' MMMM yyyy").format(date);
   }
  return new SimpleDateFormat("d'th' 'of' MMMM yyyy").format(date);
}

Di kotlin Anda bisa menggunakan seperti ini

fun changeDateFormats(currentFormat: String, dateString: String): String {
        var result = ""
        try {
            val formatterOld = SimpleDateFormat(currentFormat, Locale.getDefault())
            formatterOld.timeZone = TimeZone.getTimeZone("UTC")

            var date: Date? = null

            date = formatterOld.parse(dateString)

            val dayFormate = SimpleDateFormat("d", Locale.getDefault())
            var day = dayFormate.format(date)

            val formatterNew = SimpleDateFormat("hh:mm a, d'" + getDayOfMonthSuffix(day.toInt()) + "' MMM yy", Locale.getDefault())

            if (date != null) {
                result = formatterNew.format(date)
            }

        } catch (e: ParseException) {
            e.printStackTrace()
            return dateString
        }

        return result
    }


    private fun getDayOfMonthSuffix(n: Int): String {
        if (n in 11..13) {
            return "th"
        }
        when (n % 10) {
            1 -> return "st"
            2 -> return "nd"
            3 -> return "rd"
            else -> return "th"
        }
    }

atur seperti ini

  txt_chat_time_me.text = changeDateFormats("SERVER_DATE", "DATE")

Metode berikut dapat digunakan untuk mendapatkan string yang diformat dari tanggal yang dilewatkan ke dalamnya. Ini akan memformat tanggal untuk mengatakan 1, 2, 3, 4 .. menggunakan SimpleDateFormat di Jawa. misalnya: - 1 September 2015

public String getFormattedDate(Date date){
            Calendar cal=Calendar.getInstance();
            cal.setTime(date);
            //2nd of march 2015
            int day=cal.get(Calendar.DATE);

            switch (day % 10) {
            case 1:  
                return new SimpleDateFormat("d'st' 'of' MMMM yyyy").format(date);
            case 2:  
                return new SimpleDateFormat("d'nd' 'of' MMMM yyyy").format(date);
            case 3:  
                return new SimpleDateFormat("d'rd' 'of' MMMM yyyy").format(date);
            default: 
                return new SimpleDateFormat("d'th' 'of' MMMM yyyy").format(date);
        }

Berikut ini adalah jawaban yang lebih efisien untuk pertanyaan daripada mengkodekan gaya.

Untuk mengubah hari ke nomor urut, Anda perlu menggunakan akhiran berikut .

DD +     TH = DDTH  result >>>> 4TH

OR to spell the number add SP to the format

DD + SPTH = DDSPTH   result >>> FOURTH

Temukan jawaban lengkap saya dalam pertanyaan ini .

public String getDaySuffix(int inDay)
{
  String s = String.valueOf(inDay);

  if (s.endsWith("1"))
  {
    return "st";
  }
  else if (s.endsWith("2"))
  {
    return "nd";
  }
  else if (s.endsWith("3"))
  {
    return "rd";
  }
  else
  {
    return "th";
  }
}