Enumset
Enumset ist ein generischer Behälter des Java -Enum -Typs. Da Java sortiert, Treeset, Hashset und andere Behälter sortiert hat, warum braucht es dann eine zusätzliche Enumset <T>? Die Antwort ist, dass Enumset bestimmte Eigenschaften hat. Zum Beispiel ist Enumset sehr schnell. Ich werde nicht andere Funktionen einzeln auflisten, schließlich führt der Inhalt dieses Artikels nicht die Funktionen von Enumset ein.
Sammlungsklassen, die speziell für Aufzählungsklassen entwickelt wurden, müssen alle Elemente Aufzählungsarten sein
Die festgelegten Elemente von Enumset werden geordnet und intern von Bit -Vektoren gespeichert, sodass sie weniger Speicher belegen und eine hohe Effizienz haben.
Nullelemente sind nicht erlaubt
Quellcode
Paket java.util; sun.misc.sharedsecrets; öffentliche abstrakte Klasse enumset <e erweitert Enum <e >> erweitert AbstractSet <e> implementiert klonable, java.io.serializable { / *** Elementtyp* / endgültige Klasse <E> elementtype; / *** Speichern Elemente über Array*/ Final Enum [] Universum; private static enum [] Zero_Length_enum_array = new Enum [0]; EnumSet (class <E> elementtype, enum [] Universe) {this.elementtype = elementtype; this.universe = Universum; } /** * Create an empty enum set and formulate its element type* @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> noneOf(Class<E> elementType) { Enum[] universe = GetUniverse (Elementtype); if (Universe == null) werfen neue classcastexception (elementtype + "nicht ein enum"); if (Universe.Length <= 64) return neuer regelmäßiger RegularEnumset <> (elementtype, Universe); sonst geben Sie neue Jumboenumset <> (Elementtype, Universe) zurück; }/** * Erstellen Sie ein Enum, das alle Elemente im angegebenen Elementtyp set * * @param elementtype Das Klassenobjekt des Elementtyps für diesen Enum * Set * @Throws nullPointerexception, wenn <Tt> elementtype </tt> null */public static <e aus dem Ausumsatz <e> AllOf (klassifiziert <e> AllOf) (klassifiziert <e> AllOf) (klassifiziert <e> AllOf) (klassifiziert <e> AllOf) (klassifiziert <e> AllOf) (klassifiziert <e> AllOf) (klassifiziert <e> alle ofofsofsofs (class) (klassifiziert <e> alle) (classSet <e> AllOf) (klassifiziert <e> alle ofofsofs (class) (class) (classsset <e> alle ofofs (clies keine von (elementtype); result.addall (); Rückgabeergebnis; } /** * fügt alle Elemente aus dem entsprechenden Enum -Typ zu diesem Enum * -Set hinzu, das vor dem Anruf leer ist. */ abstrakt void addall (); /** * Erstellen Sie einen Enum -Set mit demselben Elementtyp wie der angegebene Enum -Set * * @param s Die enum -Set, von der dieses Enum -Set initialisiert wird. }/** * Erstellen Sie einen Enum -Set, aus dem dieses Enum -Set initialisiert wird copyof (collection <e> c) {if (c instanceof enumSet) {return ((enumSet <e>) c) .clone (); } else {if (c.Isempty ()) werfen neue illegalArgumentException ("Sammlung ist leer"); Iterator <e> i = C.Igerator (); E first = i.Next (); EnumSet <e> result = enumSet.of (zuerst); während (i.hasnext ()) result.add (i.Next ()); Rückgabeergebnis; }}/** * Erstellen Sie ein Enum, das aus dem Ergänzung zum Initialisieren dieses Enum -Sets erstellt wurde. result.complement (); Rückgabeergebnis; }/** * 1 Element Enumeration Collection * * @param e Das Element, das dieser Satz anfänglich enthalten soll. Noneof (E.GetdeclaringClass ()); result.add (e); Rückgabeergebnis; } / ** * 2 Element Enumeration Collection * * @param e1 Ein Element, das dieses Satz anfänglich enthalten soll EnumSet <E> result = NoneOf (e1.getDeclaringClass ()); result.add (e1); result.add (e2); Rückgabeergebnis; } / ** * 3 Element Enumeration Collection * * @param e1 Ein Element, das dieses Satz anfänglich enthalten soll * @param e2 Ein weiteres Element, das dieser Satz anfänglich enthalten soll * @param e3 Ein weiteres Element, das dieser Satz anfänglich enthält. von (e e1, e e2, e e3) {enumSet <e> result = NONEOF (e1.getDeclaringClass ()); result.add (e1); result.add (e2); result.add (e3); Rückgabeergebnis; } / ** * 4 Element Enumeration Set * @param e1 Ein Element, das dieses Satz anfänglich enthalten soll * @param e2 Ein weiteres Element, das dieser Satz anfänglich enthält * @param e3 Ein weiteres Element, das dieser Satz anfangs enthalten kann. <E erweitert Enum <e >> enumSet <e> von (e e1, e e2, e e3, e 4) {enumSet <e> result = NONEOF (e1.getDeclaringClass ()); result.add (e1); result.add (e2); result.add (e3); result.add (e4); Rückgabeergebnis; } /** * 5 Element Enumeration Collection * * @param e1 Ein Element, das dieser Satz anfänglich enthalten soll * @param e2 Ein weiteres Element, das dieser Satz anfänglich enthalten soll * @param e3 Ein weiteres Element, das dieser Satz anfänglich ist Enum -Set enthält zunächst die angegebenen Elemente */ öffentliches statisches <e erweitert Enum <e >> enumSet <e> von (e e1, e e2, e e3, e E4, e e5) {enumSet <e> result = Noneof (e1.getdeclaringklass ()); result.add (e1); result.add (e2); result.add (e3); result.add (e4); result.add (e5); Rückgabeergebnis; }/** * n * * @param zuerst ein Element, das der Satz anfänglich enthalten soll Enum <e >> enumSet <e> von (e zuerst, e ... rest) {enumSet <e> result = noneof (first.getDeclaringClass ()); result.add (zuerst); für (e e: rest) result.add (e); Rückgabeergebnis; } /** * Aufzählte Sammlung von Elementen im Bereich * @param vom ersten Element im Bereich * @param bis zum letzten Element im Bereich * @throws nullPoIterexception if {@Code von} oder {@Code bis} sind null * @throws illealArgument if { @@Code von @Code aus dem @Code von Contocling -Contoching -Contoching -Contoching (to). Der von den beiden angegebenen Endpunkten definierte */ public static <e erweitert Enum <e >> enumSet <e> Bereich (e von, e bis) {if (von.comPareto (bis)> 0). EnumSet <E> result = noneof (von.getDeclaringClass ()); result.addrange (von, bis); Rückgabeergebnis; } /** * fügt dem angegebenen Bereich diesem Enumsatz hinzu, der vor dem Anruf leer ist. */ Abstract void addrange (e von, e bis); /*** Gibt eine Kopie dieses Satzes zurück. * * @return eine Kopie dieses Satzes */ public enumSet <E> clone () {try {return (enumSet <E>) Super.clone (); } catch (clonenotsuptedEdException e) {neue Assertionerror (e) werfen; }} /*** ergänzt den Inhalt dieses Enumsatzes. */ Abstract void complement (); /*** löst eine Ausnahme aus, wenn E nicht der richtige Typ für diesen Enum -Satz ist. */ Finale void typecheck (e e) {class ecklass = e.getClass (); if (ecklass! = elementtype && ecklass.getSuperClass ()! } /** * Gibt alle Werte zurück, aus denen E. * Das Ergebnis wird nicht von allen Anrufern abgespeichert, zwischengespeichert und geteilt. */ private static <e erweitert Enum <e >> e [] GetUniverse (class <e> elementtype) {Retail SharedSecrets.getjavalangAccess () .GetEnumConstantSshared (elementtype); } /** * Diese Klasse wird verwendet, um alle Enumset -Instanzen zu serialisieren, unabhängig vom * Implementierungstyp. Es erfasst ihre "logischen Inhalte" und sie werden mit öffentlichen statischen Fabriken rekonstruiert. Dies ist notwendig *, um sicherzustellen, dass das Vorhandensein eines bestimmten Implementierungstyps * ein Implementierungsdetail ist. * * @serial include * / private statische Klasse SerializationProxy <e erweitert Enum <e >> implementiert java.io.serializable { / ** * Der Elementtyp dieses Enum -Satzes. * * @serial */ private endgültige Klasse <E> elementtype; /*** Die in diesem Enum -Satz enthaltenen Elemente. * * @serial */ private final Enum [] Elemente; SerializationProxy (enumSet <e> set) {elementtype = set.elementtype; Elements = set.toArray (Zero_Length_enum_array); } private Object ReadResolve () {enumSet <E> result = enumSet.noneof (elementtype); für (Enum E: Elemente) Ergebnis.Add ((e) e); Rückgabeergebnis; } Private statische endgültige lange Serialversionuid = 362491234563181265L; } Object WriteRepace () {Neue SerializationProxy <> (this); } // ReadObject -Methode für das Serialisierungs -Proxy -Muster // Siehe effektive Java, Second. Hrsg., Item 78. Der private void ReadObject (java.io.objectinputStream Stream) löst java.io.invalidObjectexception {Wurf neu java.io.invalidobjektexception ("Proxyexy); }}Zusammenfassen
Bei dem obigen dreht sich alles um das Lesen des enumset abstrakten Quellcode, und ich hoffe, er wird für alle hilfreich sein. Interessierte Freunde können weiterhin auf andere verwandte Themen auf dieser Website verweisen. Wenn es Mängel gibt, hinterlassen Sie bitte eine Nachricht, um darauf hinzuweisen. Vielen Dank an Freunde für Ihre Unterstützung für diese Seite!