Comment convertir un tableau en liste en Java ? (exemple de code)

Parfois, nous devons convertir le type tableau en type collection, car ce dernier est une structure de données plus puissante et java.util.List a de nombreuses fonctions que les tableaux ordinaires ne prennent pas en charge. Par exemple : nous pouvons facilement détecter si la liste contient une valeur spécifique grâce à la méthode intégrée de List. Voici quelques exemples de conversion d’un tableau en liste.

Convertir un tableau en liste via java.util.Arrays.asList()

La classe Arrays a une méthode pratique asList qui peut aider dans les tâches de conversion. Voici la syntaxe :

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

Remarque : les paramètres ne doivent pas nécessairement être des tableaux, des paramètres variables peuvent également être utilisés. Il peut créer un lis

public class Test {
   public static void main(String[] args) {
      List<String> myList = Arrays.asList("Apple");
   }
}

Le code ci-dessus créera une collection contenant un élément "Apple". On peut aussi faire ceci :

public class Test {
   public static void main(String[] args) {
      List<String> myList = Arrays.asList("Apple", "Orange");
   }
}

Cela générera un ensemble avec deux éléments "Apple", "Orange"

car c'est un paramètre variadique. Nous pouvons passer un tableau, et les éléments du tableau sont reconnus comme paramètres. Exemple :

public class Test {
   public static void main(String[] args) {
      String[] myArray = { "Apple", "Banana", "Orange" };
      List<String> myList = Arrays.asList(myArray);
      for (String str : myList) {
         System.out.println(str);
      }
   }
}

De cette façon, une collection String est créée. Le tableau myArray est ajouté. La collection myList comporte trois éléments. Voici le résultat :

Apple
Banana
Orange

Trap

Cette méthode a quelques problèmes. être un objet, pas un tableau de types primitifs. Par exemple :

public class Test {
   public static void main(String[] args) {
      int[] myArray = { 1, 2, 3 };
      List myList = Arrays.asList(myArray);
      System.out.println(myList.size());
   }
}

La sortie du code est 1. Pourquoi? Étant donné que la méthode asList attend un paramètre variadique d’un objet, mais que le paramètre transmis est un tableau de types primitifs, elle crée une collection de tableaux. Le seul élément de cette collection est donc myArray. Donc myList.get(0) renverra le même objet que myArray.

L'objet créé par asList() est de taille fixe

L'objet liste renvoyé par la méthode asList() est de taille fixe et ne peut pas en accueillir plus. Il existe de nombreux éléments, tels que :

public class Test {
   public static void main(String[] args) {
      String[] myArray = { "Apple", "Banana", "Orange" };
      List<String> myList = Arrays.asList(myArray);
      myList.add("Guava");
   }
}

Le résultat est le suivant :

Exception in thread "main" java.lang.UnsupportedOperationException
    at java.util.AbstractList.add(AbstractList.java:148)
    at java.util.AbstractList.add(AbstractList.java:108)
    at Test.main(Test.java:8)

Comme myList a une longueur fixe, d'autres éléments ne peuvent pas être ajoutés.

Parce que l'objet List renvoyé par cette méthode n'est pas l'ArrayList sous le package java.util, mais le type ArrayList dans Arrays. La classe n'implémente pas les méthodes add, revmove et clear, donc tout appel visant à modifier la structure de la collection échouera.

Convertir le type de tableau de base en Liste

Comme mentionné ci-dessus. Passer un tableau de types de base à la méthode asList ne fonctionne pas. Une solution sans introduire une bibliothèque tierce consiste à transmettre le flux Java8. L'exemple est le suivant :

public class Test {
   public static void main(String[] args) {
      int[] intArray = { 5, 10, 21 };
      List myList = Arrays.stream(intArray).boxed()
            .collect(Collectors.toList());
   }
}

Chaque élément du tableau est converti. du type int au type Integer (boxing), le tableau est converti en type List.

Convertir le tableau en une liste permettant d'ajouter des éléments

Comme mentionné dans la section piège ci-dessus, la méthode Arrays.asList() le fait ne prend pas en charge l'ajout ou la suppression de l'élément. Si vous ne souhaitez pas faire cela, voici les alternatives :

public class Test {
   public static void main(String[] args) {
      String[] myArray = { "Apple", "Banana", "Orange" };
      List<String> myList = new ArrayList<String>(Arrays.asList(myArray));
      myList.add("Guava");
   }
}

Ce code crée explicitement un nouvel objet ArrayList puis y ajoute les résultats de Arrays.asList. Parce que nous avons créé une ArrayList. Aucune restriction de suppression n'est donc ajoutée et il y a quatre éléments avant la fin de l'exécution du code ci-dessus. Ne vous attendez pas à ce que votre code lève des exceptions lors de son exécution.

Convertissez vous-même le groupe Array en liste

Parfois, il est préférable d'utiliser notre propre implémentation pour résoudre le problème. Ce qui suit est un exemple simple de conversion d'un tableau Java en liste :

public class Test {
   public static void main(String[] args) {
      String[] myArray = { "Apple", "Banana", "Orange" };
      List<String> myList = new ArrayList<String>();
      for (String str : myArray) {
         myList.add(str);
      }
      System.out.println(myList.size());
   }
}

La sortie attendue du code est 3. Parce que la collection a 3 éléments après l'exécution de la logique.

L'inconvénient de notre code est qu'il est plus long et que nous réinventons la roue. L’avantage est que nous pouvons nous adapter et personnaliser à mesure que nos besoins évoluent. Par exemple : dans le code suivant, chaque élément est ajouté deux fois à la liste

public class Test {
   public static void main(String[] args) {
      String[] myArray = { "Apple", "Banana", "Orange" };
      List<String> myList = new ArrayList<String>();
      for (String str : myArray) {
         myList.add(str);
         myList.add(str);
      }
      System.out.println(myList.size());
   }
}

La sortie est 6, car tous les éléments du tableau sont ajoutés deux fois. Voici un autre exemple de conversion d'un tableau de String en List :

public class Test {
   public static void main(String[] args) {
      String[] myArray = { "5", "6", "7" };
      List<Integer> myList = new ArrayList<Integer>();
      for (String str : myArray) {
         myList.add(Integer.valueOf(str));
      }
   }}

Analyse chaque chaîne du tableau et la convertit en entier correspondant. La liste résultante contiendra tous les entiers convertis.

Apprentissage recommandé : Tutoriel vidéo Java

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!