Ich weiß , das wird mir den Tag des Monats als Zahl ( 11, 21, 23):

SimpleDateFormat formatDayOfMonth = new SimpleDateFormat("d");

Aber wie formatieren Sie den Tag des Monats ein umfassen Ordinalzeichen , sagen wir 11th, 21stoder 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";
    }
}

Die Tabelle von @kaliatech ist nett, aber da die gleichen Informationen wiederholt werden, besteht die Möglichkeit eines Fehlers. Ein solcher Fehler ist tatsächlich in der Tabelle für 7tn, 17tnund vorhanden 27tn(dieser Fehler kann im Laufe der Zeit aufgrund der fließenden Natur von StackOverflow behoben werden. Überprüfen Sie daher den Versionsverlauf in der Antwort , um den Fehler zu sehen).

In JDK gibt es nichts, was dies tun könnte.

  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];

Oder mit Kalender:

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

Laut Kommentaren von @ thorbjørn-ravn-andersen kann eine Tabelle wie diese beim Lokalisieren hilfreich sein:

  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";
    }
}

Frage ist wenig alt. Da diese Frage sehr laut ist, poste ich, was ich mit der statischen Methode als Util gelöst habe. Einfach kopieren, einfügen und verwenden!

 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);
    }

Zum Testen von Purose

Beispiel: Aufruf von der Hauptmethode!

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));
        }

Ausgabe:

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)];
}

Ich möchte die moderne Antwort beitragen. Die SimpleDateFormatKlasse konnte verwendet werden, als die Frage vor 8 Jahren gestellt wurde, aber Sie sollten sie jetzt vermeiden, da sie nicht nur längst veraltet, sondern auch notorisch problematisch ist. Verwenden Sie java.timestattdessen.

Bearbeiten

DateTimeFormatterBuilder.appendText(TemporalField, Map<Long, String>)ist großartig für diesen Zweck. Damit erstellen wir einen Formatierer, der die Arbeit für uns erledigt:

    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);
    }

Die Ausgabe dieses Snippets lautet:

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

Alte Antwort

Dieser Code ist kürzer, aber meiner Meinung nach nicht so elegant.

    // 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()]);

Ich habe gerade dieses Snippet ausgeführt

23 ..

Eines der vielen Merkmale von java.timeist, dass es einfach und zuverlässig ist, den Tag des Monats als zu erhalten int, was offensichtlich erforderlich ist, um das richtige Suffix aus der Tabelle auszuwählen.

Ich empfehle Ihnen, auch einen Unit-Test zu schreiben.

PS Eine ähnliche Formatierer kann auch verwendet werden für das Parsen ein Datum String mit Ordnungszahlen wie 1st, 2ndusw. Das in getan wurde diese Frage: Java - Parse Datum mit optionalen Sekunden .

Link: Oracle-Tutorial: Datum Uhrzeit zur Erläuterung der Verwendung java.time.

Wenn Sie versuchen, sich i18n bewusst zu werden, wird die Lösung noch komplizierter.

Das Problem ist, dass in anderen Sprachen das Suffix nicht nur von der Zahl selbst abhängt, sondern auch von dem Substantiv, das es zählt. Zum Beispiel auf Russisch wäre es "2-ой день", aber "2-ая неделя" (diese bedeuten "2. Tag", aber "2. Woche"). Dies gilt nicht, wenn wir nur Tage formatieren, aber in einem etwas allgemeineren Fall sollten Sie sich der Komplexität bewusst sein.

Ich denke, eine gute Lösung (ich hatte keine Zeit, sie tatsächlich zu implementieren) wäre, SimpleDateFormetter zu erweitern, um das länderspezifische MessageFormat anzuwenden, bevor es an die übergeordnete Klasse übergeben wird. Auf diese Weise können Sie beispielsweise die März-Formate% M unterstützen, um "3-rd" zu erhalten,% MM, um "03-rd" zu erhalten, und% MMM, um "3" zu erhalten. Von außerhalb sieht diese Klasse wie normaler SimpleDateFormatter aus, unterstützt jedoch mehr Formate. Auch wenn dieses Muster versehentlich vom regulären SimpleDateFormetter angewendet würde, wäre das Ergebnis falsch formatiert, aber dennoch lesbar.

Viele der Beispiele hier funktionieren nicht für 11, 12, 13. Dies ist allgemeiner und funktioniert für alle Fälle.

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";
}

Ich kann mich nicht mit den Antworten zufrieden geben, die eine Lösung nur für Englisch erfordern, die auf manuellen Formaten basiert. Ich habe jetzt schon eine Weile nach einer richtigen Lösung gesucht und sie endlich gefunden.

Sie sollten RuleBasedNumberFormat verwenden . Es funktioniert perfekt und respektiert das Gebietsschema.

Es gibt einen einfacheren und sichereren Weg, dies zu tun. Die Funktion, die Sie verwenden müssen, ist getDateFromDateString (dateString). Grundsätzlich wird das st / nd / rd / th aus einer Datumszeichenfolge entfernt und einfach analysiert. Sie können Ihr SimpleDateFormat in alles ändern, und dies wird funktionieren.

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;

}}

Das einzige Problem mit der von Greg bereitgestellten Lösung ist, dass sie keine Zahl größer als 100 berücksichtigt, wobei die "Teen" -Nummern enden. Zum Beispiel sollte 111 111 sein, nicht 111. Das ist meine Lösung:

/**
 * 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 in der Intensivbibliothek

Ich habe den Link zur Bibliothek des ICU-Projekts von @ Pierre-Olivier Dybman ( http://www.icu-project.org/apiref/icu4j/com/ibm/icu/text/RuleBasedNumberFormat.html ) sehr geschätzt , musste aber noch herausfinden Informationen zur Verwendung finden Sie weiter RuleBasedNumberFormatunten. Ein Beispiel für die Verwendung finden Sie weiter unten.

Es wird nur eine einzelne Zahl und nicht das gesamte Datum formatiert. Sie müssen also eine kombinierte Zeichenfolge erstellen, wenn Sie nach einem Datum im Format suchen: beispielsweise Montag, 3. Februar.

Der folgende Code legt das RuleBasedNumberFormatFormat als Ordnungszahl für ein bestimmtes Gebietsschema fest, erstellt eine java.time ZonedDateTimeund formatiert die Zahl mit ihrer Ordnungszahl in eine Zeichenfolge.

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

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

Beispielausgabe:

3 ..

Oder

4 ..

etc.

Hier ist ein Ansatz, der ein DateTimeFormatter-Muster mit dem richtigen Suffix-Literal aktualisiert, wenn es das Muster findet d'00', z. B. für den Tag des Monats 1, durch den es ersetzt wird d'st'. Sobald das Muster aktualisiert wurde, kann es einfach in den DateTimeFormatter eingegeben werden, um den Rest zu erledigen.

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;
}

Es ist erforderlich, dass das ursprüngliche Muster unmittelbar vor jedem Formatierungsaufruf aktualisiert wird, z

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

Dies ist also nützlich, wenn das Formatierungsmuster außerhalb von Java-Code definiert ist, z. B. einer Vorlage, bei der Sie das Muster in Java definieren können und dann die Antwort von @ OleV.V. könnte angemessener sein

Ich habe mir selbst eine Hilfsmethode geschrieben, um Muster dafür zu erhalten.

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;
}

und dann können wir es als nennen

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);

die Ausgabe ist

December 12th, 2018

Versuchen Sie die folgende Funktion:

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);
}

In Kotlin können Sie so verwenden

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"
        }
    }

so einstellen

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

Die folgende Methode kann verwendet werden, um die formatierte Zeichenfolge des Datums abzurufen, das an sie übergeben wird. Das Datum wird mit SimpleDateFormat in Java so formatiert, dass es 1., 2., 3., 4. ist. zB: - 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);
        }

Das Folgende ist eine effizientere Antwort auf die Frage, als den Stil fest zu codieren.

Um den Tag in eine Ordnungszahl zu ändern, müssen Sie das folgende Suffix verwenden .

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

OR to spell the number add SP to the format

DD + SPTH = DDSPTH   result >>> FOURTH

Finden Sie meine vollständige Antwort in dieser Frage.

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";
  }
}