Méthode Java Enum valueOf() (avec exemples)

La classe enum est incluse dans le package java.lang. C'est la classe de base universelle pour tous les types d'énumération du langage Java. La méthode valueOf de la classe Java Enum est utilisée pour récupérer. Les constantes Enum sont déclarées dans les types Enum en donnant une chaîne ou en convertissant String en constantes Enum.

La fonction valueOf() de la classe Enum renvoie la constante enum du type enum spécifié avec le nom spécifié.

Syntaxe Java Enum valueOf()

public static > T valueOf(Class enumType,String name)

Paramètres

T : La constante obtenue est du type enum.

enumType – L'objet Class du type enum renvoie une constante.

nom – Il renverra le nom de la constante.

Valeur du retour

La constante enum est renvoyée avec le nom défini par la méthode valueOf().

Lances

La fonction valueOf() lève l'exception suivante :

Si le type d'énumération défini est incohérent avec le nom spécifié, ou si l'objet de classe défini n'illustre pas un type d'énumération, une IllegalArgumentException est levée. Si la valeur de enumType ou name est null, une NullPointerException est levée.

enum Companies{  
  
IBM, Amazon, Google, Facebook, Twitter;  
  
}  
  
public class Enum_valueOfTechCompanies {  
  
public static void main(String[] args) {  
  
System.out.println("What is the name of the company:");  
  
for( Companies comp : Companies.values()){  
  
int i = part.ordinal()+1;  
  
System.out.println(i+" "+comp);  
  
        }  
  
      Companies comp = Companies.valueOf("IBM");  
  
System.out.println("\nAns: "+comp);  
  
       }  
}

Exemple :enum sur les langages de programmation

enum Languages{  
  
Python, Java, JavaScript, C, Kotlin;  
  
}  
  
public class Enum_valueOfProgrammingLanguage {  
  
public static void main(String[] args) {  
  
System.out.println("Choose your programming languages:");  
  
for( Languages planguage : Languages.values()) {  
  
System.out.println(Languages.valueOf(" "));  
  
        }  
  
    }  
  
}

}

Comme on peut le voir, Enum est une classe abstraite. Par conséquent, nous ne pouvons pas générer d'objets Enum.

Méthodes de classe Enum

La classe Enum a dix méthodes essentielles. La classe Object remplace la majorité d'entre eux. La classe Enum déclare ces méthodes comme finales, empêchant le programmeur de modifier les constantes enum.

nom final de la chaîne()

Cette fonction renvoie le nom de cette constante enum, qui est identique à la déclaration enum.

La syntaxe est la suivante :

public final String name()

public final String name()

// program  demonstrating the name() method
enum Cities
{
	London, New York, Manchester;
}

public class nameTest
{

	public static void main(String[] args)
	{
		Cities cityName = Cities.Manchester;
		System.out.print("enum's constant is: ");

		// method's name
		System.out.println(cityName .name());
	}
}

final int ordinal()

Cette méthode renvoie l'indice de cette constante d'énumération. ordinal int final() :

La syntaxe est la suivante :

public final int ordinal()

// program  demonstrating the ordinal() method
enum Cities
{
	London, New York, Manchester;
}

public class ordinalTest
{
	// Driver method
	public static void main(String[] args)
	{
		Cities cOrdinal = Cities.London;
		System.out.print("ordinal of enum constant "+cOrdinal .name()+" : ");

		// ordinal method
		System.out.println(cOrdinal .ordinal());
	}
}

Chaîne àChaîne()

String toString() renvoie un objet String représentant cette constante d'énumération. Cette méthode est identique à la méthode name().

La syntaxe est la suivante :

// program  demonstrating the toString() method
enum Cities
{
	London, New York, Manchester;
}

public class toStringTest
{
	// Driver method
	public static void main(String[] args)
	{
		Cities cString = Cities.GREEN;
		
		// fetch string representation of enum
		// using toString() method
		String strCities = Cities.toString();
		
		System.out.println(strCities);
	}
}

le booléen final est égal à (Objet obj)

boolean final equals(Object obj) :si l'objet fourni est égal à cette constante enum, cette fonction renvoie true ; sinon, il renvoie faux.

La syntaxe est la suivante :

public final boolean equals(Object obj)

// program  demonstrating the equals() method
enum Cities
{
	London, Austin, Manchester;
}

public class equalsTest
{

	public static void main(String[] args)
	{
		Cities cOne = Cities.London ;
		Cities cTwo = Cities.Austin ;
		Cities cThree = Cities.Manchester ;
		
		// equality checking between enums
		// using equals() method
		
		boolean bOne = cOne.equals(cTwo);
		boolean bTwo = cOne.equals(cThree);
		boolean bThree = cTwo.equals(null);
		
		System.out.println("is cOne equal to cTwo : " + bOne);
		System.out.println("is cOne equal to cThree : " + bTwo);
		System.out.println("is cTwo equal to null : " + bThree);
	}
}

code de hachage int final()

Cette méthode renvoie un code de hachage pour cette constante enum. Cette méthode renvoie un code de hachage pour cette constante enum. En fait, cette fonction ne comprend qu'une seule instruction :"return super.hashCode()", qui appelle la méthode hashCode() de la classe Object.

La syntaxe est la suivante :

public final int hashCode()

public final int hashCode()

// program  demonstrating the hashCode() method
enum Cities
{
	London, Austin, Manchester;
}

public class hashCodeTest
{

	public static void main(String[] args)
	{
		Cities cOne = Cities.RED;
		System.out.print("hashcode of enum constant "+ cOne.name() +" : ");

		// hashcode method
		System.out.println(cOne.hashCode());
		
		Cities cTwo = Cities.GREEN;
		System.out.print("hashcode of enum constant "+ cTwo.name() +" : ");

		// hashcode method
		System.out.println(cTwo.hashCode());
	}
}

final int compareTo(E obj)

Cette méthode « compare » l'ordre de cette énumération avec l'objet fourni. Seules les autres constantes enum du même type enum peuvent être comparées à des constantes enum.

La syntaxe de compareTo est la suivante :

public int compareTo(E obj)

// program  demonstrating the compareTo() method
enum Cities
{
	London, Austin, Manchester;
}

public class Test
{
	// Driver method
	public static void main(String[] args)
	{
		Cities cOne = Cities.RED;
		Cities cTwo = Cities.GREEN;
		Cities cThree = Cities.RED;
		Cities cFour = Cities.BLUE;
		
		System.out.print("Comparing "+cOne.name()+" with "+ cTwo.name() +" : ");
		
		// compareTo method
		System.out.println(cOne.compareTo(cTwo));
		
		System.out.print("Comparing "+cOne.name()+" with "+ cThree.name() +" : ");
		
		// compareTo method
		System.out.println(cOne.compareTo(cThree));
		
		System.out.print("Comparing "+cFour.name()+" with "+ cTwo.name() +" : ");
		
		// compareTo method
		System.out.println(cFour.compareTo(cTwo));
		
		// The following statement throw NullPointerException
		// as argument of compareTo method is null
		// System.out.println(cFour.compareTo(null));
		
	}
}

static T valueOf(Class enumType,String name)

Cette fonction renvoie le nom de la constante enum du type enum fourni. Un identifiant utilisé pour déclarer une constante enum dans ce type doit correspondre exactement au nom.

La syntaxe est la suivante :

public static T valueOf(Class enumType,String name)

// program  demonstrating the valueOf() method
enum Cities
{
	London, Austin, Manchester;
}
public class valueOfTest
{

	public static void main(String[] args)
	{
		// getting value of enum with specified String
		// using valueOf method
		Cities cOne = Cities.valueOf("London");
		Cities cTwo = Cities.valueOf("Austin");
		
		// name method
		System.out.println(cOne.name());
		System.out.println(cTwo.name());
		
		// The following statement throw IllegalArgumentException
		// as LoNDON is not an enum constant
		// Cities cThree = Cities.valueOf("LoNDON");
		
		// The following statement throw NullPointerException
		// as argument of valueOf method is null
	// Cities cFour = Cities.valueOf(null);
	}
}

Classe finale getDeclaringClass()

Cette fonction renvoie l'objet Class pour le type enum de cette constante enum. Si cette fonction renvoie le même objet Class pour les deux constantes enum e1 et e2, elles sont du même type enum.

La syntaxe est la suivante :

public final Class getDeclaringClass()

// program  demonstrating the getDeclaringClass() method
enum Cities
{
	London, Austin, Manchester;
}

enum Month
{
	JANUARY, FEBRUARY ;
}

public class getDeclaringClassTest
{
	// Driver method
	public static void main(String[] args)
	{
		// getting value of enum with specified String
		// using valueOf method
		Cities c1 = Cities.valueOf("London");
		Cities c2 = Cities.valueOf("Austin");
		Month mOne = Month.valueOf("JANUARY");
		Month mTwo = Month.valueOf("FEBRUARY");
		
		System.out.print("Class corresponding to "+ c1.name() +" : ");
	
		// getDeclaringClass method
		System.out.println(cOne.getDeclaringClass());
		
		System.out.print("Class corresponding to "+ cTwo.name() +" : ");
		
		// getDeclaringClass method
		System.out.println(cTwo.getDeclaringClass());
		
		System.out.print("Class corresponding to "+ mOne.name() +" : ");
		
		// getDeclaringClass method
		System.out.println(mOne.getDeclaringClass());
		
		System.out.print("Class corresponding to "+ mTwo.name() +" : ");
		
		// getDeclaringClass method
		System.out.println(mTwo.getDeclaringClass());
	}
}

clone d'objet final()

Cette fonction garantit que les énumérations ne sont jamais clonées, ce qui est nécessaire pour les conserver "singleton". Il est utilisé par le compilateur pour générer des constantes Enum.

La syntaxe est la suivante :

public final Object clone() throws CloneNotSupportedException

// program  demonstrating the clone() method
enum Cities
{
	London, Austin, Manchester;
}

public class cloneTest
{
	// Driver method
	public static void main(String[] args)
			throws CloneNotSupportedException
	{
		System.out.println("Enums are never cloned");
		cloneTest tClone = new cloneTest()
		{
			// final clone method
			protected final Object clone()
					throws CloneNotSupportedException
			{
				return new CloneNotSupportedException();
			}
		};
		
		System.out.println(tClone.clone());
	}
}

final void finalize()

Les classes Enum ne peuvent pas avoir la méthode finalize, selon cette méthode.

La syntaxe est la suivante :

protected final void finalize()

// program  demonstrating the finalize() method
enum Cities
{
	London, Austin, Manchester;
}

public class finalizeTest
{

	public static void main(String[] args) throws Throwable
	{
		System.out.println("enum classes cannot have finalize methods");
		finalizeTest tVal = new finalizeTest()
		{
			// final finalize method
			protected final void finalize() throws Throwable
			{
				// empty implementation
			};		
		};
	}
}

Conclusion

Nous avons exploré comment utiliser la méthode valueOf en Java dans cet exemple Java Enum valueOf. Étant donné que chaque énumération de Java étend de manière inhérente java.lang, la méthode valueOf est disponible pour toutes les énumérations Java. Enum est un type de classe. La méthode enum valueOf reçoit la chaîne exacte utilisée pour déclarer la constante Enum et renvoie cette constante Enum. IllegalArgumentException est levée si la méthode valueOf renvoie une chaîne non valide.