Créer un tableau à partir d'un tableau
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 = ???;
new ArrayList<>(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:
- La liste renvoyée par asList a taille fixe . Ainsi, si vous souhaitez pouvoir ajouter ou supprimer des éléments de la liste renvoyée dans votre code, vous devez l’envelopper dans une nouvelle
ArrayList. Sinon, vous aurez uneUnsupportedOperationException. - 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.
(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 les méthodes de fabrique ImmutableList _ _ _ et of() et copyOf() (les éléments ne peuvent pas être nuls):
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é de type, car l'utilisation de Guava méthodes d'usine permet de déduire 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 de goyave ce qui prend 2 avec les collections Java actuelles.
Si tu ne peux 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 retourné pour asList() est une List utilisant une implémentation ArrayList concrète, mais ce n'est PASJava.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 méthodes de l'API List en développant simplement une AbstractList (donc, l'ajout ou la suppression d'éléments n'est pas pris en charge), mais il autorise les appels à set() pour remplacer des éléments. Ainsi, cette liste n'est pas vraiment immuable et un appel à asList() doit être entouré de Collections.unmodifiableList().
Voir l'étape suivante si vous avez besoin d'une liste mutable.
Pour une liste modifiable
Comme ci-dessus, mais entouré d'un Java.util.ArrayList réel:
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);
}
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));
A partir de Java 5, Arrays.asList() prend un paramètre varargs et vous n'avez pas à construire le tableau explicitement.
new ArrayList<T>(Arrays.asList(myArray));
Assurez-vous que myArray est du même type que T. Vous obtiendrez une erreur du compilateur si vous essayez de créer un List<Integer> à partir d'un tableau de int, par exemple.
Une autre manière (bien qu'équivalent essentiellement à la solution new ArrayList(Arrays.asList(array)):
Collections.addAll(arraylist, array);
Java 9
Dans 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 immuable 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 de fabrique statique immuable sont intégrées aux interfaces List , Set et Map de Java 9 et versions ultérieures.
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);
Une autre mise à jour, qui se termine presque en 2014, vous pouvez également le faire avec Java 8:
ArrayList<Element> arrayList = Stream.of(myArray).collect(Collectors.toCollection(ArrayList::new));
Quelques caractères seraient sauvegardés, s'il ne s'agissait que d'une List
List<Element> list = Stream.of(myArray).collect(Collectors.toList());
Si tu utilises :
new ArrayList<T>(Arrays.asList(myArray));
vous pouvez créez et remplissez deux listes! Remplir deux fois une grande liste est exactement ce que vous ne voulez pas faire, car cela créera un autre tableau Object[] chaque fois que la capacité doit être étendue.
Heureusement, la mise en œuvre du JDK est rapide et la fonction Arrays.asList(a[]) est très bien faite. Il crée une sorte de ArrayList nommée Arrays.ArrayList où les données Object [] pointent directement sur le tableau.
// in Arrays
@SafeVarargs
public static <T> List<T> asList(T... a) {
return new ArrayList<>(a);
}
//still in Arrays, creating a private unseen class
private static class ArrayList<E>
private final E[] a;
ArrayList(E[] array) {
a = array; // you point to the previous array
}
....
}
Le côté dangereux est que si vous modifiez le tableau initial, vous modifiez la liste! Es-tu sûr de vouloir ça? Peut-être que oui peut-être que non.
Sinon, la façon la plus compréhensible est de faire ceci:
ArrayList<Element> list = new ArrayList<Element>(myArray.length); // you know the initial capacity
for (Element element : myArray) {
list.add(element);
}
Ou, comme dit @glglgl, vous pouvez créer un autre ArrayList indépendant avec:
new ArrayList<T>(Arrays.asList(myArray));
J'aime utiliser Collections, Arrays ou Guava. Mais si cela ne vous convient pas ou si vous ne le sentez pas, écrivez simplement une autre ligne inélégante.
Dans Java 9, vous pouvez utiliser:
List<String> list = List.of("Hello", "World", "from", "Java");
List<Integer> list = List.of(1, 2, 3, 4, 5);
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);
// Guava
import com.google.common.collect.ListsLists
...
List<String> list = Lists.newArrayList(aStringArray);
Vous pouvez aussi le faire avec stream en Java 8.
List<Element> elements = Arrays.stream(array).collect(Collectors.toList());
Depuis Java 8, il existe un moyen plus simple de transformer:
public static <T> List<T> fromArray(T[] array) {
return Arrays.stream(array).collect(toList());
}
comme dit tout cela le fera
new ArrayList<>(Arrays.asList("1","2","3","4"));
et la méthode la plus récente pour créer un tableau est observableArrays
ObservableList: Liste permettant aux auditeurs de suivre les modifications lorsqu'elles se produisent.
pour Java SE, vous pouvez essayer
FXCollections.observableArrayList(new Element(1), new Element(2), new Element(3));
c’est selon Oracle Docs
observableArrayList () Crée une nouvelle liste observable vide qui est soutenue par un arraylist . observableArrayList (E ... items) Crée une nouvelle liste de tableaux observables avec des éléments ajoutés.
Mise à jour Java 9
aussi en Java 9 c'est un peu facile:
List<String> list = List.of("element 1", "element 2", "element 3");
Si nous voyons la définition de la méthode
Arrays.asList(), vous obtiendrez quelque chose comme ceci:public static <T> List<T> asList(T... a) //varargs are of T type.Donc, vous pouvez initialiser
arraylistcomme ceci:List<Element> arraylist = Arrays.asList(new Element(1),new Element(2),new Element(3));Remarque : chaque
new Element(int args)sera traité comme un objet individuel et peut être passé comme unvar-args.Il pourrait aussi y avoir une autre réponse à cette question.
Si vous voyez une déclaration pour la méthodeJava.util.Collections.addAll(), vous obtiendrez quelque chose comme ceci:public static <T> boolean addAll(Collection<? super T> c, T... a);Donc, ce code est aussi utile pour le faire
Collections.addAll(arraylist, array);
Un autre moyen 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);
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());
Nous pouvons facilement convertir un tableau en ArrayList. Nous utilisons la méthode addAll() de l'interface de Collection pour copier le contenu d'une liste à une autre.
Arraylist arr = new Arraylist();
arr.addAll(Arrays.asList(asset));
Utilisez le code suivant pour convertir un tableau d'éléments en une liste de tableaux.
Element[] array = {new Element(1), new Element(2), new Element(3)};
ArrayList<Element>elementArray=new ArrayList();
for(int i=0;i<array.length;i++) {
elementArray.add(array[i]);
}
Même s'il existe de nombreuses réponses parfaitement écrites à cette question, j'ajouterai 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, et non un tableau 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 faire 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 tableau lien .
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));
Une autre solution Java8 (j'ai peut-être manqué la réponse parmi le grand ensemble. Si oui, mes excuses). Ceci 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
Vous pouvez le faire en Java 8 comme suit
ArrayList<Element> list = (ArrayList<Element>)Arrays.stream(array).collect(Collectors.toList());
Vous pouvez créer une ArrayList en utilisant Cactoos (je suis l’un des développeurs):
List<String> names = new StickyList<>(
"Scott Fitzgerald", "Fyodor Dostoyevsky"
);
Il n'y a aucune garantie que l'objet sera réellement de classe ArrayList. Si vous avez besoin de cette garantie, procédez comme suit:
ArrayList<String> list = new ArrayList<>(
new StickyList<>(
"Scott Fitzgerald", "Fyodor Dostoyevsky"
)
);
Utilisez le code ci-dessous
Element[] array = {new Element(1), new Element(2), new Element(3)};
ArrayList<Element> list = (ArrayList) Arrays.asList(array);
l'expression lambda générant une liste de typesArrayList<Element>
(1) sans distribution non vérifiée
(2) sans créer une seconde liste (avec, par exemple, asList())
ArrayList<Element> list = Stream.of( array ).collect( Collectors.toCollection( ArrayList::new ) );
La classe Arrays de Java 8 fournit une méthode stream () dont les versions surchargées acceptent les tableaux primitifs et les tableaux d’objets.
/**** Converting a Primitive 'int' Array to List ****/
int intArray[] = {1, 2, 3, 4, 5};
List<Integer> integerList1 = Arrays.stream(intArray).boxed().collect(Collectors.toList());
/**** 'IntStream.of' or 'Arrays.stream' Gives The Same Output ****/
List<Integer> integerList2 = IntStream.of(intArray).boxed().collect(Collectors.toList());
/**** Converting an 'Integer' Array to List ****/
Integer integerArray[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
List<Integer> integerList3 = Arrays.stream(integerArray).collect(Collectors.toList());
Voici les 3 façons .. peuvent être utiles,
Arrays.asList("yellow", "green","blue");
Collections.singletonList(new String[]{"yellow", "green","blue"});
Arrays.stream((new String[]{"yellow", "green", "blue"})).collect(Collectors.toList());
C'est un moyen clair pour ça
ArrayList<Element> arraylist = new ArrayList<>(Arrays.asList(array))