So che questo mi darà il giorno del mese come numero ( 11, 21, 23):

SimpleDateFormat formatDayOfMonth = new SimpleDateFormat("d");

Ma come formattare il giorno del mese per includere un indicatore ordinale , diciamo 11th, 21sto 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";
    }
}

La tabella di @kaliatech è carina, ma poiché si ripetono le stesse informazioni, si apre la possibilità di un bug. Un tale bug esiste effettivamente nella tabella per 7tn, 17tne 27tn(questo errore potrebbe essere corretto col passare del tempo a causa della natura fluida di StackOverflow, quindi controlla la cronologia delle versioni sulla risposta per vedere l'errore).

Non c'è nulla in JDK per farlo.

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

O usando Calendar:

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

Per i commenti di @ thorbjørn-ravn-andersen, una tabella come questa può essere utile durante la localizzazione:

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

La domanda è poco vecchia. Poiché questa domanda è molto rumorosa, pubblicare ciò che ho risolto con il metodo statico come util. Basta copiare, incollare e usarlo!

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

Per testare il purosio

Esempio: chiamandolo dal metodo principale!

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

Produzione:

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

Vorrei contribuire con la risposta moderna. La SimpleDateFormatlezione era OK quando la domanda è stata posta 8 anni fa, ma dovresti evitarla ora poiché non solo è obsoleta da tempo, ma anche notoriamente problematica. Usa java.timeinvece.

modificare

DateTimeFormatterBuilder.appendText(TemporalField, Map<Long, String>)è ottimo per questo scopo. Usandolo costruiamo un formatter che fa il lavoro per noi:

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

L'output di questo snippet è:

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

Vecchia risposta

Questo codice è più breve, ma IMHO non è così elegante.

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

In esecuzione questo frammento proprio ora ho avuto

23

Una delle tante caratteristiche di java.timeè che è semplice e affidabile ottenere il giorno del mese come int, che è ovviamente necessario per scegliere il suffisso giusto dal tavolo.

Ti consiglio di scrivere anche un test unitario.

PS Un formattatore simile può essere utilizzato anche per l'analisi di una stringa di data che contiene i numeri ordinali come 1st, 2ndecc che è stato fatto in questa domanda: Java - data Parse con secondi opzionali .

Link: tutorial Oracle: Data Ora che spiega come utilizzare java.time.

Se provi a conoscere i18n, la soluzione diventa ancora più complicata.

Il problema è che in altre lingue il suffisso può dipendere non solo dal numero stesso, ma anche dal nome che conta. Ad esempio in russo sarebbe "2-ой день", ma "2-ая неделя" (significano "2 ° giorno", ma "2 ° settimana"). Questo non si applica se formattiamo solo giorni, ma in un caso un po 'più generico dovresti essere consapevole della complessità.

Penso che una buona soluzione (non ho avuto il tempo di implementare effettivamente) sarebbe quella di estendere SimpleDateFormetter per applicare MessageFormat compatibile con le impostazioni locali prima di passare alla classe padre. In questo modo saresti in grado di supportare, diciamo per i formati di marzo% M per ottenere "3 °",% MM per ottenere "03 °" e% MMM per ottenere "terzo". Al di fuori di questa classe sembra un normale SimpleDateFormatter, ma supporta più formati. Inoltre, se questo schema venisse applicato per errore dal normale SimpleDateFormetter, il risultato sarebbe formattato in modo errato, ma comunque leggibile.

Molti degli esempi qui non funzioneranno per 11, 12, 13. Questo è più generico e funzionerà per tutti i casi.

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

Non posso essere soddisfatto delle risposte che richiedono una soluzione solo inglese basata su formati manuali. Sto cercando una soluzione adeguata da un po 'di tempo e finalmente l'ho trovata.

Dovresti usare RuleBasedNumberFormat . Funziona perfettamente ed è rispettoso del Locale.

C'è un modo più semplice e sicuro per farlo. La funzione che devi usare è getDateFromDateString (dateString); Rimuove sostanzialmente lo st / nd / rd / th off di una stringa di data e semplicemente la analizza. Puoi modificare SimpleDateFormat in qualsiasi cosa e questo funzionerà.

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;

}

L'unico problema con la soluzione fornita da Greg è che non tiene conto di un numero maggiore di 100 con la fine dei numeri "adolescenti". Ad esempio, 111 dovrebbe essere 111 °, non 111 °. Questa è la mia soluzione:

/**
 * 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 nella libreria ICU

Ho apprezzato il link alla biblioteca del progetto ICU da @ Pierre-Olivier Dybman ( http://www.icu-project.org/apiref/icu4j/com/ibm/icu/text/RuleBasedNumberFormat.html ), ma ho comunque dovuto capire come usarlo, quindi un esempio di RuleBasedNumberFormatutilizzo è di seguito.

Formatterà solo un numero singolo anziché l'intera data, quindi dovrai creare una stringa combinata se cerchi una data in formato: lunedì 3 febbraio, ad esempio.

Il codice seguente imposta il RuleBasedNumberFormatformato come Ordinale per una determinata Locale, crea un java.time ZonedDateTimee quindi formatta il numero con il suo ordinale in una stringa.

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

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

Esempio di output:

3 °

O

4 °

eccetera.

Ecco un approccio che aggiorna un modello DateTimeFormatter con il suffisso corretto letterale se trova il modello d'00', ad esempio per il giorno del mese 1 con cui verrebbe sostituito d'st'. Una volta che il modello è stato aggiornato, può essere semplicemente inserito nel DateTimeFormatter per fare il resto.

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

Richiede che il modello originale sia aggiornato appena prima di ogni chiamata di formattazione, ad es

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

Quindi questo è utile se il modello di formattazione è definito al di fuori del codice Java, ad esempio un modello, dove come se fosse possibile definire il modello in Java, allora la risposta di @ OleV.V. potrebbe essere più appropriato

Ho scritto me stesso un metodo di supporto per ottenere schemi per questo.

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

e quindi possiamo chiamarlo come

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

l'uscita è

December 12th, 2018

Prova sotto la funzione:

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 puoi usare così

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

impostato in questo modo

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

Il seguente metodo può essere utilizzato per ottenere la stringa formattata della data che gli viene passata. Formatterà la data per dire 1 °, 2 °, 3 °, 4 ° .. usando SimpleDateFormat in Java. ad es .: 1 ° settembre 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);
        }

Quella che segue è una risposta più efficiente alla domanda piuttosto che codificare a fondo lo stile.

Per cambiare il giorno in numero ordinale è necessario utilizzare il seguente suffisso .

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

OR to spell the number add SP to the format

DD + SPTH = DDSPTH   result >>> FOURTH

Trova la mia risposta completa in questa domanda.

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