Énum
Enumset est un conteneur générique de type d'énumération Java. Étant donné que Java a trié, arrenet, hashset et autres conteneurs, pourquoi a-t-il besoin d'un énum supplémentaire <T>? La réponse est que l'énumaire a certaines caractéristiques. Par exemple, Enumset est très rapide. Je ne répertorierai pas les autres fonctionnalités une par une, après tout, le contenu de cet article ne présente pas les fonctionnalités d'Enumset.
Cours de collecte conçus spécifiquement pour les cours d'énumération, tous les éléments doivent être des types d'énumération
Les éléments définis de l'énumaire sont commandés et sont stockés en interne par bit, ils occupent donc moins de mémoire et ont une efficacité élevée.
Les éléments nuls ne sont pas autorisés
Code source
Package Java.util; Import Sun.Misc.SharedSecrets; Public Abstract Class Enumset <e étend enum <e>> étend AbstractSet <e> implémente Clonable, Java.io.Serializable {/ ** * Type d'élément * / Classe finale <e> ElementType; / ** * Stockez les éléments via le tableau * / Univers final Enum []; enum statique privé [] zero_length_enum_array = new enum [0]; EnumSet (class <e> elementType, enum [] univers) {this.elementType = elementType; this.universe = univers; } / ** * Créez un ensemble d'énumération vide et formulez son type d'élément * @param elementType L'objet de classe du type d'élément pour cet enum * set * @throws nullpointerException if <tt> elementType </tt> est null * / public static <e étend enum <e>> enumset <e> null (class <e> elementType) {énum [] universe = univers getUniverse (elementType); if (Universe == null) lancez une nouvelle classe classcastException (élémentType + "pas un enum"); if (Universe.Length <= 64) Renvoie un nouveau régulière RELALORYENUMSET <> (ElementType, Universe); else return new JumboenumSet <> (elementType, Universe); } /** * Create an enum containing all elements in the specified element type set * * @param elementType the class object of the element type for this enum * set * @throws NullPointerException if <tt>elementType</tt> is null */ public static <E extends Enum<E>> EnumSet<E> allOf(Class<E> elementType) { EnumSet<E> result = nulof (elementType); résultat.addall (); Résultat de retour; } / ** * Ajoute tous les éléments du type d'énumération approprié à cet ensemble d'énumération *, qui est vide avant l'appel. * / abstract void addall (); / ** * Créer un ensemble d'énumération avec le même type d'élément que l'ensemble d'énumération spécifié * * @param s L'ensemble d'énumération à partir de laquelle initialiser cet ensemble d'énumération * @throws nullpointerException if <tt> s </tt> est null * / public static <e étend enum <e>> enumset <e> copyof (enumset <e> s) {return s.clone (); } / ** * Créez un ensemble d'énumération à partir de laquelle initialiser cet ensemble d'énumération * @Throws illégalArgumentException if <tt> c </tt> n'est pas une instance * <tt> enumset </tt> et ne contient aucun éléments * @throws nullpointerException si <tt> c </tt> n'est pas nul * / public statique <e extends étendus énum <e> ENUMSET <e> e> copyof (collection <e> c) {if (c instanceof enumset) {return ((enumset <e>) c) .clone (); } else {if (c.isempty ()) lance un nouveau illégalargumentException ("la collection est vide"); Iterator <e> i = c.iterator (); E premier = i.next (); Enumset <e> result = enumset.of (premier); while (i.hasnext ()) result.add (i.next ()); Résultat de retour; }} / ** * Créez un ensemble d'énumération à partir du complément de qui initialise cet ensemble d'énumération * @throws nullpointerException if <tt> s </tt> est null * / public static <e étend enum <e>> enumset <e> complémentof (enumset <e> s) {enumset <e> result = copyof (s); result.Compation (); Résultat de retour; } / ** * 1 élément Collection d'énumération * * @param e L'élément que cet ensemble doit contenir initialement * @throws nullpointerException si <tt> e </ tt> est null * @return un ensemble d'énumération contenant initialement l'élément spécifié * / public static <e étend enum <e>> ENUMSET <e> de (e e) {enumset non (e.getDeclaredClass ()); résultat.add (e); Résultat de retour; } / ** * Collection d'énumération de 2 éléments * * @param e1 Un élément que cet ensemble est de contenir initialement * @param e2 Un autre élément que cet ensemble est de contenir initialement * @throws nullpointerException si des paramètres sont nuls * @return un ensemble d'énumération contenant initialement les éléments spécifiés * / Public Static <e étend enum <e>> Enumet <e> Enumset <e> result = non-of (e1.getDeclaredClass ()); résultat.Add (E1); résultat.Add (E2); Résultat de retour; } / ** * Collection d'énumération de 3 éléments * * @param e1 Un élément que cet ensemble est de contenir initialement * @param e2 Un autre élément que cet ensemble est de contenir initialement * @param e3 Un autre élément que cet ensemble est de contenir initialement * @throws nullpointerException si des paramètres sont nuls * @return un ensemble ennum Initialement contenant les éléments spécifiés * / / STATIQUE publique <e éruption de (E E1, E E2, E E3) {Enumset <e> result = non-of (e1.getDecLaringClass ()); résultat.Add (E1); résultat.Add (E2); résultat.add (E3); Résultat de retour; } / ** * Ensemble d'énumération à 4 éléments * @param e1 Un élément que cet ensemble doit contenir initialement * @param e2 Un autre élément que cet ensemble doit contenir initialement * @param e3 Un autre élément que cet ensemble est de contenir initialement * @param e4 un autre élément que cet ensemble doit contenir initialement * @throws nullpointerexception si des paramètres sont nuls * @rern <E étend enum <e>> enumset <e> de (e e1, e e2, e e3, e e4) {enumset <e> result = nonof (e1.getDeclagingClass ()); résultat.Add (E1); résultat.Add (E2); résultat.add (E3); résultat.Add (E4); Résultat de retour; } / ** * Collection d'énumération à 5 éléments * * @param e1 Un élément que cet ensemble doit contenir initialement * @param e2 Un autre élément que cet ensemble doit contenir initialement * @param e3 un autre élément que cet ensemble est de contenir initialement * @param e4 un autre élément que cet ensemble doit contenir initialement * @param e5 E5 un autre élément que cet ensemble doit contenir * @Throws nullpointer ENUM Set contenant initialement les éléments spécifiés * / public statique <e étend enum <e>> enumset <e> de (e e1, e e2, e e3, e e4, e e5) {enumset <e> result = nonof (e1.getDeclatingClass ()); résultat.Add (E1); résultat.Add (E2); résultat.add (E3); résultat.Add (E4); Result.Add (E5); Résultat de retour; } / ** * n * * @param D'abord un élément que l'ensemble doit contenir initialement * @param reposer les éléments restants que l'ensemble doit contenir initialement * @throws nullpointerException si l'un des éléments spécifiés est null, * ou si <tt> repos </ tt> est null * @return Public Static <e extension contenant les éléments spécifiés * / @safargs Enum <e>> enumset <e> de (e d'abord, e ... rest) {enumset <e> result = nonoof (first.getDeclaringClass ()); résultat.add (premier); pour (e e: repos) result.add (e); Résultat de retour; } / ** * Collection énumérée d'éléments dans la gamme * @param du premier élément de la gamme * @param au dernier élément de la gamme * @throws nullpointerException si {@code from} ou {@code to} est null * @throws illégalargumentException if {@code from .....untel Dans la gamme * définie par les deux points de terminaison spécifiés * / public static <e étend enum <e>> énumset <e> gamme (e from, e to) {if (from.compareto (to)> 0) lancent un nouveau illégalargumentException (de + ">" + à); Enumset <e> result = non-of (from.getDecLaringClass ()); résultat.addrange (de, à); Résultat de retour; } / ** * Ajoute la plage spécifiée à cet ensemble d'énumération, qui est vide avant * à l'appel. * / abstrait void addRange (e de, e à); / ** * Renvoie une copie de cet ensemble. * * @return une copie de cet ensemble * / public enumset <e> clone () {try {return (enumset <e>) super.clone (); } catch (clonenotsupportedException e) {lancer une nouvelle assertionError (e); }} / ** * complète le contenu de cet ensemble d'énumération. * / Abstract void complément (); / ** * lance une exception si E n'est pas du type correct pour cet ensemble d'énumération. * / final void tyPecheck (e e) {class eclass = e.getClass (); if (eclass! = elementType && eclass.getsuperclass ()! = elementType) lancez new classCastException (eclass + "! =" + elementType); } / ** * Renvoie toutes les valeurs comprenant E. * Le résultat n'est pas affligé, mis en cache et partagé par tous les appelants. * / Private Static <e étend enum <e>> e [] getUniverse (class <e> elementType) {return sharedsecrets.getjavalangaccess () .geTenumConstantsShared (elementType); } / ** * Cette classe est utilisée pour sérialiser toutes les instances Enumset, quel que soit le type d'implémentation *. Il capture leur "contenu logique" et ils * sont reconstruits à l'aide d'usines statiques publiques. Ceci est nécessaire * pour s'assurer que l'existence d'un type de mise en œuvre particulier est * un détail d'implémentation. * * @Serial Inclure * / Classe statique privée SerializationProxy <E étend enum <e>> implémente java.io.serializable {/ ** * Le type d'élément de cet ensemble d'énumération. * * @Serial * / Private Final Class <E> ElementType; / ** * Les éléments contenus dans cet ensemble d'énumérage. * * @Serial * / Éléments privés finaux []; SerializationProxy (enumset <e> set) {elementType = set.ElementType; elements = set.toArray (zero_length_enum_array); } objet privé ReadResolve () {enumSet <e> result = enumSet.NoneOf (élémentType); pour (enum e: éléments) résultat.add ((e) e); Résultat de retour; } private statique final long serialversionUID = 362491234563181265l; } Objet writeRereplace () {return new SerializationProxy <> (this); } // Méthode ReadObject pour le modèle de proxy de sérialisation // Voir Effective Java, Second Ed., Item 78. Private void readObject (java.io.objectInputStream Stream) lève Java.io.invalidobjectexception {throw new Java.io.invalidObjectException ("Proxy requis"); }}Résumer
Ce qui précède consiste à lire le code source abstrait ENUMSET, et j'espère que cela sera utile à tout le monde. Les amis intéressés peuvent continuer à se référer à d'autres sujets connexes sur ce site. S'il y a des lacunes, veuillez laisser un message pour le signaler. Merci vos amis pour votre soutien pour ce site!