Comment puis-je convertir un nombre Entier en localisées nom du mois en Java?

Vous devez utiliser LLLL pour les noms de mois. ceci est documenté dans le SimpleDateFormat de documents, tels que:

SimpleDateFormat dateFormat = new SimpleDateFormat( "LLLL", Locale.getDefault() );
dateFormat.format( date );

java.temps

Depuis Java 1.8 (ou 1.7 & 1.6 avec le ThreeTen-Backport) vous pouvez utiliser ceci:

Month.of(integerMonth).getDisplayName(TextStyle.FULL_STANDALONE, locale);

Noter que integerMonth est de base 1, c'est à dire 1 est pour le mois de janvier. La gamme est toujours de 1 à 12 pour la période janvier-décembre (c'est à dire le calendrier Grégorien seulement).

À L'Aide De SimpleDateFormat.

import java.text.SimpleDateFormat;

public String formatMonth(String month) {
    SimpleDateFormat monthParse = new SimpleDateFormat("MM");
    SimpleDateFormat monthDisplay = new SimpleDateFormat("MMMM");
    return monthDisplay.format(monthParse.parse(month));
}


formatMonth("2"); 

Résultat: Février

tl;dr

Month.of( yourMonthNumber )           //Represent a month by its number, 1-12 for January-December. 
  .getDisplayName(                    //Generate text of the name of the month automatically localized. 
      TextStyle.SHORT_STANDALONE ,    //Specify how long or abbreviated the name of month should be.
      new Locale( "es" , "MX" )       //Locale determines (a) the human language used in translation, and (b) the cultural norms used in deciding issues of abbreviation, capitalization, punctuation, and so on.
  )                                   //Returns a String.

java.time.Month

Beaucoup plus facile à faire maintenant, dans le java.les classes de temps qui permettent d'éviter ces pénibles ancien héritage de date-heure classes.

La Mois enum définit une douzaine d'objets, un pour chaque mois.

Les mois sont numérotés de 1 à 12 pour janvier-décembre.

Month month = Month.of( 2 );  //2 → February.

Demander à l'objet pour générer une Chaîne de la nom du mois, automatiquement localisé.

Ajuster la TextStyle pour spécifier comment long ou en abrégé que vous souhaitez que le nom. Notez que, dans certaines langues (l'anglais) le nom du mois varie lorsqu'il est utilisé seul ou en tant que partie d'une date complète. De sorte que chaque style de texte a un …_STANDALONE variante.

Spécifier un Locale à déterminer:

• De l'homme de la langue devant être utilisée dans la traduction.
• Ce que les normes culturelles doivent se prononcer sur des questions telles que les abréviations, la ponctuation et les majuscules.

Exemple:

Locale l = new Locale( "es" , "MX" );
String output = Month.FEBRUARY.getDisplayName( TextStyle.SHORT_STANDALONE , l );  //Or Locale.US, Locale.CANADA_FRENCH. 

---

Nom → Month objet

Pour info, en allant dans l'autre sens (de l'analyse d'un nom de chaîne de mois pour obtenir un Month enum objet) n'est pas intégré. Vous pouvez écrire votre propre classe pour le faire. Voici mon petit essai d'une telle classe. Utiliser à vos propres risques. J'ai donné ce code pas sérieux de la pensée, ni un sérieux test.

Utilisation.

Month m = MonthDelocalizer.of( Locale.CANADA_FRENCH ).parse( "janvier" ) ;  //Month.JANUARY

Code.

package com.basilbourque.example;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.time.Month;
import java.time.format.TextStyle;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
//For a given name of month in some language, determine the matching `java.time.Month` enum object.
//This class is the opposite of `Month.getDisplayName` which generates a localized string for a given `Month` object.
//Usage… MonthDelocalizer.of( Locale.CANADA_FRENCH ).parse( "janvier" ) → Month.JANUARY
//Assumes `FormatStyle.FULL`, for names without abbreviation.
//About `java.time.Month` enum: https://docs.oracle.com/javase/9/docs/api/java/time/Month.html
//USE AT YOUR OWN RISK. Provided without guarantee or warranty. No serious testing or code review was performed.
public class MonthDelocalizer
{
@NotNull
private Locale locale;
@NotNull
private List < String > monthNames, monthNamesStandalone; //Some languages use an alternate spelling for a “standalone” month name used without the context of a date.
//Constructor. Private, for static factory method.
private MonthDelocalizer ( @NotNull Locale locale )
{
this.locale = locale;
//Populate the pair of arrays, each having the translated month names.
int countMonthsInYear = 12; //Twelve months in the year.
this.monthNames = new ArrayList <>( countMonthsInYear );
this.monthNamesStandalone = new ArrayList <>( countMonthsInYear );
for ( int i = 1 ; i <= countMonthsInYear ; i++ )
{
this.monthNames.add( Month.of( i ).getDisplayName( TextStyle.FULL , this.locale ) );
this.monthNamesStandalone.add( Month.of( i ).getDisplayName( TextStyle.FULL_STANDALONE , this.locale ) );
}
//       System.out.println( this.monthNames );
//       System.out.println( this.monthNamesStandalone );
}
//Constructor. Private, for static factory method.
//Personally, I think it unwise to default implicitly to a `Locale`. But I included this in case you disagree with me, and to follow the lead of the *java.time* classes. --Basil Bourque
private MonthDelocalizer ( )
{
this( Locale.getDefault() );
}
//static factory method, instead of  constructors.
//See article by Dr. Joshua Bloch. http://www.informit.com/articles/article.aspx?p=1216151
//The `Locale` argument determines the human language and cultural norms used in de-localizing input strings.
synchronized static public MonthDelocalizer of ( @NotNull Locale localeArg )
{
MonthDelocalizer x = new MonthDelocalizer( localeArg ); //This class could be optimized by caching this object.
return x;
}
//Attempt to translate the name of a month to look-up a matching `Month` enum object.
//Returns NULL if the passed String value is not found to be a valid name of month for the human language and cultural norms of the `Locale` specified when constructing this parent object, `MonthDelocalizer`.
@Nullable
public Month parse ( @NotNull String input )
{
int index = this.monthNames.indexOf( input );
if ( - 1 == index )
{ //If no hit in the contextual names, try the standalone names.
index = this.monthNamesStandalone.indexOf( input );
}
int ordinal = ( index + 1 );
Month m = ( ordinal > 0 ) ? Month.of( ordinal ) : null;  //If we have a hit, determine the `Month` enum object. Else return null.
if ( null == m )
{
throw new java.lang.IllegalArgumentException( "The passed month name: ‘" + input + "’ is not valid for locale: " + this.locale.toString() );
}
return m;
}
//`Object` class overrides.
@Override
public boolean equals ( Object o )
{
if ( this == o ) return true;
if ( o == null || getClass() != o.getClass() ) return false;
MonthDelocalizer that = ( MonthDelocalizer ) o;
return locale.equals( that.locale );
}
@Override
public int hashCode ( )
{
return locale.hashCode();
}
public static void main ( String[] args )
{
//Usage example:
MonthDelocalizer monthDelocJapan = MonthDelocalizer.of( Locale.JAPAN );
try
{
Month m = monthDelocJapan.parse( "pink elephant" ); //Invalid input.
} catch ( IllegalArgumentException e )
{
//… handle error
System.out.println( "ERROR: " + e.getLocalizedMessage() );
}
//Ignore exception. (not recommended)
if ( MonthDelocalizer.of( Locale.CANADA_FRENCH ).parse( "janvier" ).equals( Month.JANUARY ) )
{
System.out.println( "GOOD - In locale "+Locale.CANADA_FRENCH+", the input ‘janvier’ parses to Month.JANUARY." );
}
}
}

---

Sur java.temps

La java.temps cadre est intégré dans Java 8 et les versions ultérieures. Ces classes permettent d'éviter la pénible vieux héritage date du temps des classes comme java.util.Date, Agenda, & SimpleDateFormat.

La Joda-Time projet, maintenant dans le mode de maintenance, conseille la migration vers le java.le temps classes.

Pour en savoir plus, consultez les Oracle Tutoriel. Et de recherche de Débordement de Pile pour de nombreux exemples et des explications. La spécification est JSR 310.

Vous pouvez échanger java.temps objets directement avec votre base de données. Utiliser un Pilote JDBC compatible avec JDBC 4.2 ou plus tard. Pas besoin de chaînes, pas besoin de java.sql.* classes.

Où obtenir le java.les classes de temps?

• Java SE 8, Java SE 9, et plus tard
  • Intégré.
  • Partie de la norme API Java avec une liasse de mise en œuvre.
  • Java 9 ajoute quelques fonctionnalités mineures et corrections.
• Java SE 6 et Java SE 7
  • Une grande partie de la java.fonction temps est de retour, porté à Java 6 & 7 dans ThreeTen-Backport.
• Android
  • Plus tard, des versions d'Android bundle implémentations de java.les classes de temps.
  • Antérieures d'Android (<26), le ThreeTenABP projet s'adapte ThreeTen-Backport (mentionné ci-dessus). Voir Comment utiliser ThreeTenABP....

La ThreeTen-Extra projet s'étend java.temps avec d'autres classes. Ce projet est un terrain d'essai pour de possibles futurs ajouts à java.temps. Vous pouvez trouver quelques classes utiles ici comme Intervalle, YearWeek, YearQuarter, et plus.

    public static void main(String[] args) {
SimpleDateFormat format = new SimpleDateFormat("MMMMM", new Locale("en", "US"));
System.out.println(format.format(new Date()));
}

Essayez d'utiliser cette façon très simple et l'appeler comme votre propre func

public static String convertnumtocharmonths(int m){
String charname=null;
if(m==1){
charname="Jan";
}
if(m==2){
charname="Fev";
}
if(m==3){
charname="Mar";
}
if(m==4){
charname="Avr";
}
if(m==5){
charname="Mai";
}
if(m==6){
charname="Jun";
}
if(m==7){
charname="Jul";
}
if(m==8){
charname="Aou";
}
if(m==9){
charname="Sep";
}
if(m==10){
charname="Oct";
}
if(m==11){
charname="Nov";
}
if(m==12){
charname="Dec";
}
return charname;
}