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

Answer 1

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.

Answer 2

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;
}

Answer 3

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;
}

Answer 4

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.

Answer 5

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;     

}

Answer 6

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

Answer 7

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

    }

}

Answer 8

What you have to do is , you have to check for each element in second array whether previous element is already present or not.

You can use better approach Use HashSet and return set.

public static Set removeDuplicates(int []s){
  Set<Integer> set = new HashSet<Integer>();       
   for(int i=0;i<s.length;++i){
          set.add(s[i]);
        }//endFori
  return set;
}//endMethod

If you need int Array than take a look of this java-hashsetinteger-to-int-array link.

Answer 9

您还可以将数组元素放入一个Set中，语义正是因为它不包含任何重复元素。

Answer 10

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.

Answer 11

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;
}

Answer 12

您也可以使用Google的Guava库并使用ImmutableSet

ImmutableSet.copyOf(myArray).asList();

Answer 13

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]

Answer 14

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;
}

Answer 15

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]

Answer 16

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;
    }
}

Answer 17

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;
    }


}

Answer 18

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

Answer 19

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]);
        } 
    }
}

Answer 20

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]

Answer 21

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());
    }
}

Answer 22

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

Answer 23

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;
}

}

Answer 24

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,