java - valor - Criar ArrayList da matriz




matriz dinamica java (20)

Outra solução Java8 (eu posso ter perdido a resposta entre o grande conjunto. Se assim for, minhas desculpas). Isso cria um ArrayList (em oposição a uma lista), ou seja, pode-se excluir elementos

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);
    }
}

Saída é ...
Olá
mundo

Eu tenho uma matriz que é inicializada como:

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

Eu gostaria de converter essa matriz em um objeto da classe ArrayList.

ArrayList<Element> arraylist = ???;

Java 9

No Java 9 , você pode usar o método de fábrica List.of estático para criar um literal de List . Algo como o seguinte:

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

Isso retornaria uma lista immutable contendo três elementos. Se você quiser uma lista mutável , passe essa lista para o construtor ArrayList :

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

JEP 269: Métodos de Fábrica de Conveniência para Coleções

O JEP 269 fornece alguns métodos de fábrica de conveniência para a API de Coleções Java . Esses métodos de fábrica estáticos imutáveis ​​são construídos nas interfaces List , Set e Map no Java 9 e posterior.


A maneira mais simples de fazer isso é adicionando o código a seguir. Tentei e testei.

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

Como essa pergunta é bem antiga, me surpreende que ninguém tenha sugerido a forma mais simples:

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

A partir do Java 5, Arrays.asList() usa um parâmetro varargs e você não precisa construir o array explicitamente.


Dado:

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

Usar:

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

De acordo com a pergunta, a resposta usando o java 1.7 é:

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

No entanto, é melhor sempre usar a interface:

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

Mesmo que haja muitas respostas perfeitamente escritas para essa pergunta, adicionarei minhas entradas.

Digamos que você tenha Element[] array = { new Element(1), new Element(2), new Element(3) };

New ArrayList pode ser criado das seguintes formas

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);

E eles suportam muito bem todas as operações da 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

Mas as operações a seguir retornam apenas uma visualização de lista de uma ArrayList e não uma ArrayList real.

// 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));

Portanto, eles vão dar erro ao tentar fazer algumas operações ArrayList

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

Mais sobre a representação da lista de link da matriz.


No Java 9 você pode usar:

List<String> list = List.of("Hello", "World", "from", "Java");
List<Integer> list = List.of(1, 2, 3, 4, 5);

Outra maneira (embora essencialmente equivalente à new ArrayList(Arrays.asList(array)) solução new ArrayList(Arrays.asList(array)) desempenho:

Collections.addAll(arraylist, array);

Outra maneira simples é adicionar todos os elementos da matriz a uma nova ArrayList usando um loop for-each.

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

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

Se a matriz for de um tipo primitivo, as respostas dadas não funcionarão. Mas desde o Java 8 você pode usar:

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

Se você usar :

new ArrayList<T>(Arrays.asList(myArray));

você pode criar e preencher duas listas! Preencher duas vezes uma lista grande é exatamente o que você não deseja fazer porque criará outro array Object[] toda vez que a capacidade precisar ser estendida.

Felizmente, a implementação do JDK é rápida e o Arrays.asList(a[]) é muito bem feito. Ele cria um tipo de ArrayList chamado Arrays.ArrayList onde os dados de Object [] apontam diretamente para o array.

// 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
    }
    ....
}

O lado perigoso é que, se você alterar o array inicial, você muda a lista! Tem certeza que quer isso? Talvez sim talvez não.

Se não, a maneira mais compreensível é fazer isso:

ArrayList<Element> list = new ArrayList<Element>(myArray.length); // you know the initial capacity
for (Element element : myArray) {
    list.add(element);
}

Ou como disse @glglgl, você pode criar outro ArrayList independente com:

new ArrayList<T>(Arrays.asList(myArray));

Adoro usar Collections , Arrays ou goiaba. Mas se não se encaixa, ou você não sente, apenas escreva outra linha deselegante em seu lugar.



Você pode fazê-lo em java 8 da seguinte forma

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

Você provavelmente só precisa de uma lista, não uma ArrayList. Nesse caso, você pode apenas fazer:

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

Você também pode fazer isso com stream no Java 8.

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

(thread antigo, mas apenas 2 centavos, como nenhuma menção a goiaba ou outras libs e alguns outros detalhes)

Se você puder, use Goiaba

Vale a pena destacar o caminho da goiaba, o que simplifica bastante essas travessuras:

Uso

Para uma lista imutável

Use a classe ImmutableList e seus métodos de fábrica of() e copyOf() (elementos não podem ser nulos) :

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

Para uma lista mutável

Use a classe Lists e seus métodos factory 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

Por favor, observe também os métodos similares para outras estruturas de dados em outras classes, por exemplo, em Sets .

Por que goiaba?

A principal atração poderia ser reduzir a desordem devido a genéricos para segurança de tipo, já que o uso dos métodos da fábrica de Guava permite que os tipos sejam inferidos a maior parte do tempo. No entanto, este argumento tem menos água desde que o Java 7 chegou com o novo operador de diamante.

Mas não é a única razão (e o Java 7 ainda não está em todo lugar): a sintaxe abreviada também é muito útil, e os inicializadores de métodos, como visto acima, permitem escrever código mais expressivo. Você faz em uma chamada Guava o que leva 2 com as Coleções Java atuais.

Se você não pode ...

Para uma lista imutável

Use a classe Arrays do JDK e seu método factory asList() com um Collections.unmodifiableList() :

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

Observe que o tipo retornado para asList() é uma List usando uma implementação ArrayList concreta, mas NÃO é java.util.ArrayList . É um tipo interno, que emula um ArrayList mas na verdade faz referência direta ao array passado e o faz "escrever através de" (as modificações são refletidas no array).

Ele proíbe modificações por meio de alguns dos métodos da API List , simplesmente estendendo um AbstractList (assim, adicionar ou remover elementos não é suportado), no entanto, ele permite que chamadas para set() substituam elementos. Portanto, essa lista não é verdadeiramente imutável e uma chamada para asList() deve ser empacotada com Collections.unmodifiableList() .

Veja o próximo passo se você precisar de uma lista mutável.

Para uma lista mutável

O mesmo que acima, mas envolvido com um java.util.ArrayList real:

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+

Para fins educacionais: a boa e velha maneira manual

// 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);
}

Para converter uma matriz em uma ArrayList, os desenvolvedores geralmente fazem isso:

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

Arrays.asList() retornará um ArrayList que é uma private static class inside Arrays , não é a classe java.util.ArrayList. The java.util.Arrays.ArrayList classe The java.util.Arrays.ArrayList possui métodos set(), get(), contains() , mas não possui métodos para adicionar elementos, portanto, seu tamanho é fixo. Para criar uma ArrayList real, você deve fazer:

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

O construtor de ArrayList pode aceitar um tipo Collection , que também é um tipo super para java.util.Arrays.ArrayList


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

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






type-conversion