Wat is een Java-lijst?

Java-lijsten zijn bijzonder geschikt voor scenario’s waarin de omvang van een dataset niet vanaf het begin duidelijk is of als verwacht wordt dat de omvang in de loop van de tijd zal ver­an­de­ren. We laten u spe­ci­fie­ke voor­beel­den zien van hoe u Java-lijsten kunt gebruiken en welke be­wer­kin­gen u ermee kunt uitvoeren.

Waarvoor kunnen Java-lijsten worden gebruikt?

Lijsten zijn een van de fun­da­men­te­le da­ta­struc­tu­ren in Java-pro­gram­me­ring en kunnen op ver­schil­len­de manieren worden gebruikt. Ze bevatten elementen die in een geordende volgorde zijn ge­rang­schikt. U kunt elementen aan een lijst toevoegen, wijzigen, ver­wij­de­ren of opvragen. Java-lijsten kunnen objecten bevatten die tot ver­schil­len­de klassen behoren. Het is ook mogelijk om dubbele elementen of null-elementen op te slaan. Bovendien on­der­steu­nen Java-lijsten generieke klassen en methoden, waardoor ty­pe­vei­lig­heid wordt ge­ga­ran­deerd.

Lijsten kunnen worden gebruikt voor da­ta­ba­setoe­pas­sin­gen. Hier worden ze gebruikt om grote datasets uit da­ta­ba­se­query’s op te slaan en te openen. In grafische ge­brui­kers­in­ter­fa­ces worden Java-lijsten vaak gebruikt om een lijst met elementen weer te geven, zoals opties in een ver­volg­keu­ze­me­nu of ver­schil­len­de artikelen in een online winkel.

Java-lijsten zijn ook onmisbaar in al­go­rit­men en da­ta­struc­tu­ren. Ze worden gebruikt in sor­teer­al­go­rit­men, zoe­kal­go­rit­men en stack- en queue-struc­tu­ren. In net­werk­toe­pas­sin­gen kunnen lijsten helpen bij het beheer van ver­bin­din­gen en sockets.

Welke lijst­me­tho­den heeft Java?

Java-lijsten behoren tot de Col­lec­ti­on-interface en moeten worden ge­ïm­por­teerd vanuit het pakket java.util. Met Java ArrayList, Lin­ked­List, Vector en Stack zijn er ver­schil­len­de im­ple­men­ta­tie­klas­sen waaruit u kunt kiezen. U kunt de ver­schil­len­de in­stan­ties van de lijsten de­cla­re­ren met de volgende code:

List linkedList = new LinkedList(); // LinkedList
List arrayList = new ArrayList(); // ArrayList
List vecList = new Vector(); // Vector
List stackList = new Stack(); //Stack

Hier zijn enkele van de be­lang­rijk­ste methoden die u kunt gebruiken voor Java-lijsten:

1. int size(): Bepaalt het aantal elementen in een lijst
2. void add(int index, E element): Voegt een element toe op een spe­ci­fie­ke positie
3. boolean isEmpty(): Con­tro­leert of een lijst leeg is
4. void clear(): Ver­wij­dert alle elementen uit een lijst
5. boolean contains(Object o): Geeft de waarde true terug als het object o in de lijst staat
6. boolean add(E e): Voegt een element toe aan het einde van een lijst
7. boolean remove(Object o): Ver­wij­dert het eerste exemplaar van een element
8. E get(int index): Vervangt of voegt een element toe op een opgegeven index
9. E set(int index, E element): Vervangt of voegt een element in op een opgegeven index
10. Object[] toArray(): Geeft een array terug met de elementen uit een lijst
11. List<E> subList(int fromIndex, int toIndex): Legt alle elementen binnen het opgegeven interval vast
12. default void replaceAll(UnaryOperator<E> operator): Stan­daard­me­tho­de in Java 8 die unaire Java-ope­ra­to­ren toepast op elk element en ver­vol­gens elk element vervangt door het resultaat van de bewerking.

Hoe Java-lijsten te gebruiken

Hieronder laten we veel­ge­bruik­te methoden zien die worden gebruikt bij het werken met Java-lijsten. Deze omvatten het omzetten van arrays naar lijsten en vice versa, evenals het sorteren, ophalen en wijzigen van elementen.

Een array omzetten in een lijst

Om een array om te zetten in een lijst, kun je de array doorlopen met behulp van loops en de elementen één voor één aan de lijst toevoegen met behulp van de add().

import java.util.*;
    public class ArrayToList{
      public static void main(String args[]){
      // Creating Array
      String[] colors={"blue","green","red","yellow"};
      System.out.println("Array: "+Arrays.toString(colors));
      //Converting Array to List
      List<String> list=new ArrayList<String>();
      for(String color: colors){
        list.add(color);
      }
      System.out.println("List: "+list);
      }
    }

Dit re­sul­teert in de volgende uitvoer:

Array: [blue, green, red, yellow]
List: [blue, green, red, yellow]

Een lijst omzetten in een array

Met methode toArray() kunt u een lijst omzetten in een array:

import java.util.*;
    public class ListToArray{
      public static void main(String args[]){
       List<String> days = new ArrayList<String>();
       days.add("Monday");
       days.add("Tuesday");
       days.add("Wednesday");
       days.add("Thursday");
       days.add("Friday");
       days.add("Saturday");
       days.add("Sunday");
       // Converting ArrayList to Array
       String[] array = days.toArray(new String[days.size()]);
       System.out.println("Array: "+Arrays.toString(array));
       System.out.println("List: "+days);
      }
    }

In de uitvoer kunt u zien dat de elementen in de array en de lijst identiek zijn:

Array: [Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday]
List: [Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday]

Elementen in een Java-lijst oproepen en wijzigen

Met de get() kunt u een element op een spe­ci­fie­ke index openen. Met de set() kunt u een element vervangen door een ander element op een bepaalde positie in de lijst.

import java.util.*;
    public class ListExample{
      public static void main(String args[]){
      // Creating a List
      List<String> letters=new ArrayList<String>();
      // Adding elements
      letters.add("a");
      letters.add("b");
      letters.add("c");
      // get()
      System.out.println("Element at index 1: "+letters.get(1));
      // set()
      letters.set(2, "d");
      for(String letter: letters)
      System.out.println(letter);
      }
    }

Aangezien het tellen in Java begint met index 0, krijgen we het volgende resultaat:

Element at index 1: b
a
b
d

Een lijst sorteren

Je kunt een Java-lijst sorteren met behulp van de methode .sort() uit de klasse Col­lec­ti­ons. Je kunt de lijst doorlopen met behulp van een lus en de elementen één voor één naar de console afdrukken:

import java.util.*;
    class SortArrayList{
      public static void main(String args[]){
      // Creating a list of numbers
      List<Integer> numbers=new ArrayList<Integer>();
      numbers.add(4);
      numbers.add(57);
      numbers.add(92);
      numbers.add(26);
      // Sorting
      Collections.sort(numbers);
      for(Integer number: numbers)
        System.out.println(number);
      }
    }

De getallen in de Java-lijst worden op het scherm weer­ge­ge­ven van klein naar groot:

4
26
57
92