CODEWITHSUNDEEP
javaarraysunique
AnchovyLegend
AnchovyLegend

Reputation: 12538

Array of unique elements?

Given an array like the one below, I was wondering if there is an easy way to turn this array into an array with unique values only?

This is given:

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

Turn it into a result array like this, preserving the original order:

   {5,1,2,3,4}

Upvotes: 17

Views: 63057

Answers (7)

vishnu chowdary
vishnu chowdary

Reputation: 1

    boolean isunique=false;
       int i, j;
       for(i=0;i<n;i++)
       {
            for(j=0;j<i;j++) 
                 if(a[i]==a[j]) 
                      break;
            if(i==j) 
              System.out.print(a[i]+" ");

Upvotes: 0

Itz Pkyadav
Itz Pkyadav

Reputation: 79

If you want to merge two list without duplicates then try this one, it works for me.

    List<Name> list1 = Arrays.asList(new Name("abc", 1), new Name("def", 2), new Name("ghi", 3));
    List<Name> list2 = Arrays.asList(new Name("def", 4), new Name("jkl", 5), new Name("mno", 6));
   
    List<Name> newNameList= new ArrayList<>(Stream.of(list1, list2).flatMap(List::stream)
            .collect(Collectors.toMap(Name::getName, d -> d, (Name x, Name y) -> x == null ? y : x)).values());
    newNameList.forEach(System.out::println);


class Name {
String name;
int id;

public Name(String name, int id) {
    this.name = name;
    this.id = id;
}

public String getName() {
    return name;
}

@Override
public String toString() {
    return "Name{" + "name='" + name + '\'' + ", id=" + id + '}';
}
}

Upvotes: 0

Frederic Leitenberger
Frederic Leitenberger

Reputation: 2019

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

Using the Stream API of Java 8 this is a solution with a generic Array type:

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

    });
}

It works for any Object type array, but not for primitive arrays.

For primitive arrays it looks like this:

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

And finally here is a little unit test:

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

Upvotes: 0

zibi
zibi

Reputation: 3303

In Java 8, use IntStream to get unique elements of an array

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

The simplest way would be to create set from the array.

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

and then you can retrieve the array using:

set.toArray()

use LinkedHashSet if you want to maintain the order or TreeSet if you want to have it sorted.

Upvotes: 32

smk
smk

Reputation: 5932

Two options

  1. Keep a map of count and element and finally only use those elements with count 1. (Need extra storage but is faster)

  2. Sort the array and as you move through the array only use non-repeated ones.

Doesn't need extra space but will be O(n lg(n))

Upvotes: 3

Alepac
Alepac

Reputation: 1831

Supposing an array of Objects:

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

Replace Object with your Array Class if needed.

Upvotes: 1

eboix
eboix

Reputation: 5131

Here are 2 ideas:

  1. Add all items to a Set, or create one with the constructor that has an array as a parameter (HashSet or TreeSet, depending on what time complexity you want). Then, for each element in the set, remove it, adding it to the next open position of a new array that is the size of the set.

  2. Sort the array. Add the object at index 0 to an ArrayList. Start at index 1 and go to index length - 1. If the current element is not equal to the element at the previous index, add it to the ArrayList. Change the ArrayList into an array, if necessary.

Upvotes: 1

Related Questions