Comment formatez-vous le jour du mois pour dire «11e», «21e» ou «23e» (indicateur ordinal)?

146

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?

Ken Hume
la source
13
Pour référence, ils sont appelés nombres ordinaux - en.wikipedia.org/wiki/Ordinal_number_(linguistics) .
ocodo
5
Pour mémoire, tout ce qui construit la réponse au lieu de rechercher la réponse entière dans un tableau est presque impossible à localiser dans d'autres langues.
Thorbjørn Ravn Andersen
2
La réponse est en quelque sorte incorrecte, jetez un œil à ma réponse plz.
J888
2
Commentaire moderne: je vous recommande d'éviter le SimpleDateFormatcours. Il n'est pas seulement obsolète depuis longtemps, il est également notoirement gênant. Aujourd'hui, nous avons tellement mieux dans java.timel'API de date et d'heure Java moderne et ses DateTimeFormatter.
Ole VV
Jetez un œil à l'API des nombres ( math.tools/api/numbers ). Il prend en charge l'ordinal, le cardinal, le nombre épelé dans une langue différente, épelé comme monnaie dans diverses langues, etc.
dors le

Réponses:

181
// 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).

Greg Mattes
la source
36
cela ressemble vraiment à un oubli dans le format de données simple, n'est-ce pas?
stevevls
51
Amusez-vous à l'internationaliser. : D
Trejkaz
6
@Trejkaz En dehors de la portée de la question :)
Greg Mattes
3
Cette solution ne prend en charge que l'anglais. Utilisez RuleBasedNumberFormat d'ICU4J pour la solution localisée.
Дмитро Яковлєв
7
Vous êtes dans les mauvaises herbes, et le ton prend un peu de sens. Pas besoin de çà. Cette question ne portait pas sur les subtilités de l'internationalisation. L'internationalisation est certainement un bon sujet à discuter, mais elle devrait être faite sur une autre question dans ce sens. J'ai toujours interprété cette question comme demandant un moyen rapide et sale d'accomplir cela en anglais. Donc, je suggère que s'il n'y a vraiment pas de bonne solution dans le monde Java qui soit compatible avec l'internationalisation, nous commençons un projet sur, par exemple, GitHub et créons une bonne solution. Faites-moi savoir si vous êtes intéressé.
Greg Mattes
51

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" };
Kaliatech
la source
8
Si vous laissez la table contenir le plein "21e", "23e", "29e", il peut être externalisé et localisé dans d'autres langues. Pour un logiciel réussi qui peut devenir une exigence.
Thorbjørn Ravn Andersen
40
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";
    }
}
Anand Shekhar
la source
Je viens d'essayer votre solution en omettant les guillemets simples dans la chaîne de modèle fournie au constructeur SimpleDateFormat. Je vois maintenant pourquoi ils sont là. J'obtiens un à java.lang.IllegalArgumentExceptioncause d'un "caractère de motif illégal, t."
danny typique
17

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
Sarz
la source
16
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)];
}
ocodo
la source
15

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.

Ole VV
la source
J'adorerais que cette réponse soit augmentée, car cette réponse plus moderne vaut mieux que d'essayer de déployer votre propre implémentation.
Krease
9

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.

TAXI
la source
Bon point sur les genres en russe, mais cela rendrait techniquement% MMM impossible sans contexte supplémentaire.
Mad Physicist
@Mad Physicist, ce n'est pas vrai car% MMM sera appliqué au mois, nous connaissons donc le nom à conjuguer.
CAB
6

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";
}
sivag1
la source
5

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.

Pierre-Olivier Dybman
la source
3

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;

}

Erdem Memisyazici
la source
1
Cette réponse concerne l' analyse d' une chaîne tandis que la question concerne la génération d' une chaîne. Mais toujours approprié car il est probable que l'on ait besoin des deux directions. En outre, cette réponse résout cette autre question .
Basil Bourque
3

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";
    }
}
Talisphère
la source
6
Dans quel cas une séquence Jour Mois aurait-elle plus de 31 jours?
SatanAnglais
@SatanEnglish, la bonne chose à propos de cette méthode de fabrique statique est qu'elle peut être utilisée pour plus que simplement obtenir le suffixe d'un mois. :)
Jared Rummler
1
Cette méthode renvoie st pour 11, nd pour 12 et rd pour 13
TheIT
@SatanEnglish. Étant donné qu'aujourd'hui est le 137 février dans mon calendrier de choix, je pense que votre question répond d'elle-même. Sérieusement, les calendriers non grégoriens abondent si vous savez où chercher.
Mad Physicist
Non, @ TheIT, ce n'est pas le cas. J'ai testé. Il revient thpour 11, 12 et 13 comme il se doit. Je crois que l' if ( hunRem - tenRem == 10 )affaire garantit que c'est le cas.
Ole VV
2

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.

tbigby
la source
1

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é

tazmaniax
la source
1
Créatif et alambiqué. Il m'a certainement fallu beaucoup de temps pour comprendre comment cela fonctionne. Ce n'est pas le signe d'un bon code.
Ole VV
1
@ OleV.V. merci pour les commentaires - je l'ai un peu restructuré pour qu'il soit un peu moins verbeux. Je viens de voir ton approche et j'aime ça! Je pense que les deux approches sont valables avec des compromis différents. Le vôtre ne nécessite aucune prise en charge supplémentaire au moment du formatage, mais nécessite que le modèle soit défini à l'aide du générateur qui empêche la définition de modèle dans un code non Java. Mon approche nécessite un support supplémentaire au moment de la mise en forme, mais aucune dépendance du constructeur pour créer le modèle, ce qui le rend un peu plus flexible là où le modèle peut être défini. Mes exigences ont dicté ce dernier
tazmaniax
3
Très beau compte rendu des avantages et des inconvénients. Vous voudrez peut-être l'inclure dans la réponse? Juste une idée.
Ole VV
1

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
SamHoque
la source
Cela nécessite un API minimum de 26 cependant :)
Mikkel Larsen
@MikkelLarsen cette question ne concernait pas Android, j'utilisais Java 8 pour cela. Android ne prend pas en charge une grande api pour java 8.
SamHoque
@SamSakerz my bad :)
Mikkel Larsen
@MikkelLarsen La plupart des fonctionnalités java.time sont rétroportées vers Java 6 et Java 7 dans le projet ThreeTen-Backport . Adapté davantage pour Android antérieur (<26) dans ThreeTenABP . Voir Comment utiliser ThreeTenABP… .
Basil Bourque
1

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);
}
MEGHA DOBARIYA
la source
Lorsque vous répondez à une ancienne question, votre réponse serait beaucoup plus utile aux autres utilisateurs de StackOverflow si vous incluiez un contexte pour expliquer comment votre réponse aide, en particulier pour une question qui a déjà une réponse acceptée. Voir: Comment écrire une bonne réponse .
David Buck le
Merci de vouloir contribuer. Je recommande de ne pas utiliser Date, Calendaret SimpleDateFormat. Ces classes sont mal conçues et dépassées depuis longtemps, la dernière en particulier étant notoirement gênante. Utilisez plutôt LocalDateet DateTimeFormatter, tous deux de java.time, l'API de date et d'heure Java moderne . Je doute également de la nouveauté de votre réponse par rapport aux 18 autres réponses?
Ole VV le
0

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")
Mohit Suthar
la source
-3

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);
        }
Nadeeshani
la source
-4

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.

J888
la source
La question est de formater en Java pas dans la base de données Oracle docs.oracle.com/cd/B12037_01/server.101/b10759/… Java utilise SimpleDateFormat pour la date: docs.oracle.com/javase/tutorial/i18n/format/…
Belal mazlom
-9
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";
  }
}
Simeon Hearring
la source
Il ne doit pas utiliser endsWith (); qui produisent une mauvaise sortie
Rahul Sharma