Collecties in Java: ArrayList

1. ArrayListklasse

Vandaag gaan we de ArrayListklas verkennen. Dit is de eerste van verschillende klassen die collecties worden genoemd . In Java zijn verzamelingen zo'n breed en nuttig onderwerp dat er een hele CodeGym-zoektocht aan is gewijd.

Om volledig te begrijpen hoe verzamelingen zijn gestructureerd en al hun nuances, moet u eerst OOP, interfaces, overerving, de basisprincipes van multithreading en nog veel meer leren.

Dus vandaag maken we gewoon kennis met de eenvoudigste verzameling. Maar op een voldoende diep niveau zodat u begrijpt hoe u het moet gebruiken en hoe het werkt. Maak kennis met de ArrayListcollectie .

Het achtergrondverhaal

Ik zal beginnen met een beetje achtergrond. Programmeurs hielden echt niet van één aspect van arrays: het feit dat hun grootte niet kan worden gewijzigd. Wat als u nog drie elementen in een array moet opslaan, maar er is slechts één lege cel?

De enige oplossing voor de ruimtebeperkingen van een array was het maken van een zeer grote array om alle elementen die u nodig zou kunnen hebben op te slaan. Maar dit was meestal een verspilling van geheugen. Als een array gewoonlijk twee of drie elementen bevat, maar er ook maar een kleine kans is dat er 100 moeten worden opgeslagen, dan is het nodig om een ​​array te maken met een capaciteit om er 100 op te slaan.

Dus wat hebben programmeurs bedacht? Ze schreven de ArrayListklas, die hetzelfde werk deed als de Arrayklas, maar waarvan de grootte kon worden aangepast.

ArrayList-klasse

De naam van de ArrayListklasse bestaat uit twee woorden: Array + List. Arrayis een array en Listis een lijst.

Elk ArrayListobject bevat een gewone reeks elementen. Wanneer u elementen uit een leest ArrayList, haalt het object ze op uit zijn interne array. Wanneer u elementen schrijft, schrijft het ze naar de interne array.

De klasse ArrayList mist alle nadelen die arrays hebben. Het weet hoe:

• Bewaar elementen van een specifiek type
• Pas de grootte van de lijst dynamisch aan
• Voeg elementen toe aan het einde van de lijst
• Voeg elementen in aan het begin of midden van de lijst
• Verwijder elementen overal in de lijst

Zie hieronder voor meer informatie:

2. Een ArrayListobject maken

Om een ArrayList​​object te maken, moet je code als volgt schrijven:

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

Waar ArrayListis het verzamelingstype/klasse, TypeParameteris het type elementen dat in de ArrayListverzameling is opgeslagen en nameis de naam van een ArrayList<TypeParameter>variabele.

De namevariabele heeft een generiek type. Het bestaat uit twee typen: eerst wordt het type verzameling aangegeven en vervolgens worden punthaken gebruikt om het type elementen aan te geven dat in de verzameling is opgeslagen.

Voorbeelden:

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

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

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

In tegenstelling tot arrays kunnen verzamelingen geen primitieve typen opslaan, alleen referentietypen . Dus als je een verzameling ints nodig hebt, gebruik Integerdan de wrapper-klasse.

3. Operaties met eenArrayList

Aanvankelijk is de lengte van de nieuw gemaakte lijst nul, aangezien deze 0 elementen bevat. Als u één element aan de lijst toevoegt, neemt de lengte met 1 toe. Als u het toegevoegde element verwijdert, wordt de lengte teruggebracht tot nul.

De volgende tabel kan u meer leren over de methoden van de ArrayListklas:

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)

Met deze methoden kunt u bijna alles doen wat u maar wilt met de lijst: elementen verwisselen, elementen toevoegen en elementen verwijderen. U kunt de lijst wissen met een enkele opdracht of de lijst zelfs converteren naar een array.

4. Vergelijking van ArrayListenArray

Ik denk niet dat we vergelijken ArrayListen een array kunnen vermijden.

Er zijn slechts 4 acties die u kunt uitvoeren met arrays:

• Maak een matrix
• Krijg een element per index
• Stel een element per index in
• Verkrijg de lengte van de array

Hier zijn deze bewerkingen zoals ze van toepassing zijn op een array en een 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();

Laten we vergelijken hoe een ArrayListwerkt versus hoe een array werkt. Laten we bijvoorbeeld deze taak implementeren: "lees 10 strings van het toetsenbord en geef ze in omgekeerde volgorde weer op het scherm"

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));
}

De analogie is duidelijk. Alles is op de een of andere manier korter en duidelijker voor arrays. Maar ArrayListis ook niet moeilijk: om een ​​element te krijgen gebruiken we de get()methode; om een ​​element te veranderen, de set()methode; om de lengte van de lijst te krijgen, de size()methode.

Dus waarom gebruiken programmeurs de ArrayListklasse?

Het hele punt zijn natuurlijk alle andere methoden die gewone arrays niet hebben:

• Voeg een element toe aan de lijst
• Voeg een element toe aan het midden van de lijst
• Zoek een element in de lijst
• Een element uit een lijst verwijderen