Finding repeating numbers in an array

int[] numbers = { 1, 5, 23, 2, 1, 6, 3, 1, 8, 12, 3 };
Arrays.sort(numbers);

for(int i = 1; i < numbers.length; i++) {
    if(numbers[i] == numbers[i - 1]) {
        System.out.println("Duplicate: " + numbers[i]);
    }
}

This sorts the array numerically, then begins iterating the array. It checks the previous element in the array and if it equals the current element, then you have a duplicate.

Create a Map<Integer, Integer> (first number is the number you are looking, second is the number of appearences).

Run through your array. Each time you find a number, do map.get(numberFound) to see if you had already found it. If you had not, put the number with a counter of 1. If you had, retrieve the counter, increase it and put it back into the map.

I'm gonna throw my 2 cents in aswell :)

If you're allowed to used objects I'd do it like this.

Sets automatically holds non-duplicates so if it contains it it's no chance of the value going in a again.

int[] arrayOfInt = { 1, 2, 3, 5, 1, 2, 7, 8, 9, 10 };
Set<Integer> notDupes = new HashSet<Integer>();
Set<Integer> duplicates = new HashSet<Integer>();
for (int i = 0; i < arrayOfInt.length; i++) {
    if (!notDupes.contains(arrayOfInt[i])) {
        notDupes .add(arrayOfInt[i]);
        continue;
    }
    duplicates.add(arrayOfInt[i]);
}
System.out.println("num of dups:" + duplicates.size());
System.out.println("num of norls:" + notDupes.size());

I would use Set for this example.Logic would be:

1) Create an empty Set MySet, and another empty Set ResultSet

2) Read each number and perform this on it:

a) Check if it is in MySet.
b) If its in MySet then put it in ResultSet.
c) If its not in MySet, then put it in Myset.

3) ResultSet contains the required numbers.

The benefit of this approach would be that the complexity would reduce to "n logn" instead of "n^2".

you may use google collection framework Guava's Multiset<Integer> to find repetating number.

Elements of a multiset that are equal to one another (see "Note on element equivalence", below) are referred to as occurrences of the same single element. The total number of occurrences of an element in a multiset is called the count of that element (the terms "frequency" and "multiplicity" are equivalent, but not used in this API). Since the count of an element is represented as an int, a multiset may never contain more than Integer.MAX_VALUE occurrences of any one element.

Multiset<Integer> set = HashMultiset.create();
void sjekk(){
        System.out.println("Write five numbers");
        for(int i = 0; i < numbers.length; i++){
        set.add(inn.nextInt());
    }
...
for(Multiset.Entry<Integer> entry : set.entrySet()){ 
 System.out.println("Element :-> "+entry.getElement()+" Repeat Cnt :-> "+entry.getCount());
}