A method that returns an array with no duplicates I implemented a method in Java that returns an array of integers with no duplicates (i.e. an array that has no repeated numbers).

My solution seems rather long. I would like to know of ways to improve it...

public class IntArrayProcessor {

    private int[] a;

    public IntArrayProcessor(int[] a) {
        this.a = a;
    }

    /**
     * 
     * @return Array with no repeated integers.
     */
    public int[] getSet() {
        /* creates an array with the same entries and length as this.a */
        int[] duplicateA = new int[this.a.length];

        /* stores the number of repeated entries in array this.a */
        int numberOfDuplicates = 0;

        /* is the integer a duplicate or not? */
        boolean isDuplicate;

        /**
         * Counts the number of duplicates in array this.a
         */
        for (int i = 0; i &lt; this.a.length; i++) {
            duplicateA[i] = this.a[i];
        }

        for (int i = 0; i &lt; duplicateA.length; i++) {
            isDuplicate = false;
            for (int j = i + 1; j &lt; this.a.length; j++) {
                if (duplicateA[i] == this.a[j]) {
                    isDuplicate = true;
                }
            }
            if (isDuplicate) {
                numberOfDuplicates++;
            }
        }

        /*
         * the noDuplicate array has the lenght of the this.a array minus the
         * number of repeated entries
         */
        int[] noDuplicate = new int[this.a.length - numberOfDuplicates];

        /* to keep track of the noDuplicate indexes */
        numberOfDuplicates = 0;

        /**
         * An array with no repeated numbers
         */
        for (int i = 0; i &lt; duplicateA.length; i++) {
            isDuplicate = false;
            for (int j = i + 1; j &lt; this.a.length; j++) {
                if (duplicateA[i] == this.a[j]) {
                    isDuplicate = true;
                }
            }
            if (!(isDuplicate)) {
                noDuplicate[numberOfDuplicates] = duplicateA[i];
                numberOfDuplicates++;
            }
        }
        return noDuplicate;
    }
}
Wouldn't it be easier to just use:
public static class IntArrayProcessor {

    private Integer[] arr;

    public IntArrayProcessor(Integer[] arr) {
        this.arr = arr;
    }

    public Integer[] unique() {
        final Set&lt;Integer&gt; uniqueSet = new HashSet&lt;Integer&gt;(Arrays.asList(this.arr));
        return uniqueSet.toArray(new Integer[uniqueSet.size()]);
    }
}

I changed the method name from getSet() to the more descriptive unique().
This simply generates a hash set, which contains only the unique values of the array. The hash set (uniqueSet) is then converted from Set to Integer[], and returned.
Given that this is using built-in methods and objects, it would likely be faster than most custom implementations.
Notice that HashSet:

makes no guarantees as to the insertion order of the set; in particular it does not guarantee that the order will remain constant over time.
— HashSet documentation

If you need to keep insertion order, use LinkedHashSet as suggested in @mrblewog's comment. If you want to have the internal Set sorted, use SortedSet or TreeSet.
I also changed int[] to Integer[] so that it can be used with generics (generics do not support primitive types).