Samlingar i Java: ArrayList

1. ArrayListklass

Idag ska vi utforska ArrayListklassen. Detta är den första av flera klasser som kallas samlingar . I Java är samlingar ett så brett och användbart ämne att ett helt CodeGym-uppdrag ägnas åt dem.

För att till fullo förstå hur samlingar är uppbyggda och alla deras nyanser måste du först lära dig OOP, gränssnitt, arv, grunderna för multithreading och mycket mer.

Så idag ska vi bara bekanta oss med den enklaste sortens samling. Men på en tillräckligt djup nivå så att du förstår hur man använder den och hur den fungerar. Nu då, träffa ArrayListsamlingen .

Bakgrunden

Jag börjar med lite bakgrund. Programmerare gillade verkligen inte en aspekt av arrayer: det faktum att deras storlek inte kan ändras. Vad händer om du behöver lagra ytterligare tre element i en array, men det finns bara en tom cell?

Den enda lösningen på utrymmesbegränsningarna för en array var att skapa en mycket stor array för att rymma alla element du kan behöva lagra. Men detta var vanligtvis ett slöseri med minne. Om en array vanligtvis innehöll två eller tre element men det fanns till och med en liten chans att den skulle behöva lagra 100 av dem, då var det nödvändigt att skapa en array med kapacitet att lagra 100.

Så vad kom programmerare på? De skrev ArrayListklassen, som gjorde samma arbete som Arrayklassen, men som gick att ändra storlek på.

ArrayList klass

Namnet på ArrayListklassen är bildat av två ord: Array + List. Arrayär en array och Listär en lista.

Varje ArrayListobjekt innehåller en vanlig array av element. När du läser element från en ArrayList, hämtar objektet dem från sin interna array. När du skriver element, skriver den dem till den interna arrayen.

Klassen ArrayList saknar alla nackdelar som arrayer har. Den vet hur man:

• Lagra element av en specifik typ
• Ändra storleken på listan dynamiskt
• Lägg till element i slutet av listan
• Infoga element i början eller mitten av listan
• Ta bort element var som helst i listan

För mer information, se nedan:

2. Skapa ett ArrayListobjekt

För att skapa ett ArrayListobjekt måste du skriva kod så här:

ArrayList<TypeParameter> name = new ArrayList<TypeParameter>();

Var ArrayListär samlingstypen/klassen, TypeParameterär typen av element som lagras i ArrayListsamlingen och nameär namnet på en ArrayList<TypeParameter>variabel.

Variabeln namehar en generisk typ. Den består av två typer: typen av samlingen anges först, och sedan används vinkelparenteser för att indikera typen av element som lagras i samlingen.

Exempel:

ArrayList<Integer> list = new ArrayList<Integer>();

ArrayList<String> list = new ArrayList<String>();

ArrayList<Double> list = new ArrayList<Double>();

Till skillnad från arrayer kan samlingar inte lagra primitiva typer, bara referenstyper . Så om du behöver en samling ints, använd Integeromslagsklassen istället.

3. Operationer med enArrayList

Inledningsvis är längden på den nyskapade listan noll, eftersom den innehåller 0 element. Om du lägger till ett element i listan ökar dess längd med 1. Om du tar bort det tillagda elementet minskar längden tillbaka till noll.

Följande tabell kan lära dig mer om klassens metoder ArrayList:

void add(Type value)

void add(int index, Type value)

Type get(int index)

void set(int index, Type value)

Type remove(int index)

Type remove(Type value)

void clear()

boolean contains(Type value)

boolean isEmpty()

int size()

Type[] toArray(Type[] array)

Dessa metoder låter dig göra nästan allt du vill med listan: byta element, lägga till element och ta bort element. Du kan rensa listan med ett enda kommando, eller till och med konvertera listan till en array.

4. Jämförelse av ArrayListochArray

Jag tror inte att vi kan undvika att jämföra ArrayListoch en array.

Det finns bara 4 åtgärder du kan utföra med arrayer:

• Skapa en array
• Få ett element efter index
• Ställ in ett element efter index
• Få längden på arrayen

Här är dessa operationer som de gäller för en array och en ArrayList:

String[] array = new String[10];

ArrayList<String> list = new  ArrayList<String>();

String s = array[0];

String s = list.get(0);

array[0] = "Bye";

list.set(0, "Bye");

int count = array.length;

int count = list.size();

Låt oss jämföra hur en ArrayListfungerar mot hur en array fungerar. Låt oss till exempel implementera denna uppgift: "läs 10 strängar från tangentbordet och visa dem på skärmen i omvänd ordning"

Scanner console = new Scanner(System.in);

// Read strings from the keyboard
String[] list = new String[10];

for (int i = 0; i < list.length; i++)
{
    String s = console.nextLine();
    list[i] = s;
}

// Display the contents of the array on the screen
for (int i = 0; i < list.length; i++)
{
    int j = list.length - i - 1;
    System.out.println(list[j]);
}

Scanner console = new Scanner(System.in);

// Read strings from the keyboard
ArrayList<String> list = new ArrayList<String>();

for (int i = 0; i < 10; i++)
{
    String s = console.nextLine();
    list.add(s);
}

// Display the contents of the collection on the screen
for (int i = 0; i < list.size(); i++)
{
    int j = list.size() - i - 1;
    System.out.println(list.get(j));
}

Analogin är tydlig. Allt är på något sätt kortare och tydligare för arrayer. Men ArrayListdet är inte svårt heller: för att få ett element använder vi get()metoden; att ändra ett element, set()metoden; för att få längden på listan, size()metoden.

Så varför använder programmerare ArrayListklassen?

Hela poängen är naturligtvis alla andra metoder som vanliga arrayer inte har:

• Lägg till ett element i listan
• Lägg till ett element i mitten av listan
• Hitta ett element i listan
• Ta bort ett element från en lista