Comment voulez vous mettre en forme le jour du mois pour dire “11”, “21” ou “23” (indicateur ordinal)?

Il n'y a rien dans le JDK pour ce faire.

  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 à l'aide d'un Calendrier:

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

Par les commentaires de @thorbjørn-ravn-andersen, un tableau comme celui qui 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" };

Question est de petite vieille. Comme cette question est très bruyant donc de poster ce que j'ai résolu avec la méthode statique comme un util. Il suffit de copier, coller et l'utiliser!

 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 les tests purose

Exemple: appel de 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));
        }

De sortie:

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

Si vous essayez d'être conscient de l'i18n la solution obtenir encore plus compliqué.

Le problème est que dans d'autres langues, le suffixe peut dépendre non seulement sur le nombre lui-même, mais aussi sur le nom qu'il compte. Par exemple en russe, il serait "2-ой день", mais "2-ая неделя" (il s'agit de signifier "2ème journée", mais "2ème semaine"). Ce n'est pas valable si le formatage jours seulement, mais en un peu plus de cas générique, vous devez être conscient de la complexité.

Je pense que la solution sympa (je n'ai pas eu le temps de réellement mettre en œuvre) serait d'étendre SimpleDateFormetter pour appliquer des paramètres Régionaux conscient MessageFormat avant de passer à la classe parent. De cette façon, vous serait en mesure de soutenir disons que pour le mois de Mars formats %M pour obtenir "3-rd", %MM pour obtenir "03-rd" et %MMM pour obtenir des "tiers". De l'extérieur de la classe ressemble régulière SimpleDateFormatter, mais prend en charge plusieurs formats. Aussi si ce modèle serait par erreur appliqué par la régularité de la SimpleDateFormetter le résultat serait mal mis en forme, mais encore lisible.

Les nombreux exemples présentés ici ne fonctionnera pas pour les 11, 12, 13. C'est plus générique et de travail 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";
}

Il est simple et sûr moyen de le faire. La fonction que vous devez utiliser est getDateFromDateString(dateString); Il élimine en principe le st/nd/rd/th hors d'une chaîne de date et simplement l'analyse. Vous pouvez modifier votre SimpleDateFormat à rien et que cela fonctionne.

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;

}

Ici est une approche qui met à jour une DateTimeFormatter modèle avec le bon suffixe littérale si elle 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 donc être introduit dans le 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;
}

Il ne nécessite que le modèle original est mis à jour juste avant chaque mise en forme d'appel, par exemple,

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

Si cela est utile si le format est défini en dehors du code Java, par exemple, un modèle, si vous pouvez définir le modèle en Java, alors la réponse par @OleV.V. peut-être plus approprié

Dans kotlin vous pouvez utiliser comme cette

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

définir comme ce

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

La méthode suivante peut être utilisée pour obtenir la chaîne mise en forme de la date qui est passé à elle. Il va le format de la date-à-dire le 1er,2ème,3ème,4ème .. à l'aide de SimpleDateFormat en Java. par exemple:- du 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);
        }

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