16

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}
b4hand
  • 9,550
  • 4
  • 44
  • 49
AnchovyLegend
  • 12,139
  • 38
  • 147
  • 231

6 Answers6

30

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.

NageN
  • 601
  • 8
  • 15
zibi
  • 3,183
  • 3
  • 27
  • 47
  • I am working with strings and I was getting, HashSet cannot be resolved to a type. – AnchovyLegend Feb 01 '13 at 22:39
  • 1
    it means that you need to import the HashSet, simply **add import java.util.HashSet;** you should consider using and IDE like Eclipse – zibi Feb 01 '13 at 22:42
3

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

b4hand
  • 9,550
  • 4
  • 44
  • 49
smk
  • 5,340
  • 5
  • 27
  • 41
  • Option 1's time complexity might not be faster. If you're using a balanced binary search tree for the map, you will get lg(N) operations. If you use a hash table, you are acting under the uniform hashing assumption. – eboix Feb 01 '13 at 22:45
  • 1
    I was assuming a hash table. And all standard languages have v. good hashing functions which more or less ensure O(1) insert and retrieve – smk Feb 01 '13 at 22:47
  • OK. I suppose that since it's numbers it's fine. It's not hard to make a hash for an int :). The size for the hash table will be important, though, as you will have to cycle through all of the values stored in it, which is O(M), where M is the size of the hash table. Good, fast answer, anyway, so +1. – eboix Feb 01 '13 at 22:56
1

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.

Alepac
  • 1,833
  • 13
  • 24
  • Thanks for the reply. I am using arrays not array lists. – AnchovyLegend Feb 01 '13 at 22:42
  • @MHZ this works even with arrays so arr is an array of objects, I edit my post – Alepac Feb 01 '13 at 22:46
  • This is a very expensive way to do it, as `list.contains()` is linearly increasing effort as the list grows. With very large lists this can be a difference like a few seconds compared to thousands of years processing time... Better use a HashSet for contains lookup and the List for result buildup, if you want to keep this approach. – Frederic Leitenberger Sep 27 '16 at 17:49
1

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.

eboix
  • 5,113
  • 1
  • 27
  • 38
0

(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 }));
}
Community
  • 1
  • 1
Frederic Leitenberger
  • 1,949
  • 24
  • 32
0

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 + '}';
}
}
Itz Pkyadav
  • 51
  • 5