java - remplir - Créer un tableau à partir d'un tableau




tableau d'objet java (20)

J'ai un tableau qui est initialisé comme:

Element[] array = {new Element(1), new Element(2), new Element(3)};

Je voudrais convertir ce tableau en objet de la classe ArrayList.

ArrayList<Element> arraylist = ???;

Une autre solution Java8 (j'ai peut-être manqué la réponse parmi le grand ensemble. Si c'est le cas, mes excuses). Cela crée une ArrayList (par opposition à une liste) c'est-à-dire que l'on peut supprimer des éléments

package package org.something.util;

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

public class Junk {

    static <T> ArrayList<T>  arrToArrayList(T[] arr){
        return Arrays.asList(arr)
            .stream()
            .collect(Collectors.toCollection(ArrayList::new));
    }

    public static void main(String[] args) {
        String[] sArr = new String[]{"Hello", "cruel", "world"};
        List<String> ret = arrToArrayList(sArr);
        // Verify one can remove an item and print list to verify so
        ret.remove(1);
        ret.stream()
            .forEach(System.out::println);
    }
}

La sortie est ...
Bonjour
monde


Java 9

En Java 9 , vous pouvez utiliser la méthode de fabrique statique List.of afin de créer un littéral List . Quelque chose comme ce qui suit:

List<Element> elements = List.of(new Element(1), new Element(2), new Element(3));

Cela renverrait une liste immutable contenant trois éléments. Si vous voulez une liste mutable , transmettez cette liste au constructeur ArrayList :

new ArrayList<>(List.of(// elements vararg))

PEC 269: Méthodes de fabrique de commodité pour les collections

JEP 269 fournit des méthodes de fabrique pratiques pour l’ API Java Collections . Ces méthodes d'usine statiques immuables sont intégrées aux interfaces List , Set et Map dans Java 9 et versions ultérieures.


Comme cette question est assez ancienne, cela me surprend que personne n'ait suggéré la forme la plus simple à ce jour:

List<Element> arraylist = Arrays.asList(new Element(1), new Element(2), new Element(3));

À partir de Java 5, Arrays.asList() prend un paramètre varargs et vous n'avez pas à construire le tableau explicitement.


Déjà tout le monde a fourni assez de bonne réponse à votre problème. Maintenant, parmi toutes les suggestions, vous devez décider lequel correspondra à vos besoins. Il existe deux types de collection que vous devez connaître. L'une est une collection non modifiée et l'autre une collection qui vous permettra de modifier l'objet ultérieurement.

Je vais donc vous donner un exemple concis dans deux cas d’utilisation.

  • Création de collection immuable :: Lorsque vous ne souhaitez pas modifier l'objet de collection après la création

    List<Element> elementList = Arrays.asList(array)

  • Création de collection modifiable: Lorsque vous souhaitez modifier l'objet de collection créé après la création.

    List<Element> elementList = new ArrayList<Element>(Arrays.asList(array));


Donné:

Element[] array = new Element[] { new Element(1), new Element(2), new Element(3) };

La réponse la plus simple est de faire:

List<Element> list = Arrays.asList(array);

Cela fonctionnera bien. Mais quelques mises en garde:

  1. La liste renvoyée par asList a une taille fixe . Ainsi, si vous voulez pouvoir ajouter ou supprimer des éléments de la liste renvoyée dans votre code, vous devez l'envelopper dans un nouvel ArrayList . Sinon, vous obtiendrez une UnsupportedOperationException .
  2. La liste renvoyée par asList() est sauvegardée par le tableau d'origine. Si vous modifiez le tableau d'origine, la liste sera également modifiée. Cela peut être surprenant.

Donné:

Element[] array = new Element[] { new Element(1), new Element(2), new Element(3) };

Utilisation:

List<Element> listArray = Arrays.asList(array);

La façon la plus simple de le faire est d’ajouter le code suivant. Essayé et testé.

String[] Array1={"one","two","three"};
ArrayList<String> s1= new ArrayList<String>(Arrays.asList(Array1));

Même s'il existe de nombreuses réponses parfaitement écrites à cette question, je vais ajouter mes contributions.

Disons que vous avez Element[] array = { new Element(1), new Element(2), new Element(3) };

Nouvel ArrayList peut être créé des manières suivantes

ArrayList<Element> arraylist_1 = new ArrayList<>(Arrays.asList(array));
ArrayList<Element> arraylist_2 = new ArrayList<>(
    Arrays.asList(new Element[] { new Element(1), new Element(2), new Element(3) }));

// Add through a collection
ArrayList<Element> arraylist_3 = new ArrayList<>();
Collections.addAll(arraylist_3, array);

Et ils supportent très bien toutes les opérations de ArrayList

arraylist_1.add(new Element(4)); // or remove(): Success
arraylist_2.add(new Element(4)); // or remove(): Success
arraylist_3.add(new Element(4)); // or remove(): Success

Mais les opérations suivantes ne renvoient qu’une vue Liste d’un tableau ArrayList et non un tableau ArrayList réel.

// Returns a List view of array and not actual ArrayList
List<Element> listView_1 = (List<Element>) Arrays.asList(array);
List<Element> listView_2 = Arrays.asList(array);
List<Element> listView_3 = Arrays.asList(new Element(1), new Element(2), new Element(3));

Par conséquent, ils donneront une erreur en essayant de créer des opérations ArrayList

listView_1.add(new Element(4)); // Error
listView_2.add(new Element(4)); // Error
listView_3.add(new Element(4)); // Error

Plus sur la représentation de liste de link de tableau.


Selon la question, la réponse à l'aide de Java 1.7 est:

ArrayList<Element> arraylist = new ArrayList<Element>(Arrays.<Element>asList(array));

Cependant, il est préférable de toujours utiliser l'interface:

List<Element> arraylist = Arrays.<Element>asList(array);

Si le tableau est de type primitif, les réponses données ne fonctionneront pas. Mais depuis Java 8, vous pouvez utiliser:

int[] array = new int[5];
Arrays.stream(array).boxed().collect(Collectors.toList());

Une autre méthode simple consiste à ajouter tous les éléments du tableau à une nouvelle liste de tableaux à l’aide d’une boucle for-each.

ArrayList<Element> list = new ArrayList<>();

for(Element e : array)
    list.add(e);

Une autre manière (bien que essentiellement équivalente à la new ArrayList(Arrays.asList(array)) solution new ArrayList(Arrays.asList(array)) performances:

Collections.addAll(arraylist, array);

Vous avez probablement juste besoin d'une liste, pas d'une liste de tableaux. Dans ce cas, vous pouvez simplement faire:

List<Element> arraylist = Arrays.asList(array);

Vous pouvez aussi le faire avec stream en Java 8.

 List<Element> elements = Arrays.stream(array).collect(Collectors.toList()); 

Vous pouvez le faire en Java 8 comme suit

ArrayList<Element> list = (ArrayList<Element>)Arrays.stream(array).collect(Collectors.toList());

Vous pouvez le faire facilement avec l'aide de Arrays.asList (arrayObj);

Element[] array = {new Element(1), new Element(2), new Element(3)};
ArrayList<Element> arraylist =Arrays.asList(array);

(ancien fil, mais seulement 2 centimes car aucun ne mentionne Guava ou d’autres libs et quelques autres détails)

Si vous le pouvez, utilisez de la goyave

Cela vaut la peine de souligner la manière Goyave, qui simplifie grandement ces manigances:

Usage

Pour une liste immuable

Utilisez la classe copyOf() et copyOf() méthodes de fabrique of() et copyOf() (les éléments ne peuvent pas être null) :

List<String> il = ImmutableList.of("string", "elements");  // from varargs
List<String> il = ImmutableList.copyOf(aStringArray);      // from array

Pour une liste modifiable

Utilisez la classe Lists et ses méthodes de fabrique newArrayList() :

List<String> l1 = Lists.newArrayList(anotherListOrCollection);    // from collection
List<String> l2 = Lists.newArrayList(aStringArray);               // from array
List<String> l3 = Lists.newArrayList("or", "string", "elements"); // from varargs

Veuillez également noter les méthodes similaires pour d'autres structures de données dans d'autres classes, par exemple dans Sets .

Pourquoi goyave?

L'attraction principale pourrait être de réduire l'encombrement dû aux génériques pour la sécurité des types, car l'utilisation des méthodes de la fabrique de goyave permet d'inférer les types la plupart du temps. Cependant, cet argument a moins d’eau puisque Java 7 est arrivé chez le nouvel opérateur diamantaire.

Mais ce n’est pas la seule raison (et Java 7 n’est pas encore partout): la syntaxe abrégée est également très pratique, et les initialiseurs de méthodes, comme on le voit ci-dessus, permettent d’écrire du code plus expressif. Vous faites en un seul appel Guava ce qui prend 2 avec les Collections Java actuelles.

Si vous ne pouvez pas ...

Pour une liste immuable

Utilisez la classe Arrays du JDK et sa méthode de fabrique asList() , entourée d'un Collections.unmodifiableList() :

List<String> l1 = Collections.unmodifiableList(Arrays.asList(anArrayOfElements));
List<String> l2 = Collections.unmodifiableList(Arrays.asList("element1", "element2"));

Notez que le type renvoyé pour asList() est une List utilisant une implémentation ArrayList concrète, mais ce n'est PAS java.util.ArrayList . C'est un type interne, qui émule une ArrayList mais référence en réalité directement le tableau transmis et le rend "écrit à travers" (les modifications sont reflétées dans le tableau).

Il interdit les modifications via certaines des méthodes de l'API List en développant simplement un AbstractList (ainsi, l'ajout ou la suppression d'éléments n'est pas pris en charge), mais il permet aux appels à set() de remplacer des éléments. Ainsi, cette liste n'est pas vraiment immuable et un appel à asList() doit être asList() avec Collections.unmodifiableList() .

Voir l'étape suivante si vous avez besoin d'une liste mutable.

Pour une liste modifiable

Comme ci-dessus, mais enveloppé d'une java.util.ArrayList réelle:

List<String> l1  = new ArrayList<String>(Arrays.asList(array));    // Java 1.5 to 1.6
List<String> l1b = new ArrayList<>(Arrays.asList(array));          // Java 1.7+
List<String> l2  = new ArrayList<String>(Arrays.asList("a", "b")); // Java 1.5 to 1.6
List<String> l2b = new ArrayList<>(Arrays.asList("a", "b"));       // Java 1.7+

À des fins éducatives: le bon vieux manuel

// for Java 1.5+
static <T> List<T> arrayToList(final T[] array) {
  final List<T> l = new ArrayList<T>(array.length);

  for (final T s : array) {
    l.add(s);
  }
  return (l);
}

// for Java < 1.5 (no generics, no compile-time type-safety, boo!)
static List arrayToList(final Object[] array) {
  final List l = new ArrayList(array.length);

  for (int i = 0; i < array.length; i++) {
    l.add(array[i]);
  }
  return (l);
}

Pour convertir un tableau en ArrayList, les développeurs font souvent ceci:

List<String> list = Arrays.asList(arr);// this is wrong way..

Arrays.asList() renverra un ArrayList qui est une private static class inside Arrays , ce n'est pas la classe java.util.ArrayList. The java.util.Arrays.ArrayList classe The java.util.Arrays.ArrayList a des méthodes set(), get(), contains() , mais ne dispose d'aucune méthode pour ajouter des éléments; sa taille est donc corrigée. Pour créer une véritable ArrayList, vous devez faire:

ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(arr));

Le constructeur de ArrayList peut accepter un type Collection , qui est également un super type pour java.util.Arrays.ArrayList


// Guava
import com.google.common.collect.ListsLists
...
List<String> list = Lists.newArrayList(aStringArray); 

new ArrayList<>(Arrays.asList(array))




type-conversion