Hvad er en Java-liste?

Java-lister er særligt velegnede til scenarier, hvor stør­rel­sen af et datasæt ikke er klar fra starten, eller hvis stør­rel­sen forventes at ændre sig over tid. Vi viser dig konkrete eksempler på, hvordan du bruger Java-lister, samt de ope­ra­tio­ner, du kan udføre med dem.

Hvad kan Java-lister bruges til?

Lister er en af de grund­læg­gen­de da­ta­struk­tu­rer i Java-pro­gram­me­ring og kan bruges på mange for­skel­li­ge måder. De in­de­hol­der elementer, der er ar­ran­ge­ret i en bestemt ræk­ke­føl­ge. Du kan tilføje, ændre, slette eller søge efter elementer i en liste. Java-lister kan indeholde objekter, der tilhører for­skel­li­ge klasser. Det er også muligt at gemme dup­li­ke­re­de elementer eller null-elementer. Derudover un­der­støt­ter Java-lister generiske klasser og metoder, hvilket sikrer ty­pe­sik­ker­hed.

Lister kan bruges til da­ta­ba­se­ap­pli­ka­tio­ner. Her bruges de til at gemme og få adgang til store datasæt fra da­ta­ba­se­søg­nin­ger. I grafiske bru­ger­græn­se­fla­der bruges Java-lister ofte til at vise en liste over elementer, såsom valg­mu­lig­he­der i en rullemenu eller for­skel­li­ge varer i en on­li­ne­bu­tik.

Java-lister er også uund­vær­li­ge i al­go­rit­mer og da­ta­struk­tu­rer. De bruges i sor­te­rings­al­go­rit­mer, sø­ge­al­go­rit­mer og stak- og kø­struk­tu­rer. I net­værks­ap­pli­ka­tio­ner kan lister hjælpe med at lette ad­mi­ni­stra­tio­nen af for­bin­del­ser og sokler.

Hvilke liste­me­to­der har Java?

Java-lister tilhører Col­lection-græn­se­fla­den og skal im­por­te­res fra pakken java.util. Med Java ArrayList, Lin­ked­List, Vector og Stack er der for­skel­li­ge im­ple­men­te­rings­klas­ser, du kan vælge imellem. Du kan deklarere de for­skel­li­ge fo­re­kom­ster af listerne med følgende kode:

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

Her er nogle af de vigtigste metoder, du kan bruge til Java-lister:

1. int size(): Bestemmer antallet af elementer i en liste
2. void add(int index, E element): Tilføjer et element på en bestemt position
3. boolean isEmpty(): Kon­trol­le­rer, om en liste er tom
4. void clear(): Fjerner alle elementer fra en liste
5. boolean contains(Object o): Re­tur­ne­rer værdien true, hvis objektet o er i listen
6. boolean add(E e): Tilføjer et element til slut­nin­gen af en liste
7. boolean remove(Object o): Fjerner det første forekomst af et element
8. E get(int index): Erstat eller indsæt et element ved et angivet indeks
9. E set(int index, E element): Erstat eller indsæt et element ved et angivet indeks
10. Object[] toArray(): Re­tur­ne­rer en matrix, der in­de­hol­der ele­men­ter­ne fra en liste
11. List<E> subList(int fromIndex, int toIndex): Fanger alle elementer inden for det angivne interval
12. default void replaceAll(UnaryOperator<E> operator): Stan­dard­me­to­de i Java 8, der anvender unære Java-ope­ra­to­rer på hvert element og derefter erstatter hvert element med re­sul­ta­tet af ope­ra­tio­nen.

Sådan bruges Java-lister

Nedenfor viser vi al­min­de­li­ge metoder, der bruges, når man arbejder med Java-lister. Disse omfatter kon­ver­te­ring af arrays til lister og omvendt, samt sortering, hentning og ændring af elementer.

Konverter en matrix til en liste

For at kon­ver­te­re en matrix til en liste kan du gentage matrixen ved hjælp af sløjfer og tilføje ele­men­ter­ne til listen et ad gangen ved hjælp af metoden 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);
      }
    }

Dette re­sul­te­rer i følgende output:

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

Konverter en liste til en matrix

Med metode toArray() kan du kon­ver­te­re en liste til en matrix:

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

I outputtet kan du se, at ele­men­ter­ne i arrayet og listen er identiske:

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

Opkald og ændring af elementer i en Java-liste

Med metoden get() kan du få adgang til et element ved et bestemt indeks. Metoden set() giver dig mulighed for at erstatte et element med et andet element på en bestemt position i listen.

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

Da tællingen i Java starter med indeks 0, får vi følgende resultat:

Element at index 1: b
a
b
d

Sorter en liste

Du kan sortere en Java-liste ved hjælp af metoden .sort() fra klassen Col­lections. Du kan gen­nem­lø­be listen ved hjælp af en løkke og udskrive ele­men­ter­ne til konsollen et efter et:

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

Tallene i Java-listen vises på skærmen fra det mindste til det største:

4
26
57
92

95991e50aeda50c32cb3b3f2112a5943