Java >> Tutoriel Java >  >> Tag >> ArrayList

ArrayList en Java avec des exemples

ArrayList

ArrayList en Java est similaire à un tableau, sauf qu'il n'y a pas de limite de taille dans ArrayList. ArrayList est dynamique et permet donc d'ajouter et de supprimer des éléments à tout moment. Cependant, les éléments d'une ArrayList sont stockés dans l'ordre d'insertion. Une ArrayList n'est pas synchronisée et peut également stocker des objets qui incluent des valeurs nulles.

ArrayList est l'implémentation de l'interface de liste trouvée dans java.util forfait. La liste étend l'interface des collections, qui étend en interne l'interface itérable.
Une interface est un ensemble de méthodes abstraites. Vous ne pouvez pas créer d'instances d'une méthode abstraite.

Prérequis

Pour avoir une compréhension claire de ArrayList, il sera très avantageux de comprendre d'abord Arrays. Connaître la différence entre les tableaux à une dimension et les tableaux à deux dimensions, savoir comment créer, accéder, ajouter des éléments, supprimer et également parcourir les éléments du tableau. Supposons que vous n'ayez pas ces connaissances, cependant, vous n'avez pas à paniquer car nous allons rendre ce tutoriel aussi simple que possible, même pour les débutants. Creusons dans ArrayList en Java.

Fonctionnalités de Java ArrayList

  • ArrayList utilise une structure basée sur un index en Java.
  • Une ArrayList peut stocker des éléments en double.
  • ArrayList est redimensionnable ; vous pouvez donc diminuer et augmenter sa taille.
  • Une ArrayList n'est pas synchronisée.
  • Il a une propriété d'accès aléatoire puisque nous pouvons obtenir, définir, supprimer et insérer des éléments du tableau à partir de n'importe quelle position arbitraire.
  • Il est possible d'ajouter des éléments nuls dans une ArrayList.
  • Les éléments sont triés dans l'ordre d'insertion.
  • Ses performances sont lentes en raison de nombreux décalages lorsque vous supprimez un élément d'une ArrayList.

Différence entre un Array et un ArrayList

Dans un tableau, sa taille ne peut pas être modifiée, ce qui signifie que si vous souhaitez ajouter ou supprimer des éléments du tableau, vous devez en créer un nouveau. Dans une ArrayList, sa taille est redimensionnable; vous pouvez donc ajouter et supprimer des éléments à tout moment.

Création d'une ArrayList

Le premier point à noter est que chaque fois que vous devez créer un arrayList, vous devez d'abord le java.util.arrayList forfait.
Exemple : 

import java.util.ArrayList;

Créons maintenant une ArrayList d'objets appelés Laptops qui stockera des chaînes de noms de marques d'ordinateurs portables.

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

Dans l'exemple ci-dessus, ArrayList contient des objets portables de type String, un type non primitif. Nous pouvons également créer une ArrayList pour contenir d'autres types d'objets primitifs tels que Integer, Boolean, Character et double.
Exemple :

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

L'avantage de spécifier le type tel qu'une chaîne ou un entier est que, si vous essayez d'ajouter un autre type, cela génère une erreur de compilation. Vous trouverez ci-dessous une autre méthode de création d'une ArrayList à l'aide de deux lignes. 

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

Comment initialiser une ArrayList

Il existe trois méthodes que nous pouvons utiliser pour initialiser une ArrayList en Java.

La méthode normale d'initialisation

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

    }   
}

Initialisation de Arrays.asList

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

Initialisation de la classe interne anonyme

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

  	      }   
}

Méthodes/Opérations ArrayList

Ajouter des éléments dans l'ArrarList

Nous ajoutons des éléments à une ArrayList en utilisant la méthode add().
Exemple : 

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

À partir des exemples ci-dessus, vous noterez également comment définir les différents types d'objets. Les chaînes sont entre le double (“”), le caractère entre guillemets simples (”), mais les entiers et les guillemets doubles ne sont entourés d'aucun guillemet.
Sortie :

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)

Nous pouvons également ajouter un élément dans la ArrayList tout en spécifiant l'index dans la méthode add.

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

À partir du code ci-dessus, il ajoutera "Toshiba" à la quatrième position. N'oubliez pas que notre index commence à 0.

Accéder aux éléments de la ArrayList

Si nous accédions aux éléments d'un tableau, nous appelons le nom du tableau et l'index du tableau dont nous avons besoin. print ( my_array [ 0 ] ). Dans une ArrayList, nous utilisons une méthode appelée get(). Son indice commence également à 0.
Par exemple, si nous voulons accéder au troisième élément de nos ordinateurs portables, ArrayList. Nous imprimons.
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));
    }
}

Sortie 

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

Modification d'un élément dans la ArrayList

Lorsque nous voulons modifier un élément ArrayList, nous utilisons la méthode set(). Il contient deux éléments, l'un étant l'index de la valeur que vous souhaitez modifier et le second la valeur avec laquelle vous souhaitez modifier.
Modifions Lenovo en Acer et imprimons l'élément modifié de notre 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));
    }
}

Sortie : 

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

Suppression d'éléments dans la ArrayList

Vous pouvez soit supprimer un seul élément d'une ArrayList en utilisant l'index et le remove() ou supprimez tous les éléments de la ArrayList en utilisant clear() méthode.

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

Sortie : 

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

Dans la deuxième partie, il imprime une ArrayList vide puisque tous ses objets ont été supprimés.

Méthode de clonage

Le clone() copie et renvoie la copie exacte des objets ArrayList.
Exemple : 

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

Sortie 

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

Comment déterminer la taille d'une ArrayList

Pour déterminer la taille d'un tableau, nous utilisons le size() méthode.
Exemple :

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

Sortie :

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

Parcourir une ArrayList

Il existe deux façons de parcourir une ArrayList.

boucle For

Pour spécifier le nombre de fois à boucler, vous pouvez utiliser size() méthode.

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

Sortie : 

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

Boucle pour chaque (itérateur)

La deuxième méthode consiste à utiliser une boucle for-each ou appelée boucle d'itération.

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

Il existe d'autres méthodes de bouclage via ArrayList, comme l'utilisation de Lamba. Voyons cela à travers un code pour une meilleure compréhension.

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

    }
}

Sortie : 

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)

Trier une ArrayList

Le sort() La méthode est utilisée pour trier les éléments ArrayList. Vous pouvez utiliser le tri par ordre croissant ou par ordre décroissant. Nous devons importer le package de collections pour que le tri fonctionne.

Import java.utils.collections

Exemple :

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

}

Sortie : 

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

Constructeurs ArrayList

ArryList()

Ce constructeur est utilisé pour créer une ArrayList vide. La capacité initiale de cette ArrayList par défaut est de 10.

ArrayList emptylist = new ArrayList();

ArrayList(Collection c)

Nous pouvons créer et initialiser une collection d'éléments dans une ArrayList à l'aide de ce constructeur.

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

ArrayList(int capacité)

Pour construire une ArrayList avec une capacité initiale spécifiée au moment de l'initialisation, nous pouvons utiliser ce constructeur.
Prenons un exemple, supposons que nous devions ajouter 600 éléments dans une ArrayList, nous allons créer la ArrayList pour l'initialiser pour contenir les 600 éléments.

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

Comment augmenter et diminuer la taille d'une ArrayList

Comme nous l'avons mentionné précédemment, une ArrayList est dynamique, mais nous pouvons également augmenter et diminuer sa taille manuellement en utilisant deux méthodes.

AssurerCapacité();

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

Cette méthode augmente la capacité actuelle de ArrayList. Dans l'exemple ci-dessus, la taille par défaut de ArrayList est de 10, mais elle passe à 20 en utilisant ensureCapacity() méthode.

Trim Tosize();

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

Laptopsl.trimTosize();

Après avoir augmenté la taille du tableau pour contenir 20 éléments, le trimTosize() la réduit à sa taille par défaut.

Comment comparer deux ArrayList en Java

Pour comparer deux ArrayList en Java, nous utilisons la méthode contains().

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

    }

}

Nous avons d'abord créé deux ArrayList pour contenir une chaîne d'ordinateurs portables de type objet, puis nous avons créé la dernière ArrayList pour comparer les deux ArrayList et renvoyer "oui" s'ils sont identiques et "non" s'ils ne sont pas identiques.

Sortie : 

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

Conclusion

Ce tutoriel a couvert les points les plus importants à comprendre pour commencer à travailler avec Java ArrayList. Vous avez appris à créer, ajouter, accéder, trier, boucler, supprimer, comparer et construire. En conclusion, on peut aussi dire qu'une Arraylist est l'implémentation d'un tableau dynamique/redimensionnable. S'il vous plaît laissez vos commentaires dans la section des commentaires en cas de questions. Je serai ravi de vous aider !


Balise Java