Java >> Tutoriel Java >  >> Java

Convertir une liste en tableau en Java

Java

En Java, il existe de nombreuses instances où vous devez transformer une liste en tableau. Par exemple, une fonction n'accepte qu'un tableau comme paramètre au lieu d'une collection.

L'interface Liste se charge du suivi de la commande de la collection. De plus, ce dernier est l'interface enfant d'une collection. C'est une collection triée d'objets qui peuvent 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é. Maintenant que nous avons reçu une liste de chaînes, qu'il s'agisse d'une LinkedList ou d'une ArrayList, notre objectif est de la convertir en un tableau de chaînes en Java en utilisant diverses méthodes.

Méthodes

  • La méthode toArray() est utilisée
  • La méthode get() est utilisée
  • Présentation des flux dans Java 8

méthode toArray()

Cette méthode renvoie un tableau Object[] dont les éléments sont dans le même ordre que les éléments de la liste. Lors de l'exécution de certaines actions, le casting est utilisé pour indiquer le type de chaque élément.

C'est une autre technique pour créer un tableau à partir d'une liste. Nous pouvons facilement convertir une liste en tableau en utilisant la méthode toArray(). De plus, la méthode toArray() renvoie un tableau contenant tous les éléments de la liste. Les entrées du tableau renvoyé sont dans le même ordre que celles de la liste.

La méthode toArray() est disponible sur l'objet List. Cette fonction prend un tableau vide comme paramètre et convertit la liste actuelle en tableau avant de l'insérer dans le tableau spécifié. Cette approche peut être divisée en deux catégories.

  • toArray()
  • versTableau(T[] arr)

La fonction toArray() de l'interface List a la syntaxe suivante :

public <T> T[] toArray(T[] a)

La méthode toArray() prend un tableau en entrée ou aucun et produit un tableau contenant tous les membres de la liste. Regardons un autre exemple de conversion d'une liste en tableau pour voir comment vous pouvez utiliser la méthode toArray() de la liste. Pour convertir un objet List en tableau, utilisez le code suivant.

  • Faites-en un objet List.
  • Ajoutez quelques extras (éléments).
  • Créez un tableau vide de la même taille que la ArrayList que vous venez de créer.
  • Ignorer le tableau créé ci-dessus en tant qu'entrée de la fonction toArray() lors de la conversion de la liste en tableau.
  • La dernière étape consiste à imprimer le contenu du tableau.

Les exemples ci-dessous illustrent la conversion d'une liste de chaînes et d'une liste d'entiers en un tableau.

Convertir une liste en tableau en Java (avec exemples)

import java.util.ArrayList;

public class ListToArrayConversion {
   public static void main(String args[]){
      ArrayList<String> computerList = new ArrayList<String>();
      computerList.add("HP");
      computerList.add("DELL");
      computerList.add("Chrome Book");

      System.out.println("List Contents ::"+list);
      String[] theArray = new String[list.size()];
      computerList.toArray(theArray);

      for(int i=0; i<myArray.length; i++){
         System.out.println("The item at the index "+i+" is ::"+theArray[i]);
      }
   }
}

Exemple :Conversion d'une liste en tableau de chaînes en Java

import java.util.ArrayList;
import java.util.List;

public class ConvertingArrayListToArray {
    public static void main(String[] args) {
        List<String> fruitsList = new ArrayList<String>();
        fruitsList.add("Mango");
        fruitsList.add("Water Melon");
        fruitsList.add("Oranges");

        String[] fruitsArray = new String[itemList.size()];
        finalArray = fruitsList.toArray(fruitsArray);

        for(String s : finalArray)
            System.out.println(s);
    }
}

Nous pouvons convertir une liste d'entiers en un tableau d'entiers en utilisant la même méthode :

Exemple :Conversion d'une liste en tableau d'entiers en Java

import java.util.ArrayList;
import java.util.List;

public class ConvertArrayListToArray {
    public static void main(String[] args) {
        List<Integer> listOfIntegers = new ArrayList<Integer>();
        listOfIntegers.add(99);
        listOfIntegers.add(67);
        listOfIntegers.add(28);

        Integer[] arrayOfIntegers = new Integer[listOfIntegers.size()];
        finalArray = listOfIntegers.toArray(arrayOfIntegers);

        for(Integer i : finalArray)
            System.out.println(i);
    }
}

Exemple :Création d'une classe pour convertir une liste en tableau

import java.io.*;  
import java.util.LinkedList;  
import java.util.List;  

class CodeConvertListToArray {  

  // The programs main() method

  public static void main(String[] args)  
  {  
    // creation of a linked list through the declaration of an object of List  
    List<String> namesList = new LinkedList<String>();  

    // using the lists's add() method to add elements in the linked list  
    namesList.add("Joan");  
    namesList.add("Brian");  
    namesList.add("Cartoon");  
    namesList.add("Mike");  
    namesList.add("Thompson");  

    // using the toArray() method for converting a list into an array  
    String[] arrayOfNames = namesList.toArray(new String[0]);  

    // printing every element in the given array  
    System.out.println("After converting List into an Array");  
    for (int j = 0; j < arrayOfNames.length; j++) {  
      System.out.println((j+1)+" arrays element  is "+arrayOfNames[j]);  
    }  
  }   
}

versTableau(T[] arr)

Cette forme de la même technique accepte un tableau qui a déjà été défini comme paramètre.

Lorsque la taille du tableau est supérieure ou égale à la taille de la liste, les éléments de la liste sont ajoutés au tableau. Un nouveau tableau sera construit et rempli si ce n'est pas le cas. D'autre part, la conversion n'est pas nécessaire car le type du paramètre donne le type du tableau renvoyé. Si un élément de la liste ne parvient pas à être converti dans le type donné, une ArrayStoreException est produite.

import java.util.ArrayList;

public class ListToArray {

	public static void main(String[] args) {
    // A list of size 4 to be converted:
		ArrayList<Integer> list = new ArrayList<>();
		list.add(2);
		list.add(3);
		list.add(4);
		list.add(5);
		
    // Declaring an array of size 4:
		Integer[] arr = new Integer[4];
		
    // Passing the declared array as the parameter:
    list.toArray(arr);
		
    // Printing all elements of the array:
    System.out.println("Printing 'arr':");
		for(Integer i: arr)
      System.out.println(i);

    // Declaring another array of insufficient size:
    Integer[] arr2 = new Integer[3];

    // Passing the array as the parameter:
    Integer[] arr3 = list.toArray(arr2);

    // Printing the passed array:
    System.out.println("\n'arr2' isn't filled because it is small in size:");
    for(Integer i: arr2)
      System.out.println(i);
    
    // Printing the newly allocated array:
    System.out.println("\n'arr3' references the newly allocated array:");
    for(Integer i: arr3)
      System.out.println(i);
	}
}

Un tableau de chaînes à lister

Vous pouvez également revenir d'un tableau à une liste. Nous utilisons Arrays.asList pour accomplir cela. Considérez le scénario suivant :

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ConvertingArrayToList {
    public static void main(String[] args) {
        String[] subjectsArray = {"Introduction to Programming", "Data structures and algorithms", "Advanced database management system", "Computer Ethics"};
        List<String> subjectsList = new ArrayList(Arrays.asList(subjectsArray));

        for (String subjecItem : subjectsList) {
            System.out.println(subjecItem);
        }
    }
}

méthode get()

La méthode get() est l'un des processus les plus simples pour convertir une liste en tableau. Nous pouvons maintenant accéder à tous les éléments de la liste un par un et les ajouter à un tableau. Le but ici est d'utiliser la méthode get(). Nous pouvons utiliser la méthode list ci-dessous pour obtenir tous les éléments et les insérer dans un tableau.

Type de retour :l'élément de la liste à l'index spécifié.

La fonction get() de l'interface List a la syntaxe suivante :

public E get(int index)

L'élément à la position indiquée dans la liste est renvoyé par la méthode get(). Regardons un exemple de conversion d'une liste en tableau pour voir comment nous pouvons utiliser la méthode get() de la liste.

Exemple :programme Java pour convertir une liste en tableau

// Using get() method in a loop

// Importing required classes
import java.io.*;
import java.util.LinkedList;
import java.util.List;

// Main class
class Codeunderscored {

	// Main driver method
	public static void main(String[] args)
	{

		// Creating a LinkedList of string type by
		// declaring object of List
		List<String> listOfProgrammingLanguagues = new LinkedList<String>();

		// Adding custom element to LinkedList
		// using add() method
		listOfProgrammingLanguagues.add("PHP");
		listOfProgrammingLanguagues.add("C++");
		listOfProgrammingLanguagues.add("Python");
		listOfProgrammingLanguagues.add("Java");

		// Storing it inside array of strings
		String[] arrVal = new String[list.size()];

		// Conversion of an ArrayList to Array using the get() method
		for (int i = 0; i < listOfProgrammingLanguagues.size(); i++)
			arrVal[i] = listOfProgrammingLanguagues.get(i);

		// print the given elements of array on the console
		for (String str : arr)
			System.out.print( str + " ");
	}
}

Exemple :Classe pour convertir une liste en tableau

import java.io.*;  
    import java.util.LinkedList;  
    import java.util.List;  

    // create ListToArrayConversionExample class to convert a list into an array  
    class ListToArrayConversionExample {  
        // The programs main() method 
        public static void main(String[] args)  
        {  
             // creation of a  linked list through the declaration of an object of List  
             List<String> javaStudents = new LinkedList<String>();  
             // using the add() method of the list to add elements in the linked list  
             javaStudents.add("Ann");  
             javaStudents.add("Abraham");  
             javaStudents.add("Winny");  
             javaStudents.add("Bob");  
             javaStudents.add("Princes");  

             // get the lists' size and store it into lenOfList variable  
             int lenOfList = javaStudents.size();  
            
	 // declaration and the initialization of the array of type string to store list elements  
             String[] javaStudentsArray = new String[ lenOfList ];  
             // iterating through the list through the for loop and add all the elements into javaStudentsArray one by one to convert names list into an array  
             for (int i = 0; i < len; i++)  
                 javaStudentsArray[i] = javaStudents.get(i);  
             // print all the elements of the array  
             System.out.println("Conversion of a List into an Array");  
             for (int j = 0; j < javaStudentsArray.length; j++) {  
                 System.out.println((j+1)+" array element is : "+javaStudentsArray[j]);  
             }  
        }   
    }

Utilisation de la classe Stream - introduite dans Java8

Une autre approche consiste à convertir une liste en tableau, à l'aide de la fonctionnalité Stream introduite dans Java8. La fonction toArray() de l'interface List a la syntaxe suivante :

public <T> T[] toArray(T[] a)

La méthode toArray() prend soit un tableau, soit aucun comme argument. De plus, il renvoie un tableau contenant tous les éléments de la liste. La méthode Stream.toArray() renvoie un tableau contenant les entrées de flux de la méthode List.stream(). Il existe deux options pour le faire :

Utilisation de Streams conjointement avec une référence de méthode

List<String> languageList = Arrays.asList("Python","Kotlin", "C++","JavaScript", "Java");
String[] languageArray = languageList.stream().toArray(String[]::new);
System.out.println(Arrays.toString(languageArray));

Utiliser des expressions lambda avec des flux

List<String> languageList = Arrays.asList("Python","Kotlin", "C++","JavaScript", "Java");
String[] languageArray = languageList.stream().toArray(n -> new String[n]);
System.out.println(Arrays.toString(languageArray));

Regardons un autre exemple de conversion d'une liste en tableau pour voir comment vous pouvez utiliser la méthode toArray() de la liste.

import java.io.*;  
import java.util.LinkedList;  
import java.util.List;  

//create ListToArrayConversion class to convert a list into an array  
class ListToArrayConversion {  
  // The programs main() method
  public static void main(String[] args)  
  {  
    // creation of a linked list through the declaration of an object of List  
    List<String> listOfNames = new LinkedList<String>();  
    // using the lists's add() method to add elements in the linked list  

    listOfNames.add("Jonah");  
    listOfNames.add("Mike");  
    listOfNames.add("Ann");  
    listOfNames.add("Faith");  
    listOfNames.add("Mery");  

    // using the stream() method to convert a list into an array  
    String[] arrayOfNames = listOfNames.stream().toArray(String[] ::new);  

    // print all the elements of the array  
    System.out.println("Results after converting a List into an Array");  
    for (int j = 0; j < arrayOfNames.length; j++) {  
      System.out.println((j+1)+" The array's element is: "+arrayOfNames[j]);  
    }  
  }   
}

Exemple :Programme illustrant la conversion de List en Array à l'aide de stream

// Importing utility classes
import java.util.*;

// Main class
class CodeunderscoredStream {

	// Main driver method
	public static void main(String[] args)
	{

		// Creating an empty LinkedList of string type
		List<String> listLaptops = new LinkedList<String>();

		// Adding elements to above LinkedList
		// using add() method
		listLaptops.add("HP");
		listLaptops.add("Dell");
		listLaptops.add("Apple");
		listLaptops.add("IBM");
		listLaptops.add("Lenovo");
		listLaptops.add("Chrome Book");

		// Storing size of List
		int listSize = listLaptops.size();

		// Converting List to array via scope resolution
		// operator using streams
		String[] arrOfStreams = listLaptops.stream().toArray(String[] ::new);

		// Printing elements of array
		// using enhanced for loop
		for (String str : arrOfStreams)
			System.out.print(str + " ");
	}
}

Utiliser la bibliothèque de goyave

Il existe deux variantes d'utilisation de la bibliothèque de goyave comme suit.

La classe FluentIterable dans la bibliothèque Guava

Le FluentIterable est une API Iterable étendue qui fournit des fonctionnalités similaires à la bibliothèque de flux de Java 8 légèrement différemment. L'objectif est de créer un itérable fluide qui encapsule une liste itérable et produit un tableau avec tous ses éléments dans la séquence d'itération.

List<String> languagesList = Arrays.asList("Python","Kotlin", "C++","JavaScript", "Java");
String[] languageArray = FluentIterable.from(languagesList).toArray(String.class);
System.out.println(Arrays.toString(languageArray));

La classe Iterables dans la bibliothèque Guava

La fonction toArray() de la classe Iterables de Guava copie les éléments d'un itérable dans un tableau.

List<String> languagesList = Arrays.asList("Python","Kotlin", "C++","JavaScript", "Java");
String[] languageArray = Iterables.toArray(languagesList, String.class);
System.out.println(Arrays.toString(languageArray));

Exemple :utilisation de goyave

@Test
public void givenUsingGuava() {
    Integer[] numArray = { 10, 11, 12, 13, 14, 15 };
    List<Integer> resultantList = Lists.newArrayList(numArray);
}

Utilisation des collections communes

Enfin, nous utiliserons CollectionUtils d'Apache Commons Collections. Pour remplir les éléments d'un tableau dans une List vide, utilisez l'API addAll :

@Test
public void usingCommonsCollections() {
    Integer[] numArray = { 10, 11, 12, 13, 14, 15 };
    List<Integer> resultantList = new ArrayList<>(6);
    CollectionUtils.addAll(resultantList, numArray);
}

Conclusion

En Java, la conversion entre List et Array est une tâche typique. La fonction .toArray() est le moyen le plus fin et le plus simple de transformer une liste en tableau en Java. De même, nous pouvons utiliser la méthode Arrays.asList() pour reconvertir une List en Array. De plus, nous pouvons également utiliser la méthode stream() de l'API Stream pour convertir une liste en tableau dans Java 8 et versions ultérieures.

De plus, en Java, les méthodes get() et toArray() transforment généralement une liste en tableau. Par rapport aux méthodes get() et toArray(), la technique stream() est inefficace.


Balise Java