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

Imprimer ArrayList en Java expliqué avec des exemples

ArrayList

Nous verrons comment imprimer une ArrayList en Java dans ce tutoriel. La structure de données Array en Java est très solide, mais elle a ses contraintes. Pour contourner ces limitations, la structure de données ArrayList a été créée.

Avant de commencer notre sujet, laissez-nous vous donner une introduction rapide sur ArrayList.

Introduction à ArrayList

ArrayList est une variante plus avancée de Array car elle prend en charge les tableaux redimensionnables. En dehors de cela, ArrayList est une collection Java qui implémente la liste Java. De plus, ArrayList est la version de tableau avancée, mais elle est moins efficace en termes d'optimisation du temps que les tableaux de base.

La classe ArrayList est en outre construite sur une structure de données Array et implémente l'interface List. En raison de l'utilité et de la flexibilité qu'il offre, il est largement utilisé. La plupart des développeurs préfèrent Arraylist à Array car il s'agit d'une meilleure alternative aux tableaux Java classiques. L'implémentation ArrayList de l'interface List est une implémentation de tableau redimensionnable. Toutes les opérations de liste facultatives sont implémentées et tous les éléments, y compris null, sont autorisés.

Nous l'avons gardé simple et court car nous ne nous concentrions pas sur les détails de ArrayList.

Comment imprimer des éléments ArrayList en Java

Oui, vous avez bien lu. Heureusement, les éléments ArrayList ne peuvent pas être imprimés dans une seule méthode. Même s'il existe des dizaines d'options, nous examinerons les huit principales tout en illustrant à l'aide de divers exemples dans ce guide. Pour imprimer des éléments, créez d'abord une String ArrayList et placez-y des données sous forme de chaînes, puis affichez-les à l'aide de l'une des méthodes suivantes :

  • boucle For
  • Boucle pour chaque
  • Utilisation de l'itérateur
  • Utilisation de l'itérateur de liste
  • Utiliser le flux
  • utiliser toString()
  • Utilisation de la classe Arrays
  • Utiliser des identifiants

Une chaîne ArrayList est vue ci-dessous. En utilisant la méthode add() de la ArrayList, nous avons créé un objet liste et inséré les noms des sociétés informatiques.

ArrayList arrProgrammingLanguages=new ArrayList();
arrProgrammingLanguages.add("Google");
arrProgrammingLanguages.add("Microsoft");
arrProgrammingLanguages.add("Yahoo");
arrProgrammingLanguages.add("Amazon");
arrProgrammingLanguages.add("Uber");
arrProgrammingLanguages.add("Twitter");
arrProgrammingLanguages.add("Meta");

Utiliser la boucle for

//using for loop

System.out.println("Using For Loop\n ");
for (int i = 0; i < arrProgrammingLanguages.size();i++)
{ 		      
  System.out.println(arrProgrammingLanguages.get(i)); 		
}

Nous obtenons la longueur de la ArrayList en utilisant sa méthode size (), jusqu'à laquelle nous devons récupérer les éléments à utiliser pour la boucle. Nous avons utilisé la méthode get(i) de ArrayList pour récupérer les données dans les index de ArrayList.

Utiliser l'itérateur

//using iterator
System.out.println("\nUsing the Iterator");
Iterator iterator=arrProgrammingLanguages .iterator();
while(iterator .hasNext())
{
  String obj = iterator.next();
  System.out.println(obj);
}

Les itérateurs sont utilisés pour obtenir des éléments dans le framework de collection Java. La méthode iterator() de ArrayList renvoie un itérateur pour la liste.hasNext() est une méthode de l'itérateur qui vérifie si l'élément suivant est disponible. La méthode next() de l'itérateur renvoie également des éléments.

Pour parcourir la ArrayList, nous avons construit une boucle while. Nous utilisons la méthode hasNext() dans la boucle pour voir si l'élément suivant est disponible. La méthode hasNext() d'un itérateur renvoie la valeur booléenne true ou false. Si hasNext() renvoie true, la boucle utilise la méthode Iterator next() pour obtenir les membres ArrayList et les imprime à l'aide de System.out. La méthode println est une méthode d'impression. Il n'y a plus d'éléments dans la liste si hasNext() renvoie false.

Utilisation de la boucle for-each

//using for-each loop
System.out.println("\nUsing for-each loop\n");		
for (String strVar : arrProgrammingLanguages)
{ 		      
  System.out.println(strVar); 		
}

La même boucle for est exprimée différemment ici, en utilisant la fonction de boucle for-each ou de boucle avancée de Java. Cette boucle récupère chaque élément de l'objet ArrayList un à la fois.

Utilisation de l'itérateur de liste

//Using list iterator
litrVar=arrProgrammingLanguages.listIterator();

System.out.println("\n Using the list iterator");
while(litrVar.hasNext()){
  System.out.println(litrVar.next());
}

Nous pouvons également utiliser ListIterator pour parcourir les éléments de ArrayList. La méthode hasNext() vérifie si un élément est présent et la méthode next() récupère les entrées ArrayList. ListIterator est identique à l'itérateur. Cependant, ListIterator est bidirectionnel, alors que l'itérateur est unidirectionnel.

La seule différence est qu'il faut d'abord commencer par null dans le cas d'un itérateur de liste.

ListIterator<String> litrVar = null;

Utiliser Stream en Java pour imprimer une ArrayList

Pour imprimer une ArrayList en Java, vous pouvez utiliser la boucle foreach dans Java 8 Stream.

package org.under.codeunderscored;
 
import java.util.ArrayList;
 
public class PrintArrayListMain {
 
    public static void main(String args[])
    {
        ArrayList<String> codingList = new ArrayList<>();
 
        fruitList.add("Java");
        fruitList.add("Python");
        fruitList.add("JavaScript");
        fruitList.add("GO");
        System.out.println("Elements of  the given ArrayList are:");
 
        codingList.stream().forEach(System.out::println);
 
    }
}

Utiliser toString() pour imprimer ArrayList en Java

Vous pouvez utiliser sa référence si vous souhaitez simplement afficher ArrayList sur la console. En interne, il utilisera la fonction toString() de type ArrayList (String dans cet exemple).

package org.under.codeunderscored;
 
import java.util.ArrayList;
 
public class PrintArrayListMain {
 
    public static void main(String args[])
    {
        ArrayList<String> codingList = new ArrayList<>();
 
        codingList.add("Python");
        codingList.add("Java");
        codingList.add("JavaScript");
        codingList.add("Go");
        System.out.println("Elements of the ArrayList include:"+codingList);
    }
}

Utilisation de la classe Arrays pour imprimer des éléments ArrayList en Java

Pour imprimer les éléments d'une ArrayList, convertissez-la en tableau et utilisez la fonction toString de la classe Arrays.

System.out.println("Print the Arraylist using the Arrays.toString method");
System.out.println( The Arrays.toString(aListDays.toArray()) );

Si vous souhaitez vous débarrasser des crochets, utilisez l'approche replaceAll décrite ci-dessous.

System.out.println(Arrays.toString(aListDays.toArray()) .replaceAll("[\\[\\]]", "") );

Imprimer une liste de tableaux en Java à l'aide d'ID

Chaque élément ArrayList a un identifiant unique qui peut être obtenu en imprimant ArrayList sans utiliser de méthodes telles que toString (). Il affichera la ArrayList brute avec les ID d'éléments, comme indiqué dans la sortie de l'exemple :

import java.util.ArrayList;

public class Codeunderscored {

    public static void main(String[] args) {

        ArrayList<ModelClass> modelList;

        ModelClass modelOne = new ModelClass();
        ModelClass modelTwo = new ModelClass();
        ModelClass modelThree = new ModelClass();

        modelOne.setName("Joy");
        modelTwo.setName("Ann");
        modelThree.setName("Mike");

        modelList = new ArrayList<ModelClass>();
        modelList.add(modelOne);
        modelList.add(modelTwo);
        modelList.add(modelThree);

        System.out.println(modelList);

    }
}

class ModelClass{

    String name;
    void setName(String name){
        this.name = name;
    }

}

Code Java complet pour imprimer les éléments ArrayList de différentes manières

Voici le code complet pour imprimer tous les éléments de la ArrayList en utilisant différentes techniques :

import java.util.*;
import java.util.ArrayList;
import java.util.Iterator;

public class Codeunderscored {

	public static void main(String[] args) {
	
		 ListIterator litrVar = null;
		ArrayList arrMonths=new ArrayList();
		arrMonths.add("January");
		arrMonths.add("February");
		arrMonths.add("March");
		arrMonths.add("April");
		arrMonths.add("May");
		arrMonths.add("June");
		arrMonths.add("July");
		
		//using for loop
		System.out.println("Using the For Loop\n ");
	      for (int i = 0; i < arrMonths.size();i++)
	      { 		      
	          System.out.println(arrMonths .get(i)); 		
	      }   		
		
		//using for-each loop
	      System.out.println("\nUsing for-each loop\n");		
	      for (String strVar : arrMonths)
	      { 		      
	           System.out.println(strVar); 		
	      }

	      //using iterator
	      System.out.println("\nUsing Iterator");
	      Iterator itrVar=arrMonths .iterator();
	      while(itrVar.hasNext())
	        {
	          String objVar = itrVar.next();
	          System.out.println(objVar);
	        }
	    //Using list iterator
	      litrVar=arrMonths .listIterator();
	   
	      System.out.println("\n Using the given list iterator");
	      while(litrVar.hasNext()){
	         System.out.println(litrVar.next());
	      }
	      
	}

}

Disons que vous avez trois ArrayList ou plus. Est-il nécessaire que vous réécriviez le code pour sortir les Elements ? NON, vous pouvez établir une seule méthode pour imprimer plusieurs ArrayList et l'appeler pour chaque ArrayList individuellement, comme indiqué ci-dessous.

L'exemple de code ci-dessous comporte deux listes de tableaux :"jours" et "fruits". Les deux listes de tableaux sont imprimées à l'aide de la méthode unique "printArrayListElements(ArrayList a)".

import java.util.ArrayList;
public class Codeunderscored {

	public static void main(String[] args) {

		ArrayList citiesArr = new ArrayList();
		citiesArr.add("New York");
		citiesArr.add("London");
		citiesArr.add("Paris");
		citiesArr.add("Tokyo");
		citiesArr.add("Nairobi");
		citiesArr.add("Armsterdam");
		citiesArr.add("Zurich");

		System.out.println("Cities Array List:");
		printArrayListElements(citiesArr);

		ArrayList compCompanies = new ArrayList();
		compCompanies.add("Amazon");
		compCompanies.add("Apple");
		compCompanies.add("Alibaba");

		System.out.println("Computer Companies Array List:");
		// print computer companies array list
		printArrayListElements(compCompanies);

	}

	public static void printArrayListElements(ArrayList a) {
		for (int i = 0; i < a.size(); i++) {
			System.out.println(a.get(i));
		}
	}
}

Imprimer une ArrayList d'objets personnalisés

Si vous avez un objet personnalisé dans une ArrayList, vous devrez peut-être implémenter la fonction toString() dans cet objet pour afficher correctement la ArrayList. Prenons un exemple :

Créez une classe Employé avec des caractéristiques pour le nom et l'âge.

package org.under.codeunderscored;
 
public class Employee {
    String name;
    int age;
 
    public Employee(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
}

PrintArrayListEmployeeMain.java est la classe principale qui sera utilisée pour imprimer la ArrayList.

package org.arpit.codeunderscored;
 
import java.util.ArrayList;
 
public class PrintArrayListEmployeeMain {
 
    public static void main(String[] args) {
        ArrayList<Employee> employeesList=new ArrayList<>();
 
        Employee empOne=new Employee("Mike",52);
        Employee empTwo=new Employee("Ann",31);
        Employee empThree=new Employee("Joy",20);
        Employee empFour=new Employee("Moses",11);
 
        employeesList.add(empOne);
        employeesList.add(empTwo);
        employeesList.add(empThree);
        employeesList.add(empFour);
 
        System.out.println("Employees List:"+employeesList);
    }
}

Étant donné que la méthode toString() n'a pas été implémentée dans la classe Employee, la sortie est une chaîne illisible. Mettons la fonction toString() en action dans la classe Employee.

package org.under.codeunderscored.entry;
 
public class Employee {
    String name;
    int age;
 
    public Employee(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Maintenant, réexécutez PrintArrayListEmployeeMain.java pour obtenir des résultats différents. De plus, nous pouvons maintenant imprimer de manière compréhensible ArrayList, comme vous pouvez le voir.

Exemple :Utiliser la boucle for pour imprimer une liste de tableaux en Java

Nous itérons jusqu'à la taille () de Arraylist dans la boucle for. Nous récupérons des éléments individuels à l'aide de la fonction get() de ArrayList à chaque itération. Enfin, nous allons sortir ces parties en utilisant les instructions System.out.println.

package org.under.codeunderscored;
 
import java.util.ArrayList;
 
public class PrintArrayListMain {
 
    public static void main(String[] args) {
        ArrayList<String> arrCars = new ArrayList<>();
 
        arrCars.add("Mercedes Benz");
        arrCars.add("Rolls Royce");
        arrCars.add("Tesla");
        arrCars.add("Ferrari");
 
        System.out.println("Elements of the ArrayList are:");
        for (int i = 0; i < arrCars.size(); i++) {
            System.out.println(arl.get(i) + " ");
        }
    }
}

Exemple :Imprimer ArrayList en Java à l'aide de la boucle for-each

La seule différence entre cette procédure et la précédente est que nous utiliserons la méthode de boucle avancée. Ainsi, au lieu d'utiliser la boucle for standard, nous utiliserons son homologue avancé, qui a quelques fonctionnalités supplémentaires. Jetez un œil à la syntaxe du code ci-dessous :

package org.under.codeunderscored;
 
import java.util.ArrayList;
 
public class PrintArrayListMain {
 
    public static void main(String[] args) {
        ArrayList<String> arrayCountries = new ArrayList<>();
 
        arrayCountries.add("Canada");
        arrayCountries.add("Australia");
        arrayCountries.add("Russia");
        arrayCountries.add("Norway");
 
        System.out.println("Countries in the ArrayList are:");
        for (String country : arrayCountries) {
            System.out.println(country);
        }
    }
}

Bien qu'il n'y ait que quelques différences mineures entre les deux méthodes décrites ci-dessus, leur fonctionnement est très différent. La taille complète a d'abord été récupérée, l'index a été évalué à l'aide de cette taille et le dernier élément a été consulté. D'autre part, cette approche évalue chaque élément ArrayList en série à l'aide d'une variable String.

Exemple :Imprimer une liste de tableaux en Java à l'aide de forEach

Chaque ArrayList en Java fournit une méthode forEach qui, comme la boucle for, est l'un des moyens les plus simples de parcourir tous les objets. Nous pouvons facilement récupérer les noms de ModelClass en utilisant la méthode getName(), comme dans l'exemple précédent.

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


public class Codeunderscored {
    public static void main(String[] args) {

        ArrayList<ModelClass> arrModel;

        ModelClass modelOne = new ModelClass();
        ModelClass modelTwo = new ModelClass();
        ModelClass modelThree = new ModelClass();

        modelOne.setName("Joy");
        modelTwo.setName("Thomas");
        modelThree.setName("Mike");

        arrModel = new ArrayList<ModelClass>();
        arrModel.add(modelOne);
        arrModel.add(modelTwo);
        arrModel.add(modelThree);

        arrModel.forEach(new Consumer<ModelClass>() {
            @Override
            public void accept(ModelClass modelClass) {
                System.out.println(modelClass.getName());
            }
        });

    }
}

class ModelClass{

   private String name;
    void setName(String name){
        this.name = name;
    }

    String getName(){
        return name;
    }

}

Exemple :Imprimer ArrayList en Java à l'aide de la structure d'itération

Pour imprimer l'élément ArrayList jusqu'à présent, nous avons utilisé des principes de boucle simples, mais dans cette méthode, nous utiliserons des itérateurs, qui font partie de l'architecture de collection Java. La méthode Interactors suivante sera utilisée de cette manière.

  • Iterator() est une méthode qui renvoie un itérateur ArrayList.
  • hasNext() :Vérifie la ArrayList pour la présence ou l'absence de l'élément suivant.
  • next() :accède aux éléments de la ArrayList.

Nous allons itérer l'étape de vérification des éléments à l'aide de la boucle While et de ces trois méthodes.

Jetez un œil à l'extrait de code ci-dessous :

package org.under.codeunderscored;
 
import java.util.ArrayList;
import java.util.Iterator;
 
public class PrintArrayListMain {
 
    public static void main(String args[])
    {
        ArrayList<String> arrOperatingSystem = new ArrayList<>();
 
        arrOperatingSystem.add("MacOS");
        arrOperatingSystem.add("Windows");
        arrOperatingSystem.add("ChromeOS");
        arrOperatingSystem.add("Linux");
        arrOperatingSystem.add("Ubuntu");
 
        System.out.println("Elements in the ArrayList are:");
        Iterator<String> arrIterator = arList.iterator();
        while(arrIterator .hasNext())
        {
            String item = arrIterator.next();
            System.out.println(item);
        }
    }
}

Exemple :Imprimer ArrayList en Java à l'aide de ListIterator

Pour imprimer une ArrayList en Java, vous pouvez utiliser ListIterator au lieu d'Iterator. Vous pouvez voyager dans les deux sens avec ListIterator. Prenons un exemple :

package org.under.codeunderscored;
 
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
 
public class PrintArrayListMain {
 
    public static void main(String args[])
    {
        ArrayList<String> arrClubs = new ArrayList<>();
 
        arrClubs.add("Chelsea");
        arrClubs.add("Liverpool");
        arrClubs.add("Manchester");
        arrClubs.add("Newcastle");
        arrClubs.add("Brighton");
 
        System.out.println("Clubs in the ArrayList are:");
        ListIterator<String> listIterator = arrClubs.listIterator();
        while(listIterator .hasNext())
        {
            String item = listIterator.next();
            System.out.println(item);
        }
 
        System.out.println("Clubs of ArrayList in reverse order are:");
        ListIterator<String> listItrVar = citiesList.listIterator(arrClubs.size());
        while(listItrVar.hasPrevious())
        {
            String item = listItrVar.previous();
            System.out.println(item);
        }
    }
}

Exemple :Imprimer une liste de tableaux en Java à l'aide de la commande toString()

La dernière fonction de cette liste est une substitution de la méthode toString() de ModelClass. Lorsque nous utilisons arrModel pour appeler cette méthode, elle renverra le nom. Gardez à l'esprit que, comme son nom l'indique, cette procédure ne peut renvoyer que des valeurs de chaîne.

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


public class Codeunderscored {
    public static void main(String[] args) {

        ArrayList<ModelClass> arrModel;

        ModelClass modelOne = new ModelClass();
        ModelClass modelTwo = new ModelClass();
        ModelClass modelThree = new ModelClass();

        modelOne.setName("Joy");
        modelTwo.setName("Mike");
        modelThree.setName("James");

        arrModel = new ArrayList<ModelClass>();
        arrModel.add(modelOne);
        arrModel.add(modelTwo);
        arrModel.add(modelThree);

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

    }
}

class ModelClass{

   private String name;
    void setName(String name){
        this.name = name;
    }


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

Exemple :Comment imprimer une ArrayList contenant des objets personnalisés ?

Comment pouvons-nous imprimer une ArrayList d'objets de classe personnalisés ? Considérez le code suivant, qui contient une ArrayList d'objets de classe Employee.

package com.javacodeexamples.collections.arraylist;
 
import java.util.ArrayList;
 
public class JavaPrintArrayList {
 
    public static void main(String[] args) {
        
        ArrayList<Employee> arrEmployee = new ArrayList<Employee>();
        arrEmployee.add( new Employee("Kane", "Brown") );
        arrEmployee.add( new Employee("Ann", "Faith") );
        arrEmployee.add( new Employee("Moses", "Sang") );
        
        for( Employee emp : arrEmployee)
            System.out.println(emp);
        
    }
}
 
class Employee{
    
    private String firstName;
    private String lastName;
    
    public Employee(){}
    
    public Employee(String firstName, String lastName){
        this.firstName = firstName;
        this.lastName = lastName;
    }
    
    public String getFirstName() {
        return firstName;
    }
    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }
    public String getLastName() {
        return lastName;
    }
    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
    
}

Plutôt que d'imprimer le contenu des objets Employee, notre code a imprimé leurs adresses mémoire. Étant donné que la classe Employee ne remplace pas la méthode toString, la méthode toString par défaut de la classe Object est utilisée, qui imprime la position de l'adresse de l'objet. Au lieu d'emplacements de mémoire, remplaçons la fonction toString dans la classe Employee pour obtenir le contenu de l'objet Employee.

package com.javacodeexamples.collections.arraylist;
 
import java.util.ArrayList;
 
public class JavaPrintArrayListExample {
 
    public static void main(String[] args) {
        
        ArrayList<Employee> arrEmployee = new ArrayList<Employee>();
        arrEmployee.add( new Employee("Kane", "Brown") );
        arrEmployee.add( new Employee("Ann", "Faith") );
        arrEmployee.add( new Employee("Moses", "Sang") );
        
        for( Employee p : arrEmployee)
            System.out.println(p);
        
    }
}
 
class Employee{
    
    private String firstName;
    private String lastName;
    
    public Employee(){}
    
    public Employee(String firstName, String lastName){
        this.firstName = firstName;
        this.lastName = lastName;
    }
    
    public String getFirstName() {
        return firstName;
    }
    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }
    public String getLastName() {
        return lastName;
    }
    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
    
    public String toString(){
        return "[" + firstName + "," + lastName + "]";
    }
    
}

Conclusion

Les ArrayLists ont récemment été un sujet brûlant en Java. Ils ont beaucoup plus d'avantages que les baies ordinaires. Les ArrayLists vous permettent de stocker plusieurs objets à la suite et de les supprimer lorsqu'ils ne sont plus nécessaires. Ils vous aident également à effectuer des opérations de liste standard telles que le tri et la recherche. L'utilisation d'un tableau standard vous obligerait à créer votre logique pour ces opérations, ce qui prendrait plus de temps et d'efforts.

Les ArrayLists sont utiles dans diverses situations en raison de leur large liste d'avantages. D'un autre côté, l'impression est une activité critique qui manque aux ArrayLists. Les ArrayLists peuvent être constituées de types de données de base (entiers et chaînes) ou de types de données plus complexes (classes personnalisées). Chacun de ces scénarios nécessite un ensemble d'actions distinct pour l'impression d'une ArrayList.

C'est ainsi que vous pouvez imprimer rapidement des éléments ArrayList avec ces méthodes. De plus, vous pouvez trouver une méthode autre que ces méthodes; s'il vous plaît laissez-nous savoir comment ce dernier se passe pour vous. Si vous rencontrez des problèmes, veuillez soumettre vos questions et nous les examinerons plus en détail.


Balise Java