Das System.Collections.ArrayList -Klasse ist ein spezielles Array. Durch Hinzufügen und Entfernen von Elementen kann die Länge des Arrays dynamisch geändert werden.
eins. Vorteil
1. unterstützt die Funktion zur automatischen Größenänderung
2. Flexible Einfügung von Elementen
3.. Flexible Löschung von Elementen
zwei. Einschränkung
Im Vergleich zu normalen Arrays ist die Geschwindigkeit etwas schlechter
drei. Elemente hinzufügen
1.. PublicVirtualIntadd (ObjectValue);
Fügen Sie Objekt zum Ende der ArrayList hinzu
ArrayList alist = new ArrayList (); alist.add ("a"); alist.add ("b"); alist.add ("c"); alist.add ("d"); alist.add ("e");Der Inhalt ist
Abcde
2. publicVirtualvoidInsert (intindex, ObjectValue);
Fügen Sie das Element in den angegebenen Index der ArrayList ein
ArrayList alist = new ArrayList (); alist.add ("a"); alist.add ("b"); alist.add ("c"); alist.add ("d"); alist.add ("e"); alist.insert (0, "aa");Das Ergebnis ist
aaabcde
3.. PublicVirtualvoidinSertrange (intindex, icollectionc);
Fügen Sie ein Element in die Sammlung in den angegebenen Index der ArrayList ein
ArrayList alist = new ArrayList (); alist.add ("a"); alist.add ("b"); alist.add ("c"); alist.add ("d"); alist.add ("e"); arrayList list2 = newarraylist (); list2.add ("tt");Das Ergebnis ist
ABTTTTTCDE
Vier. löschen
1.. PublicVirtualvoidRemove (ObjectObj);
Entfernen Sie die erste Übereinstimmung eines bestimmten Objekts aus einer ArrayList, beachten Sie, dass es das erste ist
ArrayList alist = new ArrayList (); alist.add ("a"); alist.add ("b"); alist.add ("c"); alist.add ("d"); alist.add ("e"); alist.remove ("a");Das Ergebnis ist
BCDE
2. publicvirtualvoidremoveat (intindex);
Entfernt Elemente im angegebenen Index der ArrayList
alist.add ("a"); alist.add ("b"); alist.add ("c"); alist.add ("d"); alist.add ("e"); alist.removeat (0);Das Ergebnis ist
BCDE
3.. PublicVirtualvoidremoverange (intindex, intCount);
Entfernt eine Reihe von Elementen aus der ArrayList. Der Index repräsentiert den Index, die Anzahl zeigt die Nummer, die aus dem Index beginnt
alist.add ("a"); alist.add ("b"); alist.add ("c"); alist.add ("d"); alist.add ("e"); alist.removerange (1,3);Das Ergebnis ist
Kopieren Sie den Code wie folgt: ae
4. PublicVirtualvoidClear ();
Entfernen Sie alle Elemente von ArrayList.
fünf. Sortieren
1.PublicvirtualvoidSort ();
Sortieren Sie Elemente in einer Arraylist oder einem Teil davon.
ArrayListalist = newArrayList (); alist.add ("e"); alist.add ("a"); alist.add ("b"); alist.add ("c"); alist.add ("d");Das Ergebnis ist
eabcd
ArrayListalist = newArrayList (); alist.add ("a"); alist.add ("b"); alist.add ("c"); alist.add ("d"); alist.add ("e"); alist.sort (); // sortieren dropdownlist1.dataSource = alist;Das Ergebnis ist
Abcde
2.PublicvirtualvoidReverse ();
Umkehrt die Reihenfolge der Elemente in einer Arraylist oder einem Teil davon.
ArrayListalist = newArrayList (); alist.add ("a"); alist.add ("b"); alist.add ("c"); alist.add ("d"); alist.add ("e"); alist.reverse (); // reverse dropdownlist1.datasource = alist;Das Ergebnis ist
EDCBA
sechs. Finden
1.PublicVirtualIntIndexof (Objekt);
2.PublicVirtualIntIndexof (Objekt, int);
3.PublicVirtualIntIndexof (Objekt, int, int);
Gibt den Null-basierten Index der ersten Übereinstimmung einer ArrayList oder eines Teils davon zurück. Es wurde keine Rückkehr -1 gefunden.
ArrayList alist = new ArrayList (); alist.add ("a"); alist.add ("b"); alist.add ("c"); alist.add ("D"); alist.add ("e"); intnindex = alist.indexof ("a"); // 1 nindex = alist.indexof ("p"); // nicht gefunden, -1 4.PublicVirtualIntLastIndexof (Objekt);
5.PublicVirtualIntLastIndexof (Objekt, int);
6.PublicVirtualIntLastIndexof (Objekt, int, int);
Gibt den Null-basierten Index der letzten Übereinstimmung einer ArrayList oder eines Teils davon zurück.
ArrayList alist = new ArrayList (); alist.add ("a"); alist.add ("b"); alist.add ("a"); // gleich wie 0 alist.add ("D"); alist.add ("e"); intnindex = alist.lastindexof ("a"); // Der Wert beträgt 2 anstelle von 0 7.PublicVirtualBoolContains (ObjektIntem);
Bestimmt, ob sich ein Element in einer ArrayList befindet. Geben Sie true zurück, wenn eingeschlossen, andernfalls fälschen Sie falsch zurück
Sieben. andere
1. publicVirtualIntCapacity {get; set;}
Erhält oder legt die Anzahl der Elemente fest, die eine ArrayList enthalten kann.
2. publicVirtualIntCount {get;}
Erholt die Anzahl der in der ArrayList enthaltenen Elemente.
Kapazität ist die Anzahl der Elemente, die eine Arraylist speichern kann. Die Anzahl ist die Anzahl der in der ArrayList enthaltenen Elemente. Die Kapazität ist immer größer oder gleich dem Zählen. Wenn die Anzahl die Kapazität beim Hinzufügen eines Elements überschreitet, wird die Kapazität der Liste durch automatische Neuverglastung des internen Arrays verdoppelt.
Wenn der Kapazitätswert explizit festgelegt ist, muss das interne Array auch neu zugewiesen werden, um die angegebene Kapazität aufzunehmen. Wenn die Kapazität explizit auf 0 festgelegt wird, setzt die gemeinsame Sprachlaufzeit sie auf die Standardkapazität. Die Standardkapazität beträgt 16.
Nach dem Aufrufen von Clear beträgt Count 0 und zu diesem Zeitpunkt ist die Kapazitätskürzung die Standardkapazität von 16, nicht 0
3.. PublicVirtualvoidtrimtosize ();
Setzen Sie die Kapazität auf die tatsächliche Anzahl von Elementen in der ArrayList.
Wenn Sie der Liste keine neuen Elemente hinzufügen, kann diese Methode verwendet werden, um den Speichersystem -Overhead der Liste zu minimieren.
Um alle Elemente in der Liste vollständig zu löschen, rufen Sie die Klare Methode auf, bevor Sie TrimTosize aufrufen. Durch das Abschneiden einer leeren ArrayList wird die Kapazität der ArrayList auf die Standardkapazität festgelegt, nicht auf Null.
ArrayList alist = new ArrayList (); alist.add ("a"); alist.add ("b"); alist.add ("c"); alist.add ("d"); alist.add ("e"); // count = 5, Kapazität = 16, alist.trimtosize (); // capact = 5; 8. Quellcodeanalyse
Eine Implementierungsklasse der List -Schnittstelle verwendet intern ein Array, um Elementwerte zu speichern, was einem Array variabler Größe entspricht.
1. Signatur
Public Class ArrayList <E> erweitert AbstractList <E> implementiert die Liste <E>, randomaccess, klonbar, serialisierbar
Sie können sehen, dass ArrayList die Abstract -Klasse der AbstractList erbt, die die meisten Methoden der Listenschnittstelle implementiert. Wenn Sie eine unveränderliche Liste implementieren möchten, erben Sie einfach diese Klasse und implementieren Sie die Methoden GET (INT) und Größen. Wenn Sie eine veränderliche Liste implementieren möchten, müssen Sie SET (int, e) überschreiben. Wenn die Größe der Liste variabel ist, müssen die Methoden hinzufügen (int, e) und REME () ebenfalls überschrieben werden.
2. Konstruktor
ArrayList bietet drei Konstruktoren:
ArrayList () ArrayList (Sammlung <? Erweitert E> C) ArrayList (intit initialCapacity)
Die Konvention der Sammlungsschnittstelle, dass jede Sammlungsklasse zwei "Standard" -Konstruktoren bereitstellen sollte, einer Konstruktor ohne Parameter (der erste oben) und der andere ein Konstruktor mit einem einzelnen Parameter (der zweite oben). ArrayList bietet außerdem einen dritten Konstruktor, der einen int -Wert akzeptiert, um die anfängliche Größe von Arrayli festzulegen (die Standardgröße beträgt 10).
3. verwandte Methoden
trimTosizepublic void trimTosize () {modcount ++; int oldCapacity = elementData.length; if (Größe <OldCapacity) {elementData = arrays.copyof (elementData, Größe); }}Wird verwendet, um die Kapazität der ArrayList auf die aktuelle tatsächliche Größe zu reduzieren und die Speicherkapazität zu verringern. Der variable Modcount wird von der AbstractList geerbt, wodurch die Häufigkeit der Liste strukturell geändert wird. Das Element der ArrayList wird tatsächlich in ElementData gespeichert, was als: private transientes Objekt [] elementData deklariert wird; Die variable Größe ist die Anzahl der Elemente der ArrayList. Wenn die Größe <alte Kapazität die Arrays.Copyof -Methode aufrufen, um eine Reduzierung zu erreichen.
4.Indexof und lasindexof
public int indexof (objekt o) {if (o == null) {für (int i = 0; i <size; i ++) if (elementData [i] == null) return i; } else {für (int i = 0; i <size; i ++) if (o.equals (elementData [i]) return i; } return -1; }Diese beiden Methoden geben das Index des angegebenen Elements zurück, und wir möchten unterscheiden, ob der Parameter null ist. LastInDexof ähnelt dem Index, aber von hinten nach vorne zu suchen.
5. Sicherungssuecapacity
public void Seesecapacity (int mincapacity) {if (mincapacity> 0) sealecapacityInternal (mincapacity); } private void tealecapacityInternal (int mincapacity) {modcount ++; // überlaufbewusster Code if (mincapacity - elementData.length> 0) wachsen (minkapazität); } private void Grow (int mincapacity) {// Überlauf-unbewusster Code int oldCapacity = elementData.length; int newCapacity = OldCapacity + (OldCapacity >> 1); if (newcapacity - mincapacity <0) newCapacity = mincapacity; if (newcapacity - max_array_size> 0) newCapacity = Hugcapacity (mincapacity); // Hackigkeit liegt normalerweise nahe an der Größe, daher ist dies ein Gewinn: elementData = arrays.copyof (elementData, Newcapacity); }Diese Methode sorgt für die Größe der ArrayList
6.Add und Addall
public void add (int index, e element) {rangecheckForAdd (Index); sealEcapacityInternal (Größe + 1); // Inkrementiert modcount !! System.ArrayCopy (ElementData, Index, ElementData, Index + 1, Größe - Index); elementData [index] = element; Größe ++; } Add (int Index, E -Element), um der angegebenen Position ein Element hinzuzufügen. RangecheckForAdd rufen Sie zunächst an, ob der Index gültig ist. Wenn Index> Größe || Index <0, eine Ausnahme wird ausgelöst. Stellen Sie dann sicher, dass die Kapazität um 1 erhöht wird, und rufen Sie das System auf. Setzen Sie schließlich den Wert auf den Index auf das hinzugefügte Element. Es gibt auch eine überlastete Methode (E E), die das Element direkt zum Ende hinzufügt.
AddAll (Sammlung <? Erweitert E> C) und AddAll (int Index, Sammlung <? Erweitert E> C) Fügen Sie alle Elemente in der Sammlung zum Ende bzw. die angegebenen Positionen hinzu.
7.Remove und removealll
public boolean remove (Objekt o) {if (o == null) {for (int index = 0; index <size; index ++) if (elementData [index] == null) {fastremove (index); zurückkehren; }} else {for (int index = 0; index <size; index ++) if (o.equals (elementData [index])) {fastremove (index); zurückkehren; }} return false; }Die Methode entfernen (Objekt O) löscht das angegebene Element. Suchen Sie zuerst nach dem Elementort und rufen Sie anschließend Fastremove (Index) an, um ihn zu löschen. Der Code ist wie folgt:
private void fastremove (int index) {modcount ++; int nummoved = Größe - Index - 1; if (nummoved> 0) // Verschieben Sie alle Elemente hinter Index+1 Ein Positionswechselsystem. ElementData [-Größe] = NULL; // GC seine Arbeit erledigen} Mit der überlasteten Entfernung (int Index) Methode werden Elemente an der angegebenen Stelle gelöscht. Removerange (int vonIndex, int toIdex) wird verwendet, um alle Elemente zwischen den angegebenen Stellen zu löschen.
REMOVELL (COLLECATION <?> C) und Retainall (Collection <?> C) Codes sind wie folgt:
public boolean removeall (Sammlung <?> c) {Objects.requirenonnull (c); return batchremove (c, false); } public boolean retainall (Sammlung <?> c) {Objects.requirenonnull (c); return batchremove (c, true); }Sie alle werden implementiert, indem sie die BatchRemove -Methode aufrufen, und ihr Code lautet wie folgt:
private boolean batchremove (Sammlung <?> c, boolean komplement) {Final Object [] elementData = this.elementData; int r = 0, w = 0; boolean modified = false; try {for (; r <size; r ++) if (c.contains (elementData [r]) == komplement) elementData [w ++] = elementData [r]; } endlich {// Verhaltenskompatibilität mit AbstractCollection erhalten, auch wenn c.contains () ausgelöst wird. if (r! = Größe) {System.ArrayCopy (elementData, r, elementData, w, Größe - r); W += Größe - R; } if (w! = size) {// klare, um gc seine Arbeit für (int i = w; i <size; i ++) elementData [i] = null; ModCount += Größe - W; Größe = W; modified = true; }} return modifiziert; }Diese Methode hat zwei Parameter. Die erste ist die Betriebserfassung und die zweite ist ein boolescher Wert. Indem es es auf True oder False einstellt, wird es ausgewählt, ob es entfernt oder behalten werden soll. In der Anweisung im Versuch wird die verbleibenden zwischen 0 und w und schließlich die zweite, wenn in den Raum nach W umgeht, und die erste wird ausgeführt, wenn C.Contains () eine Ausnahme ausgelöst hat.