Comment convertir un tableau en liste en Java

Les deux structures de données les plus importantes en Java sont Array et List. Nous allons apprendre à convertir un tableau Java en liste dans cette section. Nous avons également écrit des applications Java qui utilisent plusieurs techniques Java pour transformer un tableau en liste.

Conversion tableau Java en liste

Un tableau en Java est un conteneur pour plusieurs valeurs du même type de données. Les objets et les types primitifs peuvent tous deux être stockés dans un tableau. La définition du tableau le détermine. Les valeurs du tableau sont stockées dans la même adresse mémoire si la définition du tableau est de type primitif. Si une collection contient des éléments d'objet, la section heap est utilisée pour les stocker.

Une liste est une collection d'interfaces en Java qui appartiennent au framework Java Collections. Il maintient l'ordre d'insertion tout en stockant les éléments sous forme d'objets de manière ordonnée. De plus, cela nous permet de garder une trace des valeurs en double.

L'interface List est implémentée par les classes ArrayList, LinkedList, Vector et Stack. Voici les cinq méthodes disponibles en Java pour convertir un tableau en liste :

• Méthode native ou méthode de la force brute
• Utilisation de la méthode Arrays.asList()
• Utilisation de la méthode Collections.addAll()
• Utilisation de l'API de flux Java 8
• Utilisation de la méthode Guava Lists.newArrayList()

Utilisation de la méthode native

C'est le moyen le plus simple de convertir un tableau Java en liste. Dans cette technique, nous construisons d'abord une liste vide, puis nous y ajoutons tous les éléments du tableau. Examinons un exemple.

 import java.util.*;   
public class ArrayToList
{   
  public static void main(String args[])   
  {   
    //creating an array   
    String languageArray[] = { "PHP", "JavaScript", "Python", "Kotlin", "Java", "C++", "Ruby", "Swift", "Go"};   
    //prints the array before conversion  
    System.out.println("Languages Array before conversion: "+ Arrays.toString(languageArray));   
    //call to the generic method responsible for  converting Array into List  
    List<String> languagesList = ArrayToListConversion(languageArray);   
    //print the Languages List   
    System.out.println("Languages Array as List: " + languagesList);   
  }       
  //call to the generic method responsible for  converting Array into List  
  public static <T> List<T> ArrayToListConversion(T array[])   
  {   
    //creating the constructor of the List class  
    List<T> langList = new ArrayList<>();   
    //using the for-each loop in  iterating throught  the array elements
    for (T t : languageArray)   
    {   
      //adding each element to the List  
      langList.add(t);   
    }   
    //returns the list converted into Array  
    return list;   
  }   
}  

Utilisation de la méthode arrays.asList()

C'est une méthode de la classe Java Arrays, qui fait partie du package Java.util. Lorsque nous combinons les méthodes asList() et Collection.toArray(), nous avons un pont entre les API basées sur les tableaux et les collections.

La syntaxe est la suivante :

public static <T> List<T> asList(T... a)

La méthode prend un tableau comme paramètre, qui est utilisé pour sauvegarder la langList. Le tableau fourni est renvoyé sous la forme d'une vue de liste de taille fixe sérialisable. Examinons un exemple.

import java.util.*;   
public class ArrayToList
{   
  public static void main(String args[])   
  {   
    //creating an array to be converted  
    String languageArray[] = { "PHP", "JavaScript", "Python", "Kotlin", "Java", "C++", "Ruby", "Swift", "Go"};   

    //prints array before conversion  
    System.out.println("Language Array before conversion: "+ Arrays.toString(languageArray));   
    //call to the generic method responsible for  converting Array into List  
    List<String> langList = ArrayToListConversion(languageArray);   
    //prints the List  
    System.out.println("Language Array after conversion: " + langList);   
  }   
  // Generic function responsible for converting an array to a list
  public static <T> List<T> ArrayToListConversion(T arr[])   
  {   
    //invoke the method asList() and pass the array to be converted  
    List<T> langList = Arrays.asList(languageArray);   
    //returns the list  
    return langList;   
  }   
}  

Utilisation de la méthode collections.addAll()

C'est la fonction de la classe Java Collections. Cela fait partie du package Java.util. addAll() est une méthode fournie par la classe. La méthode peut être utilisée pour transformer un Array en List. Il remplit la collection fournie avec tous les éléments. Les éléments peuvent être spécifiés individuellement ou sous la forme d'un tableau. C'est la même chose que Arrays.asList(elements) + c.addAll(Arrays.asList(elements) + c.addAll(Arrays.asList(elements))

C'est une implémentation plus rapide que la précédente.

La syntaxe est la suivante :

public static <K> boolean addAll(Collection<? super K> c, K... elements)  

Il prend en compte deux paramètres :

• c : il s'agit d'un ensemble d'éléments qui doivent être ajoutés.
• elements :les éléments doivent être placés en c.

Si la collection a changé en raison de l'appel, elle renvoie true. Les exceptions suivantes sont levées :

• UnsupportedOperationException est levée si le paramètre c ne prend pas en charge l'opération d'ajout.
• NullPointerException est levée si un ou plusieurs des membres du tableau fournis ont des valeurs nulles, et c n'autorise pas les éléments nuls.
• IllegalPointerException est levée si un élément du tableau interdit son insertion dans le paramètre c.

Examinons un exemple.

import java.util.*;   
public class ArrayToListExample3  
{   
  public static void main(String args[])   
  {   
    //creating an Array to be converted  
    String languageArray[] = { "PHP", "JavaScript", "Python", "Kotlin", "Java", "C++", "Ruby", "Swift", "Go"};   
    //prints the Array   
    System.out.println("Languages Array before conversion: "+ Arrays.toString(languageArray));   
    //method calling  
    List<String> langList = ArrayToListConversion(languageArray);   
    //print the List   
    System.out.println("Languages Array after conversion: " + langList);   
  }       
  //call to the generic method responsible for  converting Array into List  
  public static <T> List<T> ArrayToListConversion(T arr[])   
  {   
    //creating the constructor of thr List class  
    List<T> langList = new ArrayList<>();   
    //the method adds Array to the List  
    Collections.addAll(langList, languageArray);   
    //returns the langList  
    return langList;   
  }   
}  

Utilisation de l'API Stream dans Java 8

L'API Stream dans Java 8 vous permet de manipuler des collections d'objets. C'est un ensemble de méthodes qui peuvent être combinées pour obtenir le résultat souhaité. Il est important de se rappeler que la structure de données d'origine n'est pas affectée. Il génère la sortie à l'aide de méthodes en pipeline. Vous pouvez obtenir le flux de différentes manières. Cependant, dans l'exemple suivant, nous avons utilisé Arrays.stream(Object[]) pour le faire.

Dans une méthode de rencontre, la méthode Collectors.toList() renvoie un Collector qui agrège les composants d'entrée dans une liste nouvellement générée.

La syntaxe est la suivante :

public static <K> Collector<K,?,List<K>> toList()  

Où K désigne le type d'élément que nous avons fourni. La méthode ne fournit pas de garanties de type, de mutabilité, de sécurité des threads ou de sérialisabilité. Utilisons l'API Stream pour convertir un tableau en liste dans un programme Java.

import java.util.*;   
import java.util.stream.Collectors;  
public class ArrayToList 
{   
  //call to the generic method responsible for  converting Array into List  
  public static <T> List<T> ArrayToListConversion(T arr[])   
  {   
    //is responsible for creating a list from the Array given and returns a corresponding List  
    return Arrays.stream(arr).collect(Collectors.toList());   
  }   
  public static void main(String args[])   
  {   
    //array creation to convert into a List  
    String languageArray[] = { "PHP", "JavaScript", "Python", "Kotlin", "Java", "C++", "Ruby", "Swift", "Go"};   
    //prints the Array before conversion  
    System.out.println("Array: "+ Arrays.toString(languageArray));   
    //call to the method created above and storing the elements into the List object  
    List<String> langList = ArrayToListConversion(languageArray);   
    //prints the langList   
    System.out.println("List: " + langList);   
  }   
}   

Utiliser Guava Lists.newArrayList()

Les listes de goyave sont un excellent moyen d'organiser vos données. Il appartient au package com.google.common.collect et est une méthode de la classe Lists. La méthode newArrayList() de la classe génère un objet ArrayList mutable vide avec les éléments du tableau fourni.

La syntaxe est la suivante :

public static <E> ArrayList<E> newArrayList(E... elements)

Pour Java 6 et les versions précédentes, la méthode newArrayList() est disponible. Il est obsolète dans les versions plus récentes. Nous utilisons directement le constructeur ArrayList au lieu de la technique ci-dessus.

import static com.google.common.collect.Lists.*;   
import java.util.*;   
public class ArrayToList 
{   
  public static void main(String args[])   
  {   
    //creation of an Array for conversion into a List  
    String languageArray[] = { "PHP", "JavaScript", "Python", "Kotlin", "Java", "C++", "Ruby", "Swift", "Go"};     
    //prints the Array before conversion  
    System.out.println("Array: "+ Arrays.toString(languageArray));   
    //convert the Array to List   
    List<String> langList = ArrayToListConversion(languageArray);   
    //prints the langList   
    System.out.println("List: " + langList);   
  }  
  // Generic function responsible for converting an array to a list
  public static <T> List<T> ArrayToListConversion(T arr[])   
  {   
    //creates a List from the specified Array   
    return Lists.newArrayList(languageArray);   
  }   
}  

Exemples :utilisation de l'approche par force brute

// Program for converting an Array to a List

import java.util.*;
import java.util.stream.*;

class Codeunderscored {

	// Generic function responsible for converting an array to a list
	public static <T> List<T> codeConvertArrayToList(T array[])
	{

		// empty List creation
		List<T> list = new ArrayList<>();

		// Iterate through the array
		for (T t : array) {
			// Add each element into the list
			list.add(t);
		}

		// Return the converted List
		return list;
	}

	public static void main(String args[])
	{
		// Create an Array
		String laptopsArray[]= { "Chromebook", "DELL", "Apple", "HP", "Toshiba" };

		// Print the Array
		System.out.println("Array: "+ Arrays.toString(array laptopsArray

		// convert the Array to List
		List<String> laptopsList = convertArrayToList(laptopsArray);

		// Print the List
		System.out.println("List of Laptops: " + laptopsList);
	}
}

Exemple :utilisation de la méthode Arrays.asList()

// Java Program to convert
// Array to List

import java.util.*;
import java.util.stream.*;

class Codeunderscode {

	// Generic function responsible for converting an array to a list
	public static <T> List<T> codeConvertArrayToList(T array[])
	{

		// pass the array
 as parameter in the constructor to create the list
		List<T> list = Arrays.asList(array);

		// Return the converted List
		return list;
	}

		public static void main(String args[])
	{
		// Create an Array
		String laptopsArray[]= { "Chromebook", "DELL", "Apple", "HP", "Toshiba" };

		// Print the Array
		System.out.println("Array: "+ Arrays.toString(array laptopsArray

		// convert the Array to List
		List<String> laptopsList = convertArrayToList(laptopsArray);

		// Print the List
		System.out.println("List of Laptops: " + laptopsList);
	}
}

Exemple :Utilisation de Collections.addAll()

// Java Program to convert
// Array to List

import java.util.*;
import java.util.stream.*;

class Codeunderscored {

// Generic function responsible for converting an array to a list
	public static <T> List<T> codeConvertArrayToList(T array[])
	{

		// pass the array
 as parameter in the constructor to create the list
		List<T> list = new ArrayList<>();

		// Add the array to list
		Collections.addAll(list, array);

		// Return the converted List
		return list;
	}

		public static void main(String args[])
	{
		// Create an Array
		String laptopsArray[]= { "Chromebook", "DELL", "Apple", "HP", "Toshiba" };

		// Print the Array
		System.out.println("Array: "+ Arrays.toString(array laptopsArray

		// convert the Array to List
		List<String> laptopsList = convertArrayToList(laptopsArray);

		// Print the List
		System.out.println("List of Laptops: " + laptopsList);
	}
}

Exemple :Utilisation de l'API de flux Java 8

// Java Program to convert
// Array to List in Java 8

import java.util.*;
import java.util.stream.*;

class Codeunderscored {

	// Generic function responsible for converting an array to a list
	public static <T> List<T> codeConvertArrayToList(T array[])
	{
		// list creation from an array
		return Arrays.stream(array).collect(
			Collectors.toList());
	}

		public static void main(String args[])
	{
		// Creation of an Array
		String laptopsArray[]= { "Chromebook", "DELL", "Apple", "HP", "Toshiba" };

		// Print the Array
		System.out.println("Array: "+ Arrays.toString(array laptopsArray

		// convert the Array to List
		List<String> laptopsList = convertArrayToList(laptopsArray);

		// Print the List
		System.out.println("List of Laptops: " + laptopsList);
	}
}

                                                      

Exemple :Utilisation de Guava Lists.newArrayList()

// Java Program to convert
// Array to List in Java 8

import static com.google.common.collect.Lists.*;

import java.util.*;
import java.util.stream.*;

class Codeunderscored {

	// Generic function responsible for converting an array to a list
	public static <K> List<K> convertArrayToList(K array[])
	{
		// creation of a list from the Array
		return Lists.newArrayList(array);
	}

		public static void main(String args[])
	{
		// Create an Array
		String laptopsArray[]= { "Chromebook", "DELL", "Apple", "HP", "Toshiba" };

		// Print the Array
		System.out.println("Array: "+ Arrays.toString(array laptopsArray

		// convert the Array to List
		List<String> laptopsList = convertArrayToList(laptopsArray);

		// Print the List
		System.out.println("List of Laptops: " + laptopsList);
	}
}

Conclusion

Un tableau pointe vers une collection de variables de type similaire avec un nom commun. Selon la définition du tableau, il peut contenir des types de données et des objets primitifs. Les valeurs réelles des types de données primitifs sont stockées dans des régions de mémoire contiguës. Les objets réels sont stockés dans une section de tas pour les objets d'une classe.

La collection a une interface enfant appelée List. Ce n'est pas seulement une collection triée d'objets, mais il peut également stocker des valeurs en double. De plus, la liste prend en charge l'accès positionnel et l'insertion de membres car l'ordre d'insertion est préservé. En outre, les classes ArrayList, LinkedList, Vector et Stack implémentent l'interface de liste.

La classe Java Arrays a quelques méthodes utiles. Arrays.asList() est une méthode utilitaire qui nous permet de convertir un tableau d'objets en une liste d'objets. Les exemples que nous avons couverts dans cet article montrent comment convertir un tableau en objet de liste. Vous pouvez également utiliser d'autres approches :la méthode native, l'utilisation de la méthode Collections.addAll(), l'utilisation de l'API Java 8 Stream et l'utilisation de la méthode Guava Lists.newArrayList().