Java ArrayLijst

Hoi! In voorgaande lessen hebben we ons verdiept in arrays en veelvoorkomende voorbeelden van het werken met arrays besproken. In deze les gaan we dieper in op Java ArrayList. Over het algemeen zijn arrays superhandig. En, zoals je al gemerkt hebt, je kunt er veel mee doen :) Maar arrays hebben een aantal tekortkomingen.

• Beperkte maat. U moet weten hoeveel elementen uw array moet bevatten op het moment dat u deze maakt. Als je onderschat, heb je niet genoeg ruimte. Overschat, en de array blijft halfleeg, wat ook slecht is. Je wijst immers nog steeds meer geheugen toe dan nodig is.


• Een array heeft geen methoden om elementen toe te voegen. U dient altijd expliciet de index aan te geven van de positie waar u een element wilt toevoegen. Als u per ongeluk de index opgeeft voor een positie die wordt ingenomen door een waarde die u nodig hebt, wordt deze overschreven.


• Er zijn geen methoden om een ​​item te verwijderen. Een waarde kan alleen worden "op nul gezet".

public class Cat {

   private String name;

   public Cat(String name) {
       this.name = name;
   }

   public static void main(String[] args) {

       Cat[] cats = new Cat[3];
       cats[0] = new Cat("Thomas");
       cats[1] = new Cat("Behemoth");
       cats[2] = new Cat("Lionel Messi");

       cats[1] = null;

      
      
       System.out.println(Arrays.toString(cats));
   }

   @Override
   public String toString() {
       return "Cat{" +
               "name='" + name + '\'' +
               '}';
   }
}

Uitvoer: [Cat{name='Thomas'}, null, Cat{name='Lionel Messi'}] Gelukkig zijn de makers van Java zich terdege bewust van de voor- en nadelen van arrays en hebben daarom een ​​zeer interessante gegevensstructuur gemaakt met de naam Java ArrayList . Zo eenvoudig mogelijk gezegd, een Java ArrayList is een "opgevoerde" array met veel nieuwe functies.

Hoe maak je een ArrayList

Het is heel eenvoudig om te maken:

ArrayList<Cat> cats = new ArrayList<Cat>();

Nu hebben we een lijst gemaakt voor het opslaan van Cat- objecten. Merk op dat we de grootte van de ArrayList niet specificeren , omdat deze automatisch kan worden uitgebreid. Hoe is dit mogelijk? Het is eigenlijk heel simpel. Het zal je misschien verbazen, maar ArrayList in Java is gebouwd bovenop een heel gewone array :) Ja, het bevat een array en daar worden onze elementen opgeslagen. Maar ArrayList in Java heeft een speciale manier om met die array te werken:

• Wanneer de interne array gevuld is, maakt ArrayList intern een nieuwe array aan. De grootte van de nieuwe array is de grootte van de oude array maal 1,5 plus 1.


• Alle gegevens worden gekopieerd van de oude array naar de nieuwe


• De oude array wordt opgeruimd door de vuilnisman.

Met dit mechanisme kan Java ArrayList (in tegenstelling tot een gewone array) een methode implementeren voor het toevoegen van nieuwe elementen. Het is de add()methode

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<Cat>();
   cats.add(new Cat("Behemoth"));
}

Nieuwe items worden toegevoegd aan het einde van de lijst. Nu is er geen risico dat de array overloopt, dus deze methode is volkomen veilig. Trouwens, ArrayList kan niet alleen een object vinden via zijn index, maar ook vice versa: het kan een referentie gebruiken om de index van een object te vinden in de ArrayList ! Dit is waar de methode indexOf() voor is: we geven een verwijzing door naar het object dat we willen, en indexOf() retourneert de index:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   int thomasIndex = cats.indexOf(thomas);
   System.out.println(thomasIndex);
}

Uitvoer: 0 Dat klopt. Ons thomas- object is inderdaad opgeslagen in element 0. Arrays hebben niet alleen nadelen. Ze hebben ook onbetwistbare voordelen. Een daarvan is de mogelijkheid om elementen op index te zoeken. Omdat we naar een index verwijzen, dus naar een specifiek geheugenadres, gaat het op deze manier zoeken in een array erg snel. ArrayListweet ook hoe het moet! De methode get() implementeert dit:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   Cat secondCat = cats.get(1);

   System.out.println(secondCat);
}

Uitvoer: Cat{name='Behemoth'} Bovendien kunt u eenvoudig achterhalen of de ArrayList een bepaald object bevat. Dit wordt gedaan met behulp van de ArrayList comes() methode:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   cats.remove(fluffy);
   System.out.println(cats.contains(fluffy));
}

De methode controleert of de interne array van de ArrayList het element bevat en retourneert een booleaanse waarde (true of false). Uitvoer: false En nog iets belangrijks over insertie. Met ArrayList kunt u een index gebruiken om elementen in te voegen, niet alleen aan het einde van de array, maar overal. Het heeft hiervoor twee methoden:

• ArrayList add(int index, Cat-element)
• ArrayList -set (int-index, Cat-element)

Als argumenten nemen beide methoden de index van de positie waar u wilt invoegen, en een verwijzing naar het object zelf. Het verschil is dat het invoegen met set() de oude waarde overschrijft. Invoegen met behulp van add() verschuift eerst alle elementen met één van [index] naar het einde van de array en voegt vervolgens het opgegeven object toe aan de resulterende lege positie.

Hier is een voorbeeld:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);

   System.out.println(cats.toString());

   cats.set(0, lionel);// Now we have a list of 2 cats. Adding a 3rd using set

   System.out.println(cats.toString());
}

Uitvoer: [[Cat{name='Thomas'}, Cat{name='Behemoth'}] [Cat{name='Lionel Messi'}, Cat{name='Behemoth'}] We hadden een lijst met 2 katten . Vervolgens hebben we er nog een ingevoegd als element 0 met behulp van de set() methode. Hierdoor is het oude element vervangen door een nieuw.

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);

   System.out.println(cats.toString());

   cats.add(0, lionel);// Now we have a list of 2 cats. Adding a 3rd using add

   System.out.println(cats.toString());
}

En hier zien we dat add() anders werkt. Het verplaatst alle elementen naar rechts en schrijft de nieuwe waarde als element 0. Uitvoer: [Cat{name='Thomas'}, Cat{name='Behemoth'}] [Cat{name='Lionel Messi'}, Cat{name='Thomas'}, Cat{name='Behemoth'}] Om de lijst volledig leeg te maken, gebruiken we de clear() methode:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   cats.clear();

   System.out.println(cats.toString());
}

Uitvoer: [] Alles is uit de lijst verwijderd. Let trouwens op: in tegenstelling tot arrays, overschrijft ArrayList de toString() methode en geeft de lijst al correct weer als strings. Bij gewone arrays moesten we hiervoor de klasse Arrays gebruiken. En aangezien ik Arrays noemde : met Java kun je gemakkelijk "schakelen" tussen een array en een ArrayList , dwz de ene naar de andere converteren. De klasse Arrays heeft hiervoor een methode Arrays.asList() . We gebruiken het om de inhoud als een array te krijgen en deze door te geven aan onze ArrayList- constructor:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();


   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   Cat[] catsArray = {thomas, behemoth, lionel, fluffy};

   ArrayList<Cat> catsList = new ArrayList<>(Arrays.asList(catsArray));
   System.out.println(catsList);
}

Uitvoer: [Cat{name='Thomas'}, Cat{name='Behemoth'}, Cat{name='Lionel Messi'}, Cat{name='Fluffy'}] Je kunt ook in de tegenovergestelde richting gaan: krijg een array van een ArrayList- object. We doen dit met behulp van de toArray() methode:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();

   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   Cat[] catsArray = cats.toArray(new Cat[0]);

   System.out.println(Arrays.toString(catsArray));
}

Opmerking: we hebben een lege array doorgegeven aan de methode toArray() . Dit is geen fout. Binnen de klasse ArrayList is deze methode zo geïmplementeerd dat het doorgeven van een lege array de prestaties verhoogt. Houd dit in gedachten voor de toekomst (u kunt natuurlijk een array van een bepaalde grootte doorgeven; dat werkt ook). Oh, over de maat. De huidige grootte van de lijst kan worden gevonden met behulp van de size() methode:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();


   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   System.out.println(cats.size());
}

Het is belangrijk om te begrijpen dat, in tegenstelling tot de eigenschap length van een array , de methode ArrayList.size() het werkelijke aantal elementen retourneert, niet de oorspronkelijke capaciteit. We hebben tenslotte geen grootte opgegeven bij het maken van de ArrayList . U kunt het echter specificeren - ArrayList heeft een geschikte constructor. Maar in termen van het toevoegen van nieuwe elementen verandert dit niets aan het gedrag:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>(2);// create an ArrayList with an initial capacity of 2


   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   System.out.println(cats.size());
}

Console-uitvoer: 4 We hebben een lijst met 2 elementen gemaakt, maar deze is stilletjes uitgebreid wanneer dat nodig was. Een andere overweging is dat als we in eerste instantie een zeer kleine lijst maken, deze vaker zal moeten worden uitgebreid, wat enige middelen zal kosten. We hebben het proces van het verwijderen van elementen uit een ArrayList in deze les nauwelijks besproken. Dit is natuurlijk niet omdat het ons is ontgaan. We hebben dit onderwerp in een aparte les gestopt die je later zult ontmoeten :) Om te versterken wat je hebt geleerd, raden we je aan een videoles van onze Java-cursus te bekijken