Print only non repeated elements in an array?

Question

Here is my code snippet

import java.util.*;
public class UniqueEl
{
    public static void main(String []p)
    {
        Scanner sc=new Scanner(System.in);
        System.out.println("Enter Array size");
        int size=sc.nextInt();
        //boolean ischeck=true;
        int flag=0,cnt=0;
        int []num=new int[size];
        System.out.println("Enter Array Elements");
        for(int i=0;i<size;i++)
        {
            num[i]=sc.nextInt();
        }
        System.out.println("Display Array Elements");
        for(int i=0;i<size;i++)
        {
            System.out.println("Array Elements are :-"+num[i]);
        }
        System.out.println("Unique elements from the array ");
        for(int i=0;i<size;i++)
        {   
            for(int j=0;j<size;j++)
            {
                if(i!=j)
                {
                    if(num[i]=num[j])
                    {
                        flag=1;
                    }
                    else
                    {
                        flag=0;
                        break;
                    }

                }
            }
            if(flag==1)
            {
                cnt++;
            System.out.println(num[i]+" ");

            }
        }
    }
}

Here In this array code I have to print non-repeated integer value

Say Array value is :-[1,1,2,3,1,2,4,5] answer should be :-[3,4,5] that is non repeated integer value I have to print .Can any one help me to solve this problem

score 1 · Answer 1 · answered May 15 '17 at 07:38

An easier approach may be to use Java 8's stream capabilities to count the number of appearances each element has, and then filter our the non-unique ones:

List<Integer> uniqueElements =
    Arrays.stream(num)
          .boxed()
          .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
          .entrySet()
          .stream()
          .filter(e -> e.getValue() == 1)
          .map(Map.Entry::getKey)
          .collect(Collectors.toList());

score 1 · Answer 2 · answered Feb 07 '19 at 18:17

Using EXOR Operation. Only works when the repeat count is Even and has only 1 unique number.

public class MyClass {
    public static void main (String[] args) 
    { 

        int arr[] = { 1, 2, 5, 4, 6, 8, 9, 2, 1, 4, 5, 8, 9 }; 
        int n = arr.length; 
        int v = 0;
        for(int i = 0 ; i< n ; i++ ){
            v = v ^ arr[i]; //XOR Operation
        }

        System.out.print(v); 
    } 
}

score 0 · Answer 3 · answered May 15 '17 at 08:15

Maybe this can be helpful:

static int[] uniqueElementsFrom(int[] arr) {
    final Map<Integer, Integer> numberOfOccurences = new HashMap<Integer, Integer>();

    for (int i : arr) {
        if (!numberOfOccurences.containsKey(i)) {
            numberOfOccurences.put(i, 1);
        } else {
            numberOfOccurences.put(i, numberOfOccurences.get(i) + 1);
        }
    }

    final Set<Integer> integers = numberOfOccurences.keySet();

    List<Integer> uniques = new LinkedList<Integer>();
    for (int i: integers) {
        if (numberOfOccurences.get(i) == 1) {
            uniques.add(i);
        }
    }

    final int[] uniqueIntsArray = new int[uniques.size()];
    for (int counter = 0; counter < uniques.size(); counter++) {
        uniqueIntsArray[counter] = uniques.get(counter);
    }
    return uniqueIntsArray;
}

score 0 · Answer 4 · edited May 23 '17 at 12:18

You can use two Maps to store the found/abandoned values and therefore iterate the array only once.

The approach:

for each element in array
is the element indexed (already found)?
if no index it (to a HashMap)
if yes, remove it from index and put on abandoned list
the results are the keys of the index map.

The code:

Set getUniqueValues(int[] numbers) {

  HashMap<Integer,Boolean> numIndex = new HashMap<Integer, Boolean>();
  HashMap<Integer,Boolean> abandoned = new HashMap<Integer, Boolean>();


  for (int i = 0; i < numbers.length; i++) {
      int currentNumber = numbers[i];

      try {
          // check if already abandoned and skip this iteration
          if ( abandoned.get(currentNumber) != null) continue;
      } catch(Exception e) {

      }

      boolean isInIndex;
      try {
          // check if it is already indexed
          isInIndex = numIndex.get(currentNumber);
      } catch(Exception e) {
          // if not, we found it the first time
          isInIndex = false;
      }

      if (isInIndex == false){
          //so we put it to the index
          numIndex.put(currentNumber, true);
      }else{
          // if it appeared, we abandon it
          numIndex.remove(currentNumber);
          abandoned.put(currentNumber, true);
      }
  }
   return numIndex.keySet(); 
}

Further readings:

The maps use wrapper classes (Integer, Boolean), which are auto converted by Java:

HashMap and int as key

The function returns a set, which may be converted to an array:

Java: how to convert HashMap<String, Object> to array

score 0 · Answer 5 · answered May 15 '17 at 08:37

If you want to correct your current code, there are just 2 problems i can see : 1. if(num[i]==num[j]), you want to do equality check, use == because = is assignment operator, and you want to compare num[i] to num[j]. 2. break from inner loop when you found a repetition of any int, i.e. flag=1. When flag=0, it means there is no repetition of this number and you are good to go. See corrected code below :

for(int i=0;i<size;i++)
    {   
        for(int j=0;j<size;j++)
        {
            if(i!=j)
            {
                if(num[i]==num[j])
                {
                    flag=1; //it is repeated number
                    break; //break the loop as we already found a repetition of this number
                }

            }
        }
        if(flag==0)
        {
            cnt++;
            System.out.println(num[i]+" "); //here is your non-repeated number
        }
    }

score 0 · Answer 6 · answered Jul 08 '23 at 10:07

You can use this readable solution:

 // Create a HashMap to store the count of each element
    Map<Integer, Integer> countMap = new HashMap<>();

    Arrays.stream(array)
            .forEach(num -> countMap.put(num, countMap.getOrDefault(num, 0) + 1));

    countMap.entrySet().stream()
            .filter(entry -> entry.getValue() == 1)
            .map(Map.Entry::getKey)
            .forEach(System.out::println);

Java 8 features:

getOrDefault:

https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#getOrDefault-java.lang.Object-V-

stream

https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html

Print only non repeated elements in an array?

6 Answers6