Je sais que cela va me donner le jour du mois en nombre ( 11, 21, 23):

SimpleDateFormat formatDayOfMonth = new SimpleDateFormat("d");

Mais comment formatez-vous le jour du mois pour inclure un indicateur ordinal , disons 11th, 21stou 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";
    }
}

Le tableau de @kaliatech est sympa, mais comme les mêmes informations sont répétées, cela ouvre la possibilité d'un bug. Un tel bug existe réellement dans la table 7tn, 17tnet 27tn(ce bug pourrait se fixe au fil du temps en raison de la nature fluide de StackOverflow, de vérifier l'historique de version sur la réponse pour voir l'erreur).

Il n'y a rien dans JDK pour faire cela.

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

Ou en utilisant le calendrier:

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

Selon les commentaires de @ thorbjørn-ravn-andersen, un tableau comme celui-ci peut être utile lors de la localisation:

  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 question est un peu vieille. Comme cette question est très bruyante, poster ce que j'ai fait résolu avec la méthode statique en tant qu'utilitaire. Copiez, collez et utilisez-le!

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

Pour tester purose

Exemple: l'appel à partir de la méthode main!

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

Production:

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

Je voudrais apporter la réponse moderne. La SimpleDateFormatclasse était acceptable lorsque la question a été posée il y a 8 ans, mais vous devriez l'éviter maintenant car elle est non seulement obsolète depuis longtemps, mais aussi notoirement gênante. Utilisez java.timeplutôt.

Éditer

DateTimeFormatterBuilder.appendText(TemporalField, Map<Long, String>)est parfait à cet effet. En l'utilisant, nous construisons un formateur qui fait le travail pour nous:

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

Le résultat de cet extrait de code est:

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

Ancienne réponse

Ce code est plus court, mais à mon humble avis, pas si élégant.

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

J'exécute cet extrait juste maintenant

23e

L'une des nombreuses caractéristiques de java.timeest qu'il est simple et fiable d'obtenir le jour du mois sous forme de int, ce qui est évidemment nécessaire pour choisir le bon suffixe dans le tableau.

Je vous recommande également d'écrire un test unitaire.

PS Un formatter similaire peut également être utilisé pour l' analyse d' une chaîne de date contenant des nombres ordinaux comme 1st, 2nd, etc. Cela a été fait dans cette question: Java - Date Parse avec secondes en option .

Lien: tutoriel Oracle: date et heure expliquant comment utiliser java.time.

Si vous essayez de connaître i18n, la solution devient encore plus compliquée.

Le problème est que dans d'autres langues, le suffixe peut dépendre non seulement du nombre lui-même, mais aussi du nom qu'il compte. Par exemple, en russe, ce serait "2-ой день", mais "2-ая неделя" (cela signifie "2ème jour", mais "2ème semaine"). Cela ne s'applique pas si nous ne formalisons que des jours, mais dans un cas un peu plus générique, vous devez être conscient de la complexité.

Je pense qu'une bonne solution (je n'ai pas eu le temps de mettre en œuvre réellement) serait d'étendre SimpleDateFormetter pour appliquer MessageFormat tenant compte des paramètres régionaux avant de passer à la classe parente. De cette façon, vous seriez en mesure de prendre en charge les formats de mars% M pour obtenir "3-rd",% MM pour obtenir "03-rd" et% MMM pour obtenir "troisième". De l'extérieur, cette classe ressemble à SimpleDateFormatter ordinaire, mais prend en charge plus de formats. De plus, si ce modèle était appliqué par erreur par SimpleDateFormetter ordinaire, le résultat serait incorrectement formaté, mais toujours lisible.

La plupart des exemples ici ne fonctionneront pas pour 11, 12, 13. C'est plus générique et fonctionnera pour tous les cas.

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

Je ne peux pas être satisfait des réponses appelant à une solution uniquement en anglais basée sur des formats manuels. Je cherchais une solution appropriée depuis un moment maintenant et je l'ai finalement trouvée.

Vous devez utiliser RuleBasedNumberFormat . Cela fonctionne parfaitement et c'est respectueux de la locale.

Il existe un moyen plus simple et sûr de le faire. La fonction que vous devrez utiliser est getDateFromDateString (dateString); Il supprime fondamentalement le st / nd / rd / th d'une chaîne de date et l'analyse simplement. Vous pouvez changer votre SimpleDateFormat en n'importe quoi et cela fonctionnera.

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;

}

Le seul problème avec la solution fournie par Greg est qu'elle ne tient pas compte du nombre supérieur à 100 avec les nombres «adolescents» se terminant. Par exemple, 111 devrait être 111e, pas 111e. Voici ma solution:

/**
 * 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 dans la bibliothèque ICU

J'ai apprécié le lien vers la bibliothèque du projet ICU de @ Pierre-Olivier Dybman ( http://www.icu-project.org/apiref/icu4j/com/ibm/icu/text/RuleBasedNumberFormat.html ), mais il fallait encore figurer comment l'utiliser, donc un exemple d' RuleBasedNumberFormatutilisation est ci-dessous.

Il ne formatera qu'un seul nombre plutôt que la date entière, vous devrez donc créer une chaîne combinée si vous recherchez une date au format: lundi 3 février, par exemple.

Le code ci-dessous définit le en RuleBasedNumberFormattant que format ordinal pour un paramètre régional donné, crée un java.time ZonedDateTime, puis met en forme le nombre avec son ordinal dans une chaîne.

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

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

Exemple de sortie:

3e

Ou

4e

etc.

Voici une approche qui met à jour un modèle DateTimeFormatter avec le suffixe littéral correct s'il trouve le modèle d'00', par exemple pour le jour du mois 1, il serait remplacé par d'st'. Une fois que le modèle a été mis à jour, il peut simplement être introduit dans DateTimeFormatter pour faire le reste.

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

Cela nécessite que le modèle d'origine soit mis à jour juste avant chaque appel de formatage, par exemple

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

Cela est donc utile si le modèle de formatage est défini en dehors du code Java, par exemple un modèle, où comme si vous pouviez définir le modèle en Java, la réponse par @ OleV.V. pourrait être plus approprié

J'ai écrit moi-même une méthode d'aide pour obtenir des modèles pour cela.

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

et alors nous pouvons l'appeler comme

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

la sortie est

December 12th, 2018

Essayez la fonction ci-dessous:

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

Dans kotlin, vous pouvez utiliser comme ça

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

réglé comme ça

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

La méthode suivante peut être utilisée pour obtenir la chaîne formatée de la date qui lui est transmise. Il formatera la date pour dire 1er, 2ème, 3ème, 4ème .. en utilisant SimpleDateFormat en Java. ex: - 1er septembre 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);
        }

Ce qui suit est une réponse plus efficace à la question plutôt que de coder en dur le style.

Pour changer le jour en nombre ordinal, vous devez utiliser le suffixe suivant .

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

OR to spell the number add SP to the format

DD + SPTH = DDSPTH   result >>> FOURTH

Trouvez ma réponse complète dans cette question.

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