Enumeta
Enumset es un contenedor genérico del tipo Java Enum. Dado que Java tiene sortedset, TreeSet, Hashset y otros contenedores, ¿por qué necesita un enumset adicional <T>? La respuesta es que Enumset tiene ciertas características. Por ejemplo, enumset es muy rápido. No enumeraré otras características una por una, después de todo, el contenido de este artículo no introduce las características de Enumset.
Clases de recolección diseñadas específicamente para clases de enumeración, todos los elementos deben ser tipos de enumeración
Los elementos establecidos de Enumset se ordenan y se almacenan internamente por vectores de bits, por lo que ocupan menos memoria y tienen alta eficiencia.
No se permiten elementos nulos
Código fuente
paquete java.util; import sun.misc.sharedsecrets; public abstract class enumset <e extiende enum <E>> extiende abstractSet <E> implementa clonable, java.io.Serializable { / *** Tipo de elemento* / clase final <E> elementtype; / *** Almacene los elementos a través de la matriz*/ final enum [] universo; Enum estático privado [] cero_length_enum_array = new enum [0]; Enumset (class <E> ElementType, enum [] universo) {this.elementType = elementType; this.universe = universo; }/** * Cree un conjunto de enumes vacío y formule su tipo de elemento * @param elementType El objeto de clase del tipo de elemento para este enum * set * @throws nullPointerException si <TT> elementType </tt> es null */public static <e extiende enum <E>> enumset <e> nofer (class <e> ElementTiMe) {ENUME) getuniverse (elementtype); if (universe == null) tirar nueva classcastException (elementtype + "no un enum"); if (universe.length <= 64) return nuevo regularenumset <> (elementtype, universe); else return new Jumboenumset <> (elementType, universo); }/** * Cree un enum que contenga todos los elementos en el tipo de elemento especificado SET * * @param ElementType el objeto de clase del tipo de elemento para este enum * set * @throws nullPointerException if <tt> elementType </tt> es null */public static <e se extiende enum <e>> enumset <e> AllOf (class <e> ElementType) No de (ElementType); resultado.addall (); resultado de retorno; } /** * Agrega todos los elementos del tipo de enumación apropiado a este conjunto enum *, que está vacío antes de la llamada. */ abstract void addall (); /** * Cree un conjunto de enum con el mismo tipo de elemento que el conjunto de enum especificado * * * @param s el conjunto enum para inicializar este conjunto de enum * @throws nullPointerException if <tt> s </tt> es null */public static <e extiende enum <e>> enumset <e> copyOf (enumset <e> s) {return s.clone (); } /** * Create an enum set from which to initialize this enum set * @throws IllegalArgumentException if <tt>c</tt> is not an * <tt>EnumSet</tt> instance and contains no elements * @throws NullPointerException if <tt>c</tt> is null */ public static <E extends Enum<E>> EnumSet<E> copyOf(Collection<E> c) {if (c instanciaf enumset) {return ((enumset <e>) c) .clone (); } else {if (c.isempty ()) tirar nueva ilegalargumentException ("la colección está vacía"); Iterador <E> i = c.iterator (); E primero = I.Next (); Enumset <E> resultado = enumset.of (primero); while (i.hasnext ()) resultado.Add (I.Next ()); resultado de retorno; }}/** * Crear un conjunto enum de cuyo complemento para inicializar este conjunto de enum * @throws nullPointerException if <tt> s </tt> es nulo */public static <e extiende enum <e>> enumset <e> complementof (enumset <e> s) {enumset <e> dutur = copyOf (s); resultado.complement (); resultado de retorno; }/** * 1 elemento colección de enumeración * * @param e El elemento que este conjunto debe contener inicialmente * @throws nullPointerException si <Tt> e </tt> es null * @return un conjunto enum que contiene inicialmente el elemento especificado */public static <E se extiende enum <E>> enumset <e> de (e e) {enumset <e> dulte = resultado = = resultado = nof (E.getDeclaringClass ()); resultado.Add (e); resultado de retorno; } / ** * 2 Elemento Enumeration Collection * * @param e1 Un elemento que este conjunto debe contener inicialmente * @param e2 otro elemento que este conjunto debe contener inicialmente * @throws nullPointerException si algún parámetros es nulo * @return un conjunto de enum que contiene inicialmente los elementos especificados * / public static <e extiende enume <e>> enumset <e> de (e e1 inicialmente. Enumset <E> resultado = nof (e1.getDeclaringClass ()); resultado.Add (E1); resultado.Add (E2); resultado de retorno; } /** * 3 element enumeration collection* * @param e1 an element that this set is to contain initially * @param e2 another element that this set is to contain initially * @param e3 another element that this set is to contain initially * @throws NullPointerException if any parameters are null * @return an enum set initially containing the specified elements */ public static <E extends Enum<E>> EnumSet<E> de (e e1, e e2, e e3) {enumset <e> result = nof (e1.getDeclaringClass ()); resultado.Add (E1); resultado.Add (E2); resultado.Add (E3); resultado de retorno; } / ** * 4 elementos enumeración conjunto * @param e1 Un elemento que este conjunto debe contener inicialmente * @param e2 otro elemento que este conjunto debe contener inicialmente * @param e3 otro elemento que este conjunto debe contener inicialmente * @param e4 otro elemento que este conjunto es para contener inicialmente * @throws nullPointerException si algún parámetro es null * @@return un set de statats spectialmente. <E extiende enum <e>> enumset <E> de (E E1, E E2, E E3, E E4) {enumset <E> result = nof (e1.getDeclaringClass ()); resultado.Add (E1); resultado.Add (E2); resultado.Add (E3); resultado.Add (E4); resultado de retorno; } /** * 5 Elementos Enumeración de la colección * * @param e1 Un elemento que este conjunto debe contener inicialmente * @param e2 otro elemento que este conjunto debe contener inicialmente * @param e3 otro elemento que este conjunto debe contener inicialmente * @param e4 otro elemento que este conjunto debe contener inicialmente * @param e5 otro elemento que este conjunto es inicialmente * @throws nullPointerexception si cualquier parámetro es inicial Conjunto de enum que contiene inicialmente los elementos especificados */ public static <e extiende enum <e>> enumset <E> de (E E1, E E2, E E3, E E4, E E5) {enumset <e> result = nof (e1.getDeclaringClass ()); resultado.Add (E1); resultado.Add (E2); resultado.Add (E3); resultado.Add (E4); resultado.Add (E5); resultado de retorno; }/** * n * * @param primero un elemento que el conjunto debe contener inicialmente * @param REST los elementos restantes El conjunto debe contener inicialmente * @throws nullPointerException Enum <e>> enumset <E> de (e primero, e ... repente) {enumset <e> result = nof (first.getDeclaringClass ()); resultado.Add (primero); para (E E: REST) Result.Add (e); resultado de retorno; } /** * colección de elementos enumerados en el rango * @param desde el primer elemento en el rango * @param hasta el último elemento en el rango * @throws nullPointerException si {@code de} o {@code to} son null * @throws ilegalarGumention de {@code de.compareto (to)> 0} * @@return an enumnem de un enume de los elementos inicialmente de los elementos. El rango * definido por los dos puntos finales especificados */ public static <e extiende enum <e>> enumset <e> range (e from, e to) {if (from.compareto (a)> 0) arrojar una nueva AgumentAxception (de + ">" + a); Enumset <E> resultado = nof (from.getDeclaringClass ()); resultado.Addrange (de, a); resultado de retorno; } /** * Agrega el rango especificado a este conjunto de enum, que está vacío anterior * a la llamada. */ abstracto nulo addRange (e from, e to); /*** Devuelve una copia de este conjunto. * * @return una copia de este conjunto */ public enumset <E> clone () {try {return (enumset <E>) super.clone (); } catch (clonenotsupportedException e) {tirar nueva afirmaciónRor (e); }} /*** complementa el contenido de este conjunto enum. */ abstract void complement (); /*** Lanza una excepción si E no es del tipo correcto para este conjunto de enum. */ Final void typecheck (e e) {class eclass = e.getClass (); if (eclass! = elementtype && eclass.getSuperClass ()! = ElementType) Throw New ClassCastException (Eclass + "! =" + ElementType); } /** * Devuelve todos los valores que comprenden E. * El resultado no se aclaza, almacena en caché y comparte todas las personas que llaman. */ privado static <e extiende enum <e>> e [] getuniverse (class <E> ElementType) {return SharedSecrets.getJavalangaccess () .getenumConstantsShared (elementType); } /** * Esta clase se usa para serializar todas las instancias de enumset, independientemente del tipo de implementación *. Captura sus "contenidos lógicos" y * se reconstruyen utilizando fábricas estáticas públicas. Esto es necesario * para garantizar que la existencia de un tipo de implementación particular sea * un detalle de implementación. * * @Serial incluye * / private static class serializationProxy <e extiende enum <e>> implementa java.io.serializable { / ** * El tipo de elemento de este conjunto de enum. * * @Serial */ Private Final Class <E> ElementType; /*** Los elementos contenidos en este conjunto enum. * * @Serial */ Elementos privados finales []; SerializationProxy (enumset <E> set) {elementType = set.ElementType; elements = set.toarray (cero_length_enum_array); } objeto privado readResolve () {enumset <e> result = enumset.noneOf (elementType); para (enum e: elementos) resultado.Add ((e) e); resultado de retorno; } Private Static final Long SerialVersionUid = 362491234563181265l; } Object WriterePlace () {return New SerializationProxy <> (this); } // Método ReadObject para el patrón de proxy de serialización // Ver Java efectivo, segunda ed., Elemento 78. Private void ReadObject (java.io.objectInputStream stream) arroja java.io.invalidObjectException {tirar nueva java.io.invalidObjectException ("requerido proxy");; }}Resumir
Lo anterior se trata de leer el código fuente de Enumset Abstract, y espero que sea útil para todos. Los amigos interesados pueden continuar referiéndose a otros temas relacionados en este sitio. Si hay alguna deficiencia, deje un mensaje para señalarlo. ¡Gracias amigos por su apoyo para este sitio!