Eu sei que isso vai me dar o dia do mês como um número ( 11, 21, 23):

SimpleDateFormat formatDayOfMonth = new SimpleDateFormat("d");

Mas como você formata o dia do mês para incluir um indicador ordinal , digamos 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";
    }
}

A tabela do @kaliatech é boa, mas, como as mesmas informações são repetidas, abre a chance de um bug. Na verdade, esse erro existe na tabela para 7tn, 17tne 27tn(esse erro pode ser corrigido com o passar do tempo devido à natureza fluida do StackOverflow, portanto, verifique o histórico da versão na resposta para ver o erro).

Não há nada no JDK para fazer isso.

  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 usando o Calendário:

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

Por comentários de @ thorbjørn-ravn-andersen, uma tabela como essa pode ser útil ao localizar:

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

A pergunta é um pouco antiga. Como esta pergunta é muito barulhenta, postando o que resolvi com o método estático como um utilitário. Basta copiar, colar e usá-lo!

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

Para testar a purose

Exemplo: chamando-o do método principal!

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

Resultado:

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

Eu gostaria de contribuir com a resposta moderna. A SimpleDateFormataula foi boa para usar quando a pergunta foi feita há oito anos, mas você deve evitá-la agora, pois ela não só está desatualizada há muito tempo, mas também é notoriamente problemática. Use em java.timevez disso.

Editar

DateTimeFormatterBuilder.appendText(TemporalField, Map<Long, String>)é ótimo para esse fim. Utilizando-o, construímos um formatador que faz o trabalho para nós:

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

A saída desse snippet é:

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

Resposta antiga

Este código é mais curto, mas IMHO não é tão 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()]);

Executando esse trecho agora que eu recebi

23

Um dos muitos recursos java.timeé que é simples e confiável obter o dia do mês como um int, o que é obviamente necessário para escolher o sufixo certo da tabela.

Eu recomendo que você escreva um teste de unidade também.

PS Um formatador semelhante também pode ser usado para analisar uma seqüência de data contendo números ordinais, como 1st, 2nd, etc. Isso foi feito em esta pergunta: Java - data Parse com segundos opcionais .

Link: Tutorial do Oracle: Data e hora explicando como usar java.time.

Se você tentar conhecer o i18n, a solução ficará ainda mais complicada.

O problema é que, em outras línguas, o sufixo pode depender não apenas do número em si, mas também do substantivo que conta. Por exemplo, em russo, seria "2-ой день", mas "2-ая неделя" (isso significa "2º dia", mas "2ª semana"). Isso não se aplica se formatarmos apenas dias, mas, em um caso um pouco mais genérico, você deve estar ciente da complexidade.

Acho que a melhor solução (não tive tempo de implementar) seria estender o SimpleDateFormetter para aplicar o MessageFormat com reconhecimento de localidade antes de passar para a classe pai. Dessa forma, você poderá oferecer suporte aos formatos% M para obter "3º",% MM para "3º" e% MMM para "3º". De fora desta classe parece simples SimpleDateFormatter, mas suporta mais formatos. Além disso, se esse padrão fosse aplicado por engano pelo SimpleDateFormetter comum, o resultado seria formatado incorretamente, mas ainda legível.

Muitos dos exemplos aqui não funcionarão para 11, 12, 13. Isso é mais genérico e funcionará para todos os casos.

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

Não estou satisfeito com as respostas que exigem uma solução somente em inglês com base em formatos manuais. Estou procurando uma solução adequada há um tempo e finalmente a encontrei.

Você deve estar usando RuleBasedNumberFormat . Funciona perfeitamente e respeita a localidade.

Existe uma maneira mais simples e segura de fazer isso. A função que você precisará usar é getDateFromDateString (dateString); Ele basicamente remove o st / nd / rd / th de uma string de data e simplesmente o analisa. Você pode alterar seu SimpleDateFormat para qualquer coisa e isso funcionará.

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;

}

O único problema da solução fornecida por Greg é que ela não é responsável por números maiores que 100, com os números "adolescentes" terminando. Por exemplo, 111 deve ser 111, não 111. Esta é a minha solução:

/**
 * 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 na biblioteca da UTI

Apreciei o link para a biblioteca do projeto da UTI de @ Pierre-Olivier Dybman ( http://www.icu-project.org/apiref/icu4j/com/ibm/icu/text/RuleBasedNumberFormat.html ), mas ainda precisava descobrir como usá-lo, então um exemplo do RuleBasedNumberFormatuso está abaixo.

Ele formatará apenas um número e não a data inteira, portanto, você precisará criar uma sequência combinada se procurar uma data no formato: segunda-feira, 3 de fevereiro, por exemplo.

O código abaixo configura o RuleBasedNumberFormatformato como ordinal para um determinado local, cria um java.time ZonedDateTimee formata o número com seu ordinal em uma seqüência de caracteres.

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

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

Exemplo de saída:

3º

Ou

4º

etc.

Aqui está uma abordagem que atualiza um padrão DateTimeFormatter com o literal correto do sufixo se encontrar o padrão d'00', por exemplo, para o dia do mês 1, ele seria substituído por d'st'. Depois que o padrão é atualizado, ele pode apenas ser alimentado no DateTimeFormatter para fazer o 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;
}

Requer que o padrão original seja atualizado imediatamente antes de cada chamada de formatação, por exemplo

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

Portanto, isso é útil se o padrão de formatação for definido fora do código Java, por exemplo, um modelo, onde, como se você pudesse definir o padrão em Java, a resposta seria @ OleV.V. pode ser mais apropriado

Eu escrevi para mim mesmo um método auxiliar para obter padrões para isso.

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 então podemos chamá-lo como

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

a saída é

December 12th, 2018

Tente abaixo da função:

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

No kotlin você pode usar assim

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

definido assim

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

O método a seguir pode ser usado para obter a seqüência de caracteres formatada da data que é passada para ele. Ele formatará a data para dizer 1º, 2º, 3º, 4º .. usando SimpleDateFormat em Java. Por exemplo: - 1 de setembro de 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);
        }

A seguir, é uma resposta mais eficiente à pergunta, em vez de codificar o estilo.

Para alterar o dia para o número ordinal, você precisa usar o seguinte sufixo .

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

OR to spell the number add SP to the format

DD + SPTH = DDSPTH   result >>> FOURTH

Encontre minha resposta completa nesta pergunta.

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