Tableau des éléments uniques?

Donné un tableau comme celui ci-dessous, je me demandais si il existe un moyen facile de transformer ce tableau dans un tableau avec les valeurs uniques?

C'est donné:

   numbers={5,5,4,3,1,4,5,4,5}

La transformer en une matrice de résultats comme ça, la préservation de l'ordre original:

   {5,1,2,3,4}
Est-il toujours triés? Oui, il y a un moyen facile, mais qu'avez-vous essayé?
Non, il n'est pas triée dans tous les cas.
docs.oracle.com/javase/7/docs/api/java/util/Set.html
L'ordre de la matrice résultante de la matière? E. g. si la commande à partir du premier tableau-elle être préservée?
Pas de l'ordre du tableau qui en résulte, n'a pas d'importance, aussi longtemps que tous les éléments sont uniques.

OriginalL'auteur AnchovyLegend | 2013-02-01

  1. 24

    Dans Java 8, utilisez IntStream d'obtenir des éléments uniques d'un tableau

    int[] noDuplicates = IntStream.of(array).distinct().toArray();

    La façon la plus simple serait de créer un ensemble à partir de la matrice.

    Integer[] array = ...
Set<Integer> set = new LinkedHashSet<Integer>(Arrays.asList(array ));

    et puis vous pouvez récupérer le tableau à l'aide de:

    set.toArray()

    utilisation LinkedHashSet si vous voulez maintenir l'ordre ou TreeSet si vous voulez avoir un tri.

    quelles erreurs avez-vous l'obtenir?
    Je travaille avec des cordes et j'ai été faire, HashSet<String> ne peut pas être résolu à un type.
    cela signifie que vous devez importer le HashSet, tout simplement ajouter des import java.util.HashSet; vous devriez envisager d'utiliser et IDE comme Eclipse

    OriginalL'auteur zibi

  2. 3

    Deux options

    1. Garder une carte du comte et de l'élément et enfin, l'utilisation de ces éléments avec le compte 1. (Besoin de stockage supplémentaire, mais est plus rapide)

    2. Trier le tableau et que vous vous déplacez à travers le tableau utilisez uniquement des non-répétée.

    N'a pas besoin d'espace supplémentaire, mais sera en O(n lg n))

    L'Option 1 est l'heure de la complexité pourrait pas être plus rapide. Si vous utilisez un équilibre binaire un arbre de recherche pour la carte, vous obtiendrez lg(N) opérations. Si vous utilisez une table de hachage, vous agissez sous l'uniforme de hachage hypothèse.
    J'ai été en supposant une table de hachage. Et toutes les langues ont des c. bon les fonctions de hachage qui est plus ou moins s'assurer de O(1) insérer et extraire
    OK. Je suppose que puisque c'est les numéros de c'est la fin. Il n'est pas difficile de faire un hash pour un int :). La taille de la table de hachage sera important, cependant, que vous aurez à faire défiler toutes les valeurs stockées dans celui-ci, qui est O(M), où M est la taille de la table de hachage. Bon, réponse rapide, de toute façon, donc +1.

    OriginalL'auteur smk

  3. 1

    En supposant qu'un tableau d'Objets:

    Object[] arr;

{...omissis...}

List<Object> list = new ArrayList<Object>();
for(Object val: arr) {
  if(!list.contains(val)) {
    list.add(val);
  }
}
list.toArray(new Object[0]);

    Remplacer Object avec votre Classe Array, si nécessaire.

    Merci pour la réponse. Je suis à l'aide de tableaux de ne pas tableau liste.
    cela fonctionne même avec les tableaux donc arr est un tableau d'objets, j'ai modifier mon post
    C'est un moyen très coûteux de le faire, comme list.contains() est linéairement plus en plus d'efforts que la liste s'accroît. Avec de très grandes listes cela peut être une différence de quelques secondes par rapport à des milliers d'années, le temps de traitement... vaut Mieux utiliser un HashSet pour contient de recherche et la Liste de résultat de l'accumulation, si vous voulez garder cette approche.

    OriginalL'auteur Alepac

  4. 0

    Voici 2 idées:

    1. Ajouter tous les éléments d'un Ensemble, ou en créer un avec le constructeur qui a un tableau comme paramètre (HashSet ou TreeSet, selon le moment de la complexité que vous voulez). Ensuite, pour chaque élément dans l'ensemble, l'enlever, l'ajouter à la prochaine position d'ouverture d'un nouveau tableau qui est la taille de l'ensemble.

    2. Trier le tableau. Ajouter l'objet à l'index 0 pour un ArrayList. Commencer à l'indice 1 et aller à l'index length - 1. Si l'élément courant est pas égal à l'élément à l'indice précédent, l'ajouter à la ArrayList. Modifier la ArrayList dans un tableau, si nécessaire.

    OriginalL'auteur eboix

  5. 0

    (Repost de: https://stackoverflow.com/a/39731584/1520422)

    Utiliser le Flux de données de l'API de Java 8 c'est une solution avec un générique de type Tableau:

    public static <T> T[] makeUnique(T... values)
{
    return Arrays.stream(values).distinct().toArray(new IntFunction<T[]>()
    {

        @Override
        public T[] apply(int length)
        {
            return (T[]) Array.newInstance(values.getClass().getComponentType(), length);
        }

    });
}

    Il fonctionne pour n'importe quel type d'Objet tableau, mais pas pour des primitifs tableaux.

    Pour des primitifs tableaux, il ressemble à ceci:

    public static int[] makeUnique(int... values)
{
    return Arrays.stream(values).distinct().toArray();
}

    Et enfin, voici un petit test de l'unité:

    @Test
public void testMakeUnique()
{
    assertArrayEquals(new String[] { "a", "b", "c" }, makeUnique("a", "b", "c", "b", "a"));
    assertArrayEquals(new Object[] { "a", "b", "c" }, makeUnique(new Object[] { "a", "b", "c", "b", "a" }));
    assertArrayEquals(new Integer[] { 1, 2, 3, 4, 5 }, makeUnique(new Integer[] { 1, 2, 2, 3, 3, 3, 1, 4, 5, 5, 5, 1 }));
    assertArrayEquals(new int[] { 1, 2, 3, 4, 5 }, makeUnique(new int[] { 1, 2, 2, 3, 3, 3, 1, 4, 5, 5, 5, 1 }));
}

    OriginalL'auteur Frederic Leitenberger