Java >> Java tutorial >  >> Tag >> ArrayList

ArrayList i Java med eksempler

ArrayList i java ligner et array, bortset fra at der ikke er nogen størrelsesbegrænsning i ArrayList. ArrayList er dynamisk og tillader derfor tilføjelse og fjernelse af elementer når som helst. Dog er elementerne i en ArrayList gemt i indsættelsesrækkefølgen. En ArrayList er ikke synkroniseret og kan også gemme objekter, der indeholder null-værdier.

ArrayList er implementeringen af ​​listen Interface fundet i java.util pakke. Listen udvider samlingsgrænsefladen, som praktikant udvider den iterable grænseflade.
En grænseflade er en samling abstrakte metoder. Du kan ikke oprette forekomster af en abstrakt metode.

Forudsætning

For at få en klar forståelse af ArrayList vil det være en stor fordel først at forstå Arrays. Kend forskellen mellem endimensionelle og todimensionelle arrays, ved, hvordan man opretter, får adgang til, tilføjer elementer, fjerner og også går gennem array-elementerne. Antag dog, at du ikke har denne viden, men du behøver ikke at gå i panik, da vi vil gøre denne tutorial så enkel som muligt, selv for begyndere. Lad os grave ind i ArrayList i java.

Funktioner i Java ArrayList

  • ArrayList bruger en indeksbaseret struktur i java.
  • En ArrayList kan gemme duplikerede elementer.
  • ArrayList kan ændres størrelse; derfor kan du formindske og øge dens størrelse.
  • En ArrayList er ikke synkroniseret.
  • Den har en vilkårlig adgangsegenskab, da vi kan hente, indstille, fjerne og indsætte elementer i arrayet fra enhver vilkårlig position.
  • Det er muligt at tilføje null-elementer i en ArrayList.
  • Elementer er sorteret i rækkefølgen af ​​indsættelse.
  • Dens ydeevne er langsom på grund af meget skift, når du fjerner et element fra en ArrayList.

Forskellen mellem en Array og en ArrayList

I et array kan dets størrelse ikke ændres, og det betyder, at hvis du ønsker at tilføje eller fjerne elementer fra arrayet, skal du oprette et nyt. I en ArrayList kan dens størrelse ændres; derfor kan du tilføje og fjerne elementer når som helst du ønsker det.

Oprettelse af en ArrayList

Det første punkt at bemærke er, at hver gang du skal oprette en arrayList, skal du først java.util.arrayList pakke.
Eksempel:

import java.util.ArrayList;

Lad os nu oprette en ArrayList af objekter kaldet bærbare computere, der vil gemme strenge af navne på bærbare mærker.

package javaarraylist;
import java.util.ArrayList;
public class JavaArrayList {
    public static void main(String[] args) 
    {
     ArrayList <String> laptops = new ArrayList <String>();
    }   
}

I ovenstående eksempel indeholder ArrayList bærbare objekter af typen String, en ikke-primitiv type. Vi kan også oprette en ArrayList til at indeholde andre primitive typer objekter såsom heltal, boolesk, tegn og dobbelt.
Eksempel :

package javaarraylist;
import java.util.ArrayList;
public class JavaArrayList {
    public static void main(String[] args) 
    {
     ArrayList <Character> A = new ArrayList <Character>();
     ArrayList <Integer> numbers = new ArrayList <Integer>();
     ArrayList <Double> doubleArrayList = new ArrayList <Double>();
    }
}

Fordelen ved at specificere typen såsom en streng eller et heltal er, at hvis du prøver at tilføje en anden type, giver det en kompileringsfejl. Nedenfor er en anden metode til at oprette en ArrayList ved hjælp af to linjer.

package javaarraylist;
import java.util.ArrayList;
public class JavaArrayList {
    public static void main(String[] args) 
    {
     ArrayList <String> laptops;
      
      Laptops= new ArrayList <String>();
    }   
}

Sådan initialiseres en ArrayList

Der er tre metoder, som vi kan bruge til at initialisere en ArrayList i Java.

Den normale måde at initialisere på

package javaarraylist;
import java.util.ArrayList;
public class JavaArrayList {
    public static void main(String[] args) 
    {
     ArrayList <String>Laptops= new ArrayList <String>(); 
  	Laptops.add("Laptops o1");
 	Laptops.add("Laptops o2");

    }   
}

Arrays.asList initialisering

package javaarraylist;
import java.util.ArrayList;
public class JavaArrayList {
    public static void main(String[] args) 
    {
     ArrayList <String>Laptops= new ArrayList <String>(Arrays.asList("A", "B", "C")); 
  	      }   
}

Anonym Initialisering af indre klasse

package javaarraylist;
import java.util.ArrayList;
public class JavaArrayList {
    public static void main(String[] args) 
    {
     ArrayList <String>Laptops= new ArrayList <String>(){{   
  	 	add(Laptops o1);
   		add(Laptops o2);
   		add(Laptops o3);
 
 }};

  	      }   
}

ArrayList metoder/operationer

Tilføj elementer i ArrarList

Vi tilføjer elementer til en ArrayList ved hjælp af add() metoden.
Eksempel:

package javaarraylist;
import java.util.ArrayList;
public class JavaArrayList {
    public static void main(String[] args) 
    {
     ArrayList <String> Laptops = new ArrayList <String>();
     Laptops.add("Dell");
     Laptops.add("Hp");
     Laptops.add("Lenovo");
     
    System.out.println("======String Objects==========");
    System.out.println(Laptops);
    
     ArrayList <Character> A = new ArrayList <Character>();
     A.add('a');
     A.add('b');
     A.add('c');
     A.add('d');
     
    System.out.println("======Character Objects==========");
    System.out.println(A);
     
     ArrayList <Integer> numbers = new ArrayList <Integer>();
     numbers.add(1);
     numbers.add(2);
     numbers.add(3);
    
    System.out.println("======Integer Objects==========");
    System.out.println(numbers);
    
     ArrayList <Double> doubleArrayList = new ArrayList <Double>();
     doubleArrayList.add(12.12);
     doubleArrayList.add(12.23);
     doubleArrayList.add(10.10);
    
    System.out.println("======Double Objects==========");
    System.out.println(doubleArrayList);    
    }
}

Fra ovenstående eksempler vil du også bemærke, hvordan du definerer de forskellige typer objekter. Strenge er indesluttet mellem det dobbelte (“”), tegnet mellem enkelte anførselstegn (”), men heltal og dobbelte anførselstegn er ikke omgivet af nogen anførselstegn.
Output :

run:
======String Objects==========
[Dell, Hp, Lenovo]
======Character Objects==========
[a, b, c, d]
======Integer Objects==========
[1, 2, 3]
======Double Objects==========
[12.12, 12.23, 10.1]
BUILD SUCCESSFUL (total time: 0 seconds)

Vi kan også tilføje et element i ArrayList, mens vi angiver indekset i add-metoden.

ArrayList <String> Laptops = new ArrayList <String>();
Laptops.add(3,"Toshiba");

Fra ovenstående kode tilføjer den "Toshiba" på den fjerde position. Husk vores indeks starter ved 0.

Få adgang til elementer i ArrayList

Hvis vi fik adgang til elementer fra et array, kalder vi arraynavnet og indekset for det array, vi har brug for. print (my_array [0]). I en ArrayList bruger vi en metode kaldet get(). Dens indeks starter også fra 0.
For eksempel, hvis vi ønsker at få adgang til det tredje element fra vores bærbare computere, ArrayList. Vi udskriver.
System.out.println(Laptops.get(2));

package javaarraylist;
import java.util.ArrayList;
public class JavaArrayList {
    public static void main(String[] args) 
    {
     ArrayList <String> Laptops = new ArrayList <String>();
     Laptops.add("Dell");
     Laptops.add("Hp");
     Laptops.add("Lenovo");
     Laptops.add("Toshiba");   
    
    System.out.println(Laptops.get(2));
    }
}

Output

run:
Lenovo
BUILD SUCCESSFUL (total time: 0 seconds)

Ændring af et element i ArrayList

Når vi ønsker at ændre et ArrayList-element, bruger vi metoden set(). Den indeholder to elementer, hvor det ene er indekset for den værdi, du vil ændre, og det andet er den værdi, du vil ændre med.
Lad os ændre Lenovo til Acer og udskrive det ændrede element fra vores liste.

package javaarraylist;
import java.util.ArrayList;
public class JavaArrayList {
    public static void main(String[] args) 
    {
     ArrayList <String> Laptops = new ArrayList <String>();
     Laptops.add("Dell");
     Laptops.add("Hp");
     Laptops.add("Lenovo");
     Laptops.add("Toshiba");
     
    Laptops.set(2, "Acer");
    System.out.println(Laptops.get(2));
    }
}

Output:

run:
Acer
BUILD SUCCESSFUL (total time: 0 seconds)

Fjernelse af elementer i ArrayList

Du kan enten fjerne et enkelt element fra en ArrayList ved hjælp af indekset og remove() eller fjern alle elementerne fra ArrayList ved hjælp af clear() metode.

package javaarraylist;
import java.util.ArrayList;
public class JavaArrayList {
    public static void main(String[] args) 
    {
     ArrayList <String> Laptops = new ArrayList <String>();
     Laptops.add("Dell");
     Laptops.add("Hp");
     Laptops.add("Lenovo");
     Laptops.add("Toshiba");
     
    Laptops.remove(2);
    System.out.println(Laptops);
    
    Laptops.clear();
    System.out.println(Laptops);
    }
}

Output:

run:
[Dell, Hp, Toshiba]
[]
BUILD SUCCESSFUL (total time: 0 seconds)

I den anden del udskriver den en tom ArrayList, da alle dens objekter er blevet fjernet.

Klonmetode

klonen() metoden kopierer og returnerer den nøjagtige kopi af ArrayList-objekter.
Eksempel:

package javaarraylist;
import java.util.ArrayList;
public class JavaArrayList {
    public static void main(String[] args) 
    {
     ArrayList <String> Laptops = new ArrayList <String>();
     Laptops.add("Dell");
     Laptops.add("Hp");
     Laptops.add("Lenovo");
     Laptops.add("Toshiba");
     
    System.out.println(Laptops);
    
     ArrayList <String> LaptopsCopy =(ArrayList <String>)Laptops.clone();
    
    System.out.println("====printing the copied Items======");
    
    System.out.println(LaptopsCopy);
        
    }
}

Output

run:
[Dell, Hp, Lenovo, Toshiba]
====printing the copied Items======
[Dell, Hp, Lenovo, Toshiba]
BUILD SUCCESSFUL (total time: 0 seconds)

Sådan bestemmes størrelsen af ​​en ArrayList

For at bestemme størrelsen af ​​et array bruger vi size() metode.
Eksempel:

package javaarraylist;
import java.util.ArrayList;
public class JavaArrayList {
    public static void main(String[] args) 
    {
     ArrayList <String> Laptops = new ArrayList <String>();
     Laptops.add("Dell");
     Laptops.add("Hp");
     Laptops.add("Lenovo");
     Laptops.add("Toshiba");
     
    System.out.println("Printing the size of the array");
    System.out.println(Laptops.size());
    
    }
}

Output :

run:
Printing the size of the array
4
BUILD SUCCESSFUL (total time: 0 seconds)

Sløjfe gennem en ArrayList

Der er to måder at gå gennem en ArrayList på.

For-loop

For at angive antallet af gange, der skal gås igennem, kan du bruge size() metode.

package javaarraylist;
import java.util.ArrayList;
public class JavaArrayList {
    public static void main(String[] args) 
    {
     ArrayList <String> Laptops = new ArrayList <String>();
     Laptops.add("Dell");
     Laptops.add("Hp");
     Laptops.add("Lenovo");
     Laptops.add("Toshiba");
     
     for (int i = 0; i < Laptops.size(); i++) {
      System.out.println(Laptops.get(i));
    }
    
    }
}

Output:

run:
Dell
Hp
Lenovo
Toshiba
BUILD SUCCESSFUL (total time: 1 second)

For hver sløjfe (iterator)

Den anden metode er at bruge for-hver-løkke eller kaldet iterator-løkke.

package javaarraylist;
import java.util.ArrayList;
public class JavaArrayList {
    public static void main(String[] args) 
    {
     ArrayList <String> Laptops = new ArrayList <String>();
     Laptops.add("Dell");
     Laptops.add("Hp");
     Laptops.add("Lenovo");
     Laptops.add("Toshiba");
     
   for (String i : Laptops) {
      System.out.println(i);
    }
    }
}

Der er andre looping-metoder gennem ArrayList, som at bruge Lamba. Lad os se dette gennem en kode for bedre forståelse.

package javaarraylist;

import java.util.ArrayList;
import java.util.function.Consumer;

public class JavaArrayList {

    public static void main(String[] args) 
    {
        // Creating an array list
        ArrayList<String> Laptops = new ArrayList<>();

        // Insert some elements
     Laptops.add("Dell");
     Laptops.add("Hp");
     Laptops.add("Lenovo");
     Laptops.add("Toshiba");
       System.out.println( "======Iterate using standard for loop=====");
        for (int i=0; i<Laptops.size(); i++) {
            System.out.println(Laptops);
        }
        
        System.out.println("==== Iterate using an iterator====");
        for (String i : Laptops) {
      System.out.println(i);
    }
        
        System.out.println("===Iterate using ArrayList.forEach====");
        Laptops.forEach(new Consumer<String>() {
            @Override
            public void accept(String i) {
                System.out.println(i);
            }
        });
        
       System.out.println("===== Iterate using forEach and Lambda=====");
        Laptops.forEach(i -> System.out.println(i));

       System.out.println("=====Iterate using forEach and method reference======");
        Laptops.forEach(System.out::println);

    }
}

Output:

run:
======Iterate using standard for loop=====
[Dell, Hp, Lenovo, Toshiba]
[Dell, Hp, Lenovo, Toshiba]
[Dell, Hp, Lenovo, Toshiba]
[Dell, Hp, Lenovo, Toshiba]
==== Iterate using an iterator====
Dell
Hp
Lenovo
Toshiba
===Iterate using ArrayList.forEach====
Dell
Hp
Lenovo
Toshiba
===== Iterate using forEach and Lambda=====
Dell
Hp
Lenovo
Toshiba
=====Iterate using forEach and method reference======
Dell
Hp
Lenovo
Toshiba
BUILD SUCCESSFUL (total time: 0 seconds)

Sorter en ArrayList

sort() metode bruges til at sortere ArrayList-elementerne. Du kan bruge enten sortering i stigende rækkefølge eller i faldende rækkefølge. Vi er nødt til at importere indsamlingspakken, for at sorteringen kan lykkes.

Import java.utils.collections

Eksempel:

package javaarraylist;

import java.util.ArrayList;
import java.util.Collections;

public class JavaArrayList {

    public static void main(String[] args) 
    {
        ArrayList <String> Laptops = new ArrayList <String>();
     Laptops.add("Dell");
     Laptops.add("Acer");
     Laptops.add("Lenovo");
     Laptops.add("Toshiba");
     
     System.out.println("===unsorted list==");
     System.out.println(Laptops);
     
    System.out.println("===sorted list=="); 
    Collections.sort(Laptops);
    System.out.println(Laptops);
    }

}

Output:

run:
===unsorted list==
[Dell, Acer, Lenovo, Toshiba]
===sorted list==
[Acer, Dell, Lenovo, Toshiba]
BUILD SUCCESSFUL (total time: 0 seconds)

ArrayList-konstruktører

ArryList()

Denne konstruktør bruges til at oprette en tom ArrayList. Den oprindelige kapacitet for denne standard ArrayList er 10.

ArrayList emptylist = new ArrayList(); 

ArrayList(Samling c)

Vi kan oprette og initialisere en samling af elementer til en ArrayList ved hjælp af denne konstruktør.

ArrayList <String> Laptops = new ArrayList<String>(list); 
//list specifiesa collection of elements

ArrayList(int kapacitet)

For at bygge en ArrayList med initial kapacitet specificeret på initialiseringstidspunktet, kan vi bruge denne konstruktør.
Lad os tage et eksempel, antag at vi skal tilføje 600 elementer i en ArrayList, vil vi oprette ArrayList for at initialisere den til at indeholde de 600 elementer.

ArrayList<Integer> capacity = new ArrayList<Integer>(600);

Sådan øger og formindsker du størrelsen af ​​en ArrayList

Som vi havde nævnt tidligere, er en ArrayList dynamisk, men vi kan også øge og mindske dens størrelse manuelt ved hjælp af to metoder.

EnsureCapacity();

ArrayList<String>Laptops = new ArrayList<String>();
  Laptops.ensureCapacity(20);

Denne metode øger den aktuelle kapacitet af ArrayList. I eksemplet ovenfor er standardstørrelsen for ArrayList 10, men den øges til 20 ved brug af ensureCapacity() metode.

Trim Tosize();

ArrayList<String>Laptops = new ArrayList<String>();
  Laptops.ensureCapacity(20);

Laptopsl.trimTosize();

Efter at have øget arrayets størrelse til at indeholde 20 elementer, vises trimTosize() metode reducerer den tilbage til standardstørrelsen.

Sådan sammenlignes to ArrayList i Java

For at sammenligne to ArrayList i Java bruger vi contains() metoden.

package javaarraylist;

import java.util.ArrayList;
import java.util.Collections;

public class JavaArrayList {

    public static void main(String[] args) 
    {
       ArrayList<String> Laptops1= new ArrayList<String>();
          Laptops1.add("Dell");
          Laptops1.add("Lenovo");
          Laptops1.add("Toshiba");
          Laptops1.add("Acer");
          Laptops1.add("Acer");

          ArrayList<String> Laptops2= new ArrayList<String>();
          Laptops2.add("IBM");
          Laptops2.add("Thinkpad");
          Laptops2.add("Acer");
          Laptops2.add("Acer");

          //Storing the comparison output in ArrayList<String>
          ArrayList<String> Comparison= new ArrayList<String>();
          for (String temp : Laptops1)
              Comparison.add(Laptops2.contains(temp) ? "Yes" : "No");
          System.out.println(Comparison);

    }

}

Vi oprettede først to ArrayList til at holde String of object type laptops og oprettede derefter den sidste ArrayList for at sammenligne de to ArrayList og returnere "ja", hvis de er ens og "nej", hvis de ikke er ens.

Output:

run:
[No, No, No, Yes, Yes]
BUILD SUCCESSFUL (total time: 1 second)

Konklusion

Denne tutorial dækkede de vigtigste punkter, man bør forstå for at begynde at arbejde med Java ArrayList. Du lærte at oprette, tilføje, få adgang til, sortere, sløjfe, fjerne, sammenligne og konstruere. Afslutningsvis kan vi også sige, at en Arraylist er implementeringen af ​​et dynamisk/tilpasbart array. Giv venligst feedback i kommentarfeltet, hvis du har spørgsmål. Jeg vil med glæde hjælpe!


Java tag