Removing duplicates from array without using Util classes

1. As you are making the result array of the same length as array a so even if you put only unique items in it, rest of the blank items will have the duplicate values in them which is 0 for int array.
2. Sorting will not help you much, as you code is searching the whole array again and again for the duplicates. You need to change your logic for it.
3. You can put some negative value like -1 for all the array items first in result array and then you can easily create a new result array say finalResult array from it by removing all the negative values from it, It will also help you to remove all the zeroes.

In java , arrays are of fixed length. Once created, their size can't be changed. So you created an array of size18. Then after you applied your logic , some elements got deleted. But array size won't change. So even though there are only 8 elements after the duplicate removal, the rest 10 elements will be auto-filled with 0 to keep the size at 18.

Solution ?

1. Store the new list in another array whose size is 8 ( or whatever, calculate how big the new array should be)
2. Keep a new variable to point to the end of the last valid element, in this case the index of 52. Mind you the array will still have the 0 values, you just won't use them.

I am not able to understand how sorting an array can reduce time of execution What ? You sort an array if you need it to be sorted. Nothing else. Some algorithm may require the array to be sorted or may work better if the array is sorted. Depends on where you are using the array. In your case, the sorting will not help.

As for your final question , you can definitely implement your own duplicate removal by searching if an element exists more than once and then deleting all the duplicates.

My code is not working in case of 0

There were no zeroes to begin with in your array. But because its an int[], after the duplicates are removed the remaining of the indexes are filled with 0. That's why you can see a lot of zeroes in your array. To get rid of those 0s, you need to create another array with a lesser size(size should be equal to the no. of unique numbers you've in your array, excluding 0).

If you can sort your array(I see that its already sorted), then you could either bring all the zeroes to the front or push them to the last. Based on that, you can iterate the array and get the index from where the actual values start in the array. And, then you could use Arrays.copyOfRange(array, from, to) to create a copy of the array only with the required elements.

try this

 package naveed.workingfiles;



public class RemoveDups {
    public static void main(String[] args) {
        int[] a = { 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 3, 1, 4, 52, 1, 45, };
        removeDups(a);
    }

private static void removeDups(int[] a) {
    int[] result = new int[a.length];
    int j = 0;
    int count = 0;
    for (int i : a) {
        if (!isExist(result, i)) {
            result[j++] = i;
            count++;
        }
    }
    System.out.println(count + "_____________");
    for (int i=0;i<count;i++) {
        System.out.println(result[i]);
    }

    // return result;
}

private static boolean isExist(int[] result, int i) {
    for (int j : result) {
        if (j == i) {
            return true;
        }
    }
    return false;
}

}

public class RemoveDups {
    public static void main(String[] args) {
        int[] a = { 1, 2, 0, 3, 1,0, 3, 6, 2};
        removeDups(a);
    }

private static void removeDups(int[] a) {
    int[] result = new int[a.length];
    int j = 0;
    int count = 0;
    boolean zeroExist = false;
    for (int i : a) {
        if(i==0 && !zeroExist){
            result[j++] = i;
            zeroExist = true;
            count++;
        }
        if (!isExist(result, i)) {
            result[j++] = i;
            count++;
        }
    }
    System.out.println(count + "_____________");
    for (int i=0;i<count;i++) {
        System.out.println(result[i]);
    }

    // return result;
}

private static boolean isExist(int[] result, int i) {

    for (int j : result) {
        if (j == i) {
            return true;
        }
    }
    return false;
}
}
// It works even Array contains 'Zero'

class Lab2 {
public static void main(String[] args) {
    int[] a = { 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 3, 1, 4, 52, 1, 45 };
    removeDups(a);
}

private static void removeDups(int[] a) {
    int[] result = new int[a.length];
    int j = 0;
    int count = 0;
    for (int i : a) {
        if (!isExist(result, i)) {
            result[j++] = i;
            count++;
        }
    }
    System.out.println(count + "_____________");
    for (int i = 0; i < count; i++) {
        System.out.println(result[i]);
    }
}

private static boolean isExist(int[] result, int i) {
    for (int j : result) {
        if (j == i) {
            return true;
        }
    }
    return false;
}
}