valores - matriz float java




Como converter uma matriz em um conjunto em Java (12)

Java 8

Temos a opção de usar o Stream também. Podemos obter fluxo de várias maneiras:

Set<String> set = Stream.of("A", "B", "C", "D").collect(Collectors.toCollection(HashSet::new));
System.out.println(set);

String[] stringArray = {"A", "B", "C", "D"};
Set<String> strSet1 = Arrays.stream(stringArray).collect(Collectors.toSet());
System.out.println(strSet1);

// if you need HashSet then use below option.
Set<String> strSet2 = Arrays.stream(stringArray).collect(Collectors.toCollection(HashSet::new));
System.out.println(strSet2);

O código-fonte de Collectors.toSet() mostra que os elementos são adicionados um a um a um HashSet mas a especificação não garante que seja um HashSet .

"Não há garantias sobre o tipo, mutabilidade, serializabilidade ou segurança de thread do conjunto retornado."

Por isso, é melhor usar a opção posterior. A saída é: [A, B, C, D] [A, B, C, D] [A, B, C, D]

Conjunto Imutável (Java 9)

O Java 9 introduziu o método de fábrica estática Set.of que retorna conjunto imutável para os elementos fornecidos ou a matriz.

@SafeVarargs
static <E> Set<E> of​(E... elements)

Verifique os Métodos Estáticos de Fábrica do Conjunto Imutável para obter detalhes.

Conjunto Imutável (Java 10)

Também podemos obter um conjunto imutável de duas maneiras:

  1. Set.copyOf(Arrays.asList(array))
  2. Arrays.stream(array).collect(Collectors.toUnmodifiableList());

O método Collectors.toUnmodifiableList() faz uso interno do Set.of introduzido no Java 9. Também verifique esta answer minha para mais.

Eu gostaria de converter uma matriz para um conjunto em Java. Existem algumas maneiras óbvias de fazer isso (ou seja, com um loop), mas eu gostaria de algo um pouco mais puro, algo como:

java.util.Arrays.asList(Object[] a);

Alguma ideia?


Algum tempo usando algumas bibliotecas padrão ajuda muito. Tente olhar para as coleções do Apache Commons . Neste caso, seus problemas são simplesmente transformados em algo como isto

String[] keys = {"blah", "blahblah"}
Set<String> myEmptySet = new HashSet<String>();
CollectionUtils.addAll(pythonKeywordSet, keys);

E aqui está o CollectionsUtils javadoc


Como isso:

Set<T> mySet = new HashSet<T>(Arrays.asList(someArray));

No Java 9+, se o conjunto não modificável estiver ok:

Set<T> mySet = Set.of(someArray);

No Java 10+, o parâmetro de tipo genérico pode ser inferido do tipo de componente de matrizes:

var mySet = Set.of(someArray);

Depois de fazer Arrays.asList(array) você pode executar Set set = new HashSet(list);

Aqui está um método de amostra, você pode escrever:

public <T> Set<T> GetSetFromArray(T[] array) {
    return new HashSet<T>(Arrays.asList(array));
}

Já houve muitas grandes respostas, mas a maioria delas não funciona com uma matriz de primitivos como ( int[] , byte[] , long[] , char[] , etc.)

No Java 8 e acima, coloque o array com algo como:

Integer[] boxedArr = Arrays.stream(arr).boxed().toArray(Integer[]::new);

Então, um fluxo simples pode convertê-lo em set:

Stream.of(boxedArr).collect(Collectors.toSet());

Java 8:

String[] strArray = {"eins", "zwei", "drei", "vier"};

Set<String> strSet = Arrays.stream(strArray).collect(Collectors.toSet());
System.out.println(strSet);
// [eins, vier, zwei, drei]

No Java 10 :

String[] strs = {"A", "B"};
Set<String> set = Set.copyOf(Arrays.asList(strs));

Set.copyOf retorna um Set não modificável contendo os elementos da Collection dada.

A Collection fornecida não deve ser null e não deve conter elementos null .


Rapidamente: você pode fazer:

// Fixed-size list
List list = Arrays.asList(array);

// Growable list
list = new LinkedList(Arrays.asList(array));

// Duplicate elements are discarded
Set set = new HashSet(Arrays.asList(array));

e reverter

// Create an array containing the elements in a list
Object[] objectArray = list.toArray();
MyClass[] array = (MyClass[])list.toArray(new MyClass[list.size()]);

// Create an array containing the elements in a set
objectArray = set.toArray();
array = (MyClass[])set.toArray(new MyClass[set.size()]);

Varargs vai funcionar também!

Stream.of(T... values).collect(Collectors.toSet());

new HashSet<Object>(Arrays.asList(Object[] a));

Mas acho que isso seria mais eficiente:

final Set s = new HashSet<Object>();    
for (Object o : a) { s.add(o); }         

Set<T> b = new HashSet<>(Arrays.asList(requiredArray));

Set<T> mySet = new HashSet<T>();
Collections.addAll(mySet, myArray);

Isso é Collections.addAll (java.util.Collection, T ...) do JDK 6.

Adicionalmente: e se o nosso array estiver cheio de primitivos?

Para o JDK <8, gostaria apenas de escrever o óbvio loop para fazer o wrap e add-to-set em um passo.

Para o JDK> = 8, uma opção atraente é algo como:

Arrays.stream(intArray).boxed().collect(Collectors.toSet());




set