Как найти уникальные элементы массива java

I am Java beginner, I found a few topics regarding this theme, but none of them worked for me.
I have an array like this:

int[] numbers = {1, 1, 2, 1, 3, 4, 5};

and I would need to get this output:

1, 2, 3, 4, 5

Every item from that array just once.

But how to get it?

//Running total of distinct integers found
int distinctIntegers = 0;

for (int j = 0; j < array.length; j++)
{
    //Get the next integer to check
    int thisInt = array[j];

    //Check if we've seen it before (by checking all array indexes below j)
    boolean seenThisIntBefore = false;
    for (int i = 0; i < j; i++)
    {
        if (thisInt == array[i])
        {
            seenThisIntBefore = true;
        }
    }

    //If we have not seen the integer before, increment the running total of distinct integers
    if (!seenThisIntBefore)
    {
        distinctIntegers++;
    }
}

answered Apr 4, 2013 at 21:13

Below code will print unique integers have a look:

printUniqueInteger(new int[]{1, 1, 2, 1, 3, 4, 5});


static void printUniqueInteger(int array[]){
    HashMap<Integer, String> map = new HashMap();

    for(int i = 0; i < array.length; i++){
        map.put(array[i], "test");
    }

    for(Integer key : map.keySet()){
        System.out.println(key);
    }
}

public class Practice {
    public static void main(String[] args) {
        List<Integer> list = new LinkedList<>(Arrays.asList(3,7,3,-1,2,3,7,2,15,15));
        countUnique(list);
}

public static void countUnique(List<Integer> list){
    Collections.sort(list);
    Set<Integer> uniqueNumbers = new HashSet<Integer>(list);
    System.out.println(uniqueNumbers.size());
}

}

answered Jun 9, 2016 at 0:58

There is an easier way to get a distinct list:

Integer[] intArray = {1,2,3,0,0,2,4,0,2,5,2};
List<Integer> intList = Arrays.asList(intArray);          //To List
intList = new ArrayList<>(new LinkedHashSet<>(intList));  //Distinct
Collections.sort(intList);                                //Optional Sort
intArray = intList.toArray(new Integer[0]);               //Back to array

Outputs:

1 2 3 0 0 2 4 0 2 5 2   //Array
1 2 3 0 0 2 4 0 2 5 2   //List
1 2 3 0 4 5             //Distinct List
0 1 2 3 4 5             //Distinct Sorted List
0 1 2 3 4 5             //Distinct Sorted Array

See jDoodle Example

answered Aug 7, 2019 at 7:17

You could do it like this:

    int[] numbers = {1, 1, 2, 1, 3, 4, 5};
    ArrayList<Integer> store = new ArrayList<Integer>(); // so the size can vary

    for (int n = 0; n < numbers.length; n++){
        if (!store.contains(numbers[n])){ // if numbers[n] is not in store, then add it
            store.add(numbers[n]);
        }
    }
    numbers = new int[store.size()];
    for (int n = 0; n < store.size(); n++){
        numbers[n] = store.get(n);
    }

Integer and int can be (almost) used interchangeably. This piece of code takes your array “numbers” and changes it so that all duplicate numbers are lost. If you want to sort it, you can add Collections.sort(store); before numbers = new int[store.size()]

answered Apr 1, 2013 at 22:13

I don’t know if you’ve solved your issue yet, but my code would be:

    int[] numbers = {1, 1, 2, 1, 3, 4, 5};
    int x = numbers.length;
    int[] unique = new int[x];
    int p = 0;
    for(int i = 0; i < x; i++)
    {
        int temp = numbers[i];
        int b = 0;
        for(int y = 0; y < x; y++)
        {
            if(unique[y] != temp)
            {
               b++;
            }
        }
        if(b == x)
        {
            unique[p] = temp;
            p++;
        }
    }
    for(int a = 0; a < p; a++)
    {
        System.out.print(unique[a]);
        if(a < p-1)
        {
            System.out.print(", ");
        }
    }

String s1[]=  {"hello","hi","j2ee","j2ee","sql","jdbc","hello","jdbc","hybernet","j2ee"};

int c=0;

for(int i=0;i<s1.length;i++)
{
    for(int j=i+1;j<s1.length;j++)
    {
    if(s1[i]==(s1[j]) )
    {
        c++;
    }
    }
        if(c==0)
         {
            System.out.println(s1[i]);
         }
            else
             {
            c=0;
              } 
            }
         }
      }

answered Jun 5, 2016 at 17:36

To find out unique data:

public class Uniquedata 
 {
 public static void main(String[] args) 
  {
int c=0;

String s1[]={"hello","hi","j2ee","j2ee","sql","jdbc","hello","jdbc","hybernet","j2ee","hello","hello","hybernet"};

for(int i=0;i<s1.length;i++)
{
    for(int j=i+1;j<s1.length;j++)
    {
    if(s1[i]==(s1[j]) )
    {
        c++;
        s1[j]="";
    }}
        if(c==0)
        {
            System.out.println(s1[i]);
        }
            else
            {
                s1[i]="";
            c=0;    
            }
        }
    }
}

Here is my piece of code using counting sort (partially)

Output is a sorted array consiting of unique elements

    void findUniqueElementsInArray(int arr[]) {
    int[] count = new int[256];
    int outputArrayLength = 0;
    for (int i = 0; i < arr.length; i++) {
        if (count[arr[i]] < 1) {
            count[arr[i]] = count[arr[i]] + 1;
            outputArrayLength++;
        }
    }
    for (int i = 1; i < 256; i++) {
        count[i] = count[i] + count[i - 1];
    }
    int[] sortedArray = new int[outputArrayLength];
    for (int i = 0; i < arr.length; i++) {
        sortedArray[count[arr[i]] - 1] = arr[i];
    }
    for (int i = 0; i < sortedArray.length; i++) {
        System.out.println(sortedArray[i]);
    }
}

Reference – discovered this solution while
trying to solve a problem from HackerEarth

answered Apr 19, 2017 at 10:03

public class DistinctArray {


    public static void main(String[] args) {
     int num[]={1,2,5,4,1,2,3,5};
     for(int i =0;i<num.length;i++)
     {
         boolean isDistinct=false;
         for(int j=0;j<i;j++)
         {
             if(num[j]==num[i])
             {
                 isDistinct=true;
                 break;
             }
         }
         if(!isDistinct)
         {
             System.out.print(num[i]+" ");
         }
     }
    }

}

I’ve been trying to write code that finds the unique values in a sorted array that also has duplicates.

So far, I’ve written:

public static int numUnique (double[] list) {
    int counter = 0;

    if (Array.getLength(list) < 1) {
            return Length.list);
        }
    else{
        for (int i=0; i < Length.list); i++){
            for (int j=i+1; j< Length.list); j++){
                if (list[i] != list[j]){
                    newrArray[i] = list[i];
                    counter++;

                }
            }
        }
    }

    return counter;
}

Input:

{31, 31, 31, 31, 33, 46, 46, 46, 46, 46, 52, 65, 65, 66, 75, 98, 98}

Expected output:

8

I cannot use HashSets or ArrayLists. I think the only viable option is copying from one array to another and then counting what is in the new array (assuming that only unique values are copied into the new array).

You’re overcomplicating things quite a bit:

Since the array is sorted, all you need to do is check whether a value and the value before it in the array are equal. If they aren’t increment the count, else continue with the next value:

int uniqueNum(double[] d){
    if(d.length < 2)
        return d.length;

    int count = 0;

    //choose an initial previous value that differs from the first element in the array
    double prev = (d[0] == 1.0 ? 2.0 : 1.0);
    for(double v : d){
        //ignore duplicate values
        if(v == prev)
            continue;

        count++;
        prev = v;
    }

    return count;
}

This works since in a sorted array duplicate values will always form a sequence.

Why your code doesn’t work:

for (int i=0; i < Array.getLength(list); i++){
    for (int j=i+1; j< Array.getLength(list); j++){
        if (list[i] != list[j]){
            catcherArray[i] = list[i];
            counter++;
        }
    }
}

This codes doesn’t count the number of distinct values in the array, but for any index in the array the number of values that are different from the value at that index.

answered Jan 16, 2017 at 21:01

The array is sorted, which means the duplicate values are next to each other. It’s good news for us because once we see a different value than the previous, we know for sure that the previous value is not going to show up again, ever. We can do a linear scan:

int countDistinct(double [] numbers) {
    if (numbers == null || numbers.length == 0) return 0;

    int c = 1, n = numbers.length;

    // The previous value, initialized to the first element
    double prev = numbers[0];

    // Start loop from the second element
    for (int i = 1; i < n; i++) {
        if (prev != numbers[i]) {
            c++;
            prev = numbers[i];
        }
    }

    return c;
}

answered Jan 16, 2017 at 21:37

You can you use IntStream distinct() or DoubleStream distinct() based on your array.

double[] doubleArray ={31.0, 31.0, 31.0, 31.0, 33.0, 46.0, 46.0, 46.0, 46.0, 46.0, 52.0, 65.0, 65.0, 66.0, 75.0, 98.0, 98.0};
long count = DoubleStream.of(doubleArray).distinct().count();
System.out.println(count);

Output:

8

If you have int array you can use IntStream distinct()

int[] intArray = {31, 31, 31, 31, 33, 46, 46, 46, 46, 46, 52, 65, 65, 66, 75, 98, 98};
long count = IntStream.of(intArray).distinct().count();
System.out.println(count);

Output:

8

answered Aug 11, 2017 at 9:40