Unique values of an array

No need for any loops with Java 8 streams.

1. Get a DoubleStream from the array with Arrays.stream(double[] array) so that you can
2. get the distinct() elements from that
3. which you can count() to retrieve your result.

public static long numUnique(double[] list) 
{
    return Arrays.stream(list).distinct().count();
}

As count() returns a long, I modified the signature of your method to return long, too. It's within the responsibility of the user of your method then to perform any cast on the result.

Full example program:

import java.util.Arrays;

public class UniqueDoubles
{
    public static void main(String[] args)
    {
        double[] doubles = {1, 2, 3.5, 3.5, 2, 345345.345345};

        System.out.println(numUnique(doubles));
    }

    public static long numUnique(double[] list) 
    {
        return Arrays.stream(list).distinct().count();
    }
}

An issue with this code is actually the equal test of double (floating point numbers).

       if (list[i] == list[j]) ...

It is more common to test almost equal.

       if (Math.abs(list[i] - list[j]) < EPSILON) ...

Instead of doing \$\frac{n \times (n-1)}{2}\$ comparisons, you should just:

• make a copy of the array (use the clone method)
• sort this array (see the java.util.Arrays class)
• compare each element of the sorted array to its immediate neighbor

By using this idea, the code gets faster, especially for large arrays, since it only needs \$ n \times \log n \$ comparisons for sorting and \$n-1\$ comparisons for detecting the unique values. It does an additional memory allocation, though, but in most cases you don't need to care about this.

Another way, when code readability is more important than execution speed, is to just use Guava's Multiset<Double> and add all the numbers to it. Then count the number of elements for which .count() is 1.

Seems to me the simplest thing would be to put all the doubles into a HashSet and get its length. A Set does not allow duplicate values.

    public static int numUnique(double[] list) 
    {
        Set<Double> hashSet = new HashSet<Double>();

        for (double d: list)
            hashSet.add(d);

        return hashSet.size());
    }

[EDIT: code revised to match structure of OP's function. For loop changed to for-each]

It would be simpler if we could use the hashSet.addAll() method, but that would only work if the "list" array was Double[], not double[]. By going one-by-one (in the for loop) autoboxing of the double to Double occurs.