Remove duplicates from integer array

Question

I having a problem with coding this:

Write a static method named removeDuplicates that takes as input an array of integers and returns as a result a new array of integers with all duplicates removed. For example, if the input array has the elements {4, 3, 3, 4, 5, 2, 4} the resulting array should be {4, 3, 5, 2}

Here's what I have done so far

public static int[] removeDuplicates(int []s){
    int [] k = new int[s.length];
    k[0]=s[0];
    int m =1;
    for(int i=1;i<s.length;++i){
        if(s[i]!=s[i-1]){
            k[m]=s[i];
            ++m;
        }//endIF
    }//endFori
    return k;
}//endMethod

The easy way would be to add the elements to a set (which will remove duplicates automatically for you) and put the numbers back in an array. — assylias, Dec 17 '12 at 10:11
possible duplicate of [What is the best way to remove duplicates in an Array in Java?](http://stackoverflow.com/questions/357421/what-is-the-best-way-to-remove-duplicates-in-an-array-in-java) among others ... — Brian Roach, Dec 17 '12 at 10:18
You didn't state the constraints on your implementation, and I'll bet there are many, since otherwise the solution is trivial. — Marko Topolnik, Dec 17 '12 at 10:36
actually I can not use Set or HashSet , it must be done with loops and simple arrays — Ali-J8, Dec 17 '12 at 10:43

score 8 · Answer 1 · answered Jul 28 '13 at 07:38

To Preserve the ordering and to remove duplicates in the integer array, you can try this:

public void removeDupInIntArray(int[] ints){
    Set<Integer> setString = new LinkedHashSet<Integer>();
    for(int i=0;i<ints.length;i++){
        setString.add(ints[i]);
    }
    System.out.println(setString);
}

Hope this helps.

score 6 · Answer 2 · edited Oct 29 '18 at 16:12

6

try this -

public static int[] removeDuplicates(int []s){
    int result[] = new int[s.length], j=0;
    for (int i : s) {
        if(!isExists(result, i))
            result[j++] = i;
    }
    return result;
}

private static boolean isExists(int[] array, int value){
    for (int i : array) {
        if(i==value)
            return true;
    }
    return false;
}

edited Oct 29 '18 at 16:12

davidtbernal

13,434
9
44
60

answered Dec 17 '12 at 10:18

Subhrajyoti Majumder

40,646
13
77
103

1

Looks like there a mistake here. Instead of if(isExists(result, i)) it must be if(!isExists(result, i)). – nakosspy May 20 '13 at 23:53
3

The only solution that should save order. But two problems there: 1) will skip 0's 2) there will be 0's in the end in case of duplicates. Both of them quite easy to solve, however – RiaD May 20 '13 at 23:57

Otto Kocebu · Answer 3 · 2015-02-01T20:58:59.163

First of all, you should know length without duplicates(dups): initial length minus number of dups. Then create new array with right length. Then check each element of list[] for dups, if dup founded - check next element, if dup not founded - copy element to new array.

public static int[] eliminateDuplicates(int[] list) {
    int newLength = list.length;
    // find length w/o duplicates:
    for (int i = 1; i < list.length; i++) {
        for (int j = 0; j < i; j++) {
            if (list[i] == list[j]) {   // if duplicate founded then decrease length by 1
                newLength--;
                break;
            }
        }
    }

    int[] newArray = new int[newLength]; // create new array with new length
    newArray[0] = list[0];  // 1st element goes to new array
    int inx = 1;            // index for 2nd element of new array
    boolean isDuplicate;

    for (int i = 1; i < list.length; i++) {
        isDuplicate = false;
        for (int j = 0; j < i; j++) {
            if (list[i] == list[j]) {  // if duplicate founded then change boolean variable and break
                isDuplicate = true;
                break;
            }
        }
        if (!isDuplicate) {     // if it's not duplicate then put it to new array
            newArray[inx] = list[i];
            inx++;
        }
    }
    return newArray;
}

score 3 · Answer 4 · edited Jul 03 '18 at 14:54

3

try this.

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

 numbers =  java.util.stream.IntStream.of(numbers).distinct().toArray();

edited Jul 03 '18 at 14:54

SHR

7,940
9
38
57

answered Jul 03 '18 at 14:38

SaGaR

31
1

score 2 · Answer 5 · answered Jul 28 '13 at 17:32

Maybe you can use lambdaj (download here,website), this library is very powerfull for managing collections (..list,arrays), the following code is very simple and works perfectly:

import static ch.lambdaj.Lambda.selectDistinct;
import java.util.Arrays;
import java.util.List;

public class DistinctList {
     public static void main(String[] args) {
         List<Integer> numbers =  Arrays.asList(1,3,4,2,1,5,6,8,8,3,4,5,13);
         System.out.println("List with duplicates: " + numbers);
         System.out.println("List without duplicates: " + selectDistinct(numbers));
     }
}

This code shows:

List with duplicates: [1, 3, 4, 2, 1, 5, 6, 8, 8, 3, 4, 5, 13]
List without duplicates: [1, 2, 3, 4, 5, 6, 8, 13]

In one line you can get a distinct list, this is a simple example but with this library you can resolve more.

selectDistinct(numbers)

You must add lambdaj-2.4.jar to your project. I hope this will be useful.

Note: This will help you assuming you can have alternatives to your code.

score 2 · Answer 6 · answered Nov 19 '13 at 07:00

public int[] removeRepetativeInteger(int[] list){
        if(list.length == 0){
            return null;
        }
        if(list.length == 1){
            return list;
        }

    ArrayList<Integer> numbers = new ArrayList<>();
    for(int i = 0; i< list.length; i++){
        if (!numbers.contains(list[i])){
            numbers.add(list[i]);
        }
    }
    Iterator<Integer> valueIterator = numbers.iterator();
    int[] resultArray = new int[numbers.size()]; 
    int i = 0;
    while (valueIterator.hasNext()) {
        resultArray[i] = valueIterator.next();
        i++;
    }
    return resultArray;     

}

Anders R. Bystrup · Answer 7 · 2012-12-17T12:02:55.963

1

You could also put the array elements into a Set for which the semantics precisely are that it contains no duplicate elements.

edited Dec 17 '12 at 12:02

answered Dec 17 '12 at 10:11

Anders R. Bystrup

15,729
10
59
55

2

`Set set = new HashSet( Arrays.asList( s ) )` it will not compile. – Subhrajyoti Majumder Dec 17 '12 at 10:19
-1 Set is a raw type. References to generic type Set should be parameterized. – dogbane Dec 17 '12 at 10:35
Your edit does not solve the issue, you can't transform an `int[]` to an `Integer[]` with `Arrays.asList()`. – assylias Dec 17 '12 at 11:36

score 1 · Answer 8 · answered Dec 17 '12 at 10:31

Iterate over the array and populate a set because sets cannot contain duplicates. Then copy the elements from the set into a new array and return it. This is shown below:

public static int[] removeDuplicates(int[] array) {
    // add the ints into a set
    Set<Integer> set = new HashSet<Integer>();
    for (int i = 0; i < array.length; i++) {
        set.add(array[i]);
    }

    // copy the elements from the set into an array
    int[] result = new int[set.size()];
    int i = 0;
    for (Integer u : set) {
        result[i++] = u;
    }
    return result;
}

score 1 · Answer 9 · answered Dec 17 '12 at 10:47

1

You can also use Google's Guava library and use ImmutableSet do

ImmutableSet.copyOf(myArray).asList();

answered Dec 17 '12 at 10:47

RNJ

15,272
18
86
131

score 1 · Answer 10 · answered Jul 28 '13 at 09:07

You can use HashSet that does not allow dulplicate elements

public static void deleteDups(int a []) {

    HashSet<Integer> numbers = new HashSet<Integer>();

        for(int n : a)
        {
            numbers.add(n);
        }

        for(int k : numbers)
        {
            System.out.println(k);
        }
        System.out.println(numbers);
    }       

public static void main(String[] args) {
    int a[]={2,3,3,4,4,5,6};
            RemoveDuplicate.deleteDups(a);

}

}
o/p is 2
3
4
5
6

[2, 3, 4, 5, 6]

score 1 · Answer 11 · answered Apr 17 '17 at 18:44

This worked for me:

import java.util.Arrays;
import java.util.HashSet;

public class Util {

    public static int[] removeDups(final int[] intArrayWithDups) {
        final int[] intArrayDupsRemoved = new int[intArrayWithDups.length];

        final HashSet<Integer> alreadyAdded = new HashSet<>();
        int innerCounter = 0;
        for (int integer : intArrayWithDups) {
            if (!alreadyAdded.contains(integer)) {
                intArrayDupsRemoved[innerCounter] = integer;
                alreadyAdded.add(intArrayDupsRemoved[innerCounter]);
                innerCounter++;
            }
        }

        return Arrays.copyOf(intArrayDupsRemoved, innerCounter);
    }
}

Soudipta Dutta · Answer 12 · 2018-05-06T11:33:29.237

This is an interview question. Question : Remove Duplicates from an array in place :

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

           int[] a = {1,1,2,3,4,5,6,6,7,8};

          int countwithoutDuplicates =  lengthofarraywithoutDuplicates(a);
          for(int i = 0 ; i < countwithoutDuplicates ; i++) {
              System.out.println(a[i] + " ");
          }
    }

    private static int lengthofarraywithoutDuplicates(int[] a) {
        int countwithoutDuplicates = 1 ;
        for (int i = 1; i < a.length; i++) {
              if( a[i] != a[i-1]      ) {
                 a[countwithoutDuplicates++] = a[i]; 
              }//if
        }//for
        System.out.println("length of array withpout duplicates = >" + countwithoutDuplicates);
        return countwithoutDuplicates;

    }//lengthofarraywithoutDuplicates


}

In Python :

def lengthwithoutduplicates(nums):
    if not nums: return 0
    if len(nums) == 1:return 1
    # moving backwards from last element i.e.len(a) -1 to first element 0 and step is -1
    for i in range(len(nums)-1,0,-1):
      # delete the repeated element
        if nums[i] == nums[i-1]: del nums[i]
        # store the new length of the array without the duplicates in a variable
        # and return the variable
    l = len(a)      
    return l



a = [1, 1, 2, 3, 4, 5, 6, 6, 7, 8];

l = lengthwithoutduplicates(a)
for i in range(1,l):print(i)

In Python: list comprehension using enumerate

a = [1, 1, 2, 3, 4, 5, 6, 6, 7, 8]

aa = [ ch  for i, ch in enumerate(a) if ch not in a[:i] ]
print(aa) # output => [1, 2, 3, 4, 5, 6, 7, 8]

score 1 · Answer 13 · edited Oct 13 '21 at 16:53

I have found this solution to this problem. Using HashSet is a powerful way to filter and order an array of integers. It is very fast as well.

I have written this short code in order to show the power of this feature. From an array of integers, it creates two lists. One with the ordered integers without the duplicates and the other which shows only the duplicates and the number of times they are in the initial array.

public class DuplicatesFromArray {

    public static void main(String args[]) {
        int[] withDuplicates = { 1, 2, 3, 1, 2, 3, 4, 5, 3, 6 };
        
        
        // complexity of this solution is O[n]

        duplicates(withDuplicates);

        
    }

//Complexity of this method is O(n)
    
    public static void duplicates(int[] input) {

        HashSet<Integer> nums = new HashSet<Integer>();

        List<Integer> results = new ArrayList<Integer>();
        List<Integer> orderedFiltered = new ArrayList<Integer>();

        for (int in : input) {

            if (nums.add(in) == false) {
                results.add(in);
            } else {
                orderedFiltered.add(in);
            }
        }
        out.println(
                "Ordered and filtered elements found in the array are : " + Arrays.toString(orderedFiltered.toArray()));
        out.println("Duplicate elements found in the array are : " + Arrays.toString(results.toArray()));
    }

    
    /**
     * Generic method to find duplicates in array. Complexity of this method is O(n)
     * because we are using HashSet data structure.
     * 
     * @param array
     * @return
     */
    public static <T extends Comparable<T>> void getDuplicates(T[] array) {
        Set<T> dupes = new HashSet<T>();
        for (T i : array) {
            if (!dupes.add(i)) {
                System.out.println("Duplicate element in array is : " + i);
            }
        }

    }

}

Jayamohan · Answer 14 · 2012-12-17T10:33:12.733

0

Try this

public static int[] removeDuplicates(int[] s) {     
    Integer[] array = new HashSet<Integer>(Arrays.asList(ArrayUtils.toObject(s))).toArray(new Integer[0]);      
    return ArrayUtils.toPrimitive(array);
}

Edit: Updated with Apache Lang to convert to primitives.

edited Dec 17 '12 at 10:33

answered Dec 17 '12 at 10:14

Jayamohan

12,734
2
27
41

1

That would give an `Integer[]` array, though. – Anders R. Bystrup Dec 17 '12 at 10:16
Edited the reply. Updated to primitive data type. – Jayamohan Dec 17 '12 at 10:33

score 0 · Answer 15 · answered Dec 17 '12 at 11:12

public class Test 
static int[] array = {4, 3, 3, 4, 5, 2, 4};
static HashSet list = new HashSet();
public static void main(String ar[])
{       
    for(int i=0;i<array.length;i++)
    {         
      list.add(array[i]);

    }
    System.out.println(list);
}}

The Output is : [2, 3, 4, 5]

score 0 · Answer 16 · answered Jul 28 '13 at 08:45

You can do naively though. First you need to sort the array. You can do it using any of sorting algorithms. I did use quick sort. And then check a position with its next position. If they are not same, add value in a new array, otherwise skip this iteration.

Sample Code (Quick Sort):

 public static void quickSort(int[] array, int low, int high) {
    int i = low;
    int j = high;

    int pivot = array[low + (high - low) / 2];

    while (i <= j) {
        while (array[i] < pivot) i++;
        while (array[j] > pivot) j--;
        if (i <= j) {
            exchange(array, i, j);
            i++;
            j--;
        }
    }
    if (0 < j) quickSort(array, 0, j);
    if (i < high) quickSort(array, i, high);
}

public static void exchange(int[] array, int i, int j) {
    int temp = array[i];
    array[i] = array[j];
    array[j] = temp;
}

Remove duplicates:

 public static int[] removeDuplicate(int[] arrays) {
    quickSort(arrays, 0, arrays.length - 1);

    int[] newArrays = new int[arrays.length];
    int count = 0;
    for (int i = 0; i < arrays.length - 1; i++) {
        if (arrays[i] != arrays[i + 1]) {
            newArrays[count] = arrays[i];
            count++;
        }
    }
    return newArrays;
}

Throwing "quicksort" into this is not helpful. If you are going to sort at all, the correct (Java) solution is to use `Arrays.sort(int[])`. And there are simpler ways to solve the problem that don't involve sorting. — Stephen C, Dec 29 '13 at 01:43
Besides, this reorders the remaining elements of the array, and the Question *requires* the order to be preserved. — Stephen C, Dec 29 '13 at 01:47

score 0 · Answer 17 · answered Apr 18 '14 at 19:32

public class DistinctNumbers{
    public static void main(String[] args){
        java.util.Scanner input = new java.util.Scanner(System.in);

        System.out.print("Enter ten numbers: ");
        int[] numbers = new int[10];
        for(int i = 0; i < numbers.length; ++i){
            numbers[i] = input.nextInt();
        }
        System.out.println("The distinct numbers are:");
        System.out.println(java.util.Arrays.toString(eliminateDuplicates(numbers)));
    }

    public static int[] eliminateDuplicates(int[] list){
        int[] distinctList = new int[list.length];
        boolean isDuplicate = false;
        int count = list.length-1;
        for(int i = list.length-1; i >= 0; --i){
            isDuplicate = false;
            for(int j = i-1; j >= 0 && !isDuplicate; --j){
                if(list[j] == list[i]){
                    isDuplicate = true;
                }
            }
            if(!isDuplicate){
                distinctList[count--] = list[i];
            }
        }
        int[] out = new int[list.length-count-1];
        System.arraycopy(distinctList, count+1, out, 0, list.length-count-1);
        return out;
    }
}

score 0 · Answer 18 · answered Oct 11 '16 at 02:22

hey all you can use this code that i create!!!

import java.util.*;

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

        int[] nums=  {1,3,2,3,4,3,2,5,4,6}; 
        int [] T2 = duplicate(nums);
        for (int i = 0; i < T2.length; i++) {
            System.out.println(T2[i]);

        } 
    }
    public static boolean exist(int x,int []A){
        for (int i = 0; i < A.length; i++) {
            if(x==A[i]){
                return true;
            }
        }
        return false;
    }
    public static int [] EliminateDuplicate(int [] numbers){
       int [] B = new int[numbers.length];
       int i=0,j=0;
       for(i=0;i<numbers.length;i++){
           if(!exist(numbers[i], B)){
               B[j] = numbers[i];
               j++;
           }

       }
       int[] C = new int[j];
        for (int k = 0; k < C.length; k++) {
            C[k] = B[k];

        }
       return C;
    }


}

score 0 · Answer 19 · answered Dec 14 '17 at 13:32

You can do something like this

  public class MyClass {

    public static void main(String args[]) {

        int[] man = {4,56,98,89,78,45,78, 79, 56};

        for (int i = 0; i < man.length; i++)
        {
            for (int j = i+1; j < man.length; j++)
            {
                //check if it is equal
               if (man[i] == man[j])
                {

                     man[j] = man[j] -1;

               //Decrementing size

                   j--;
                }
            }
        }

         //Array without duplicates

        for(int k=0; k<man.length; k++)
        {

            System.out.print(" " + man[k]);
        } 
    }
}

score 0 · Answer 20 · answered Jun 17 '18 at 01:11

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

// Remove duplicates from a list of integers
public class IntegerUtils {
    public static void main(String[] args) {
        int intArray[] = {1, 2, 4, 2, 67, 4, 9};
        List<Integer> uniqueList = removeDuplicates(intArray);
        uniqueList.stream().forEach(p -> System.out.println(p));
    }

    public static List<Integer> removeDuplicates(int[] intArray) {
        return Arrays.stream(intArray).boxed().distinct().collect(Collectors.toList());
    }
}

Praveen Gopal · Answer 21 · 2019-05-02T07:52:26.750

0

int[] arrayRemoveDuplicates= Arrays.stream("integerArray").distinct().toArray();
    // print the unique array
    for (int i = 0; i < arrayRemoveDuplicates.length; i++) {
        System.out.println(arrayRemoveDuplicates[i]);
    }

Java.util.streamapi introduced in java 8

edited May 02 '19 at 07:52

answered Jul 06 '18 at 14:19

Praveen Gopal

529
8
23

score -1 · Answer 22 · answered Aug 24 '17 at 23:17

import java.util.*;

public class Duplicates {

public static void main(String[] args) {
    // TODO Auto-generated method stub

    int [] myArray  = {1,3,2,4,3,2,3,4,5,6,7,6,5,4,3,4,5,6,76,5,4,3,4,4,5};
    List <Integer> myList = new ArrayList <Integer>();
    myList = removeDuplicates(myArray);

    //Printing Output   
    for (int k=0; k<myList.size();k++)
        System.out.print(" "+ myList.get(k));

}

private static List<Integer> removeDuplicates(int[] myArray) {
    // TODO Auto-generated method stub
    Arrays.sort(myArray);
    List <Integer> myList = new ArrayList <Integer>();
    for (int i=0; i<myArray.length-1; i++){

         if (myArray[i]!= myArray[i+1]){    

                    myList.add(myArray[i]);
            }

    }
    myList.add(myArray[myArray.length-1]);

    return myList;
}

}

Guest · Answer 23 · 2015-05-28T04:32:41.993

public class Foo {

public static void main(String[] args) {
    //example input
    int input[] = new int[]{1, 6 , 5896, 5896, 9, 100,7, 1000, 8, 9, 0, 10, 90, 4};
    //use list because the size is dynamical can change
    List<Integer> result = new ArrayList<Integer>();

    for(int i=0; i<input.length; i++)
    {
        boolean match = false;
        for(int j=0; j<result.size(); j++)
        {
            //if the list contains any input element make match true
            if(result.get(j) == input[i])
                match = true;
        }
        //if there is no matching we can add the element to the result list
        if(!match)
            result.add(input[i]);
    }
    // Print the result
    for(int i=0; i<result.size(); i++)
        System.out.print(result.get(i) + ", ");

}

} output: 1, 6, 5896, 9, 100, 7, 1000, 8, 0, 10, 90, 4,

Add some explanation to your answer. – HaveNoDisplayName May 28 '15 at 04:22 — HaveNoDisplayName, May 28 '15 at 04:22
Edited: you can see the explanation in the comments – Guest May 28 '15 at 04:33 — Guest, May 28 '15 at 04:33

Remove duplicates from integer array

23 Answers23

Linked

Related