Java - Counting numbers in array

Question

I've written a java prog that stores some values:

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

        //placement of value
        int arryNum[] = {2,3,4,5,4,4,3};

        //placement of index, to start at 0
        for(int counter=0;counter<arryNum.length;counter++){
            System.out.println(counter + ":" + arryNum[counter]);
        }
    }   
}

which generate such output:
0:2
1:3
2:4
3:5
4:4
5:4
6:3

and now I need to count numbers in this output #1. Output #2 should be this:

1: 0
2: 1
3: 2
4: 3
5: 1

It means it counts ONE 2, TWO 3, THREE 4, and only One 5.

I am not sure how to write the code for output 2. Is a binary search needed here?

can anybody shed a light?

Answer 1

if you are expecting in your array values between 1-5 (i assuming this from your expected output)

int arryNum[] = { 2, 3, 4, 5, 4, 4, 3 };
int[] counter = new int[] { 0, 0, 0, 0, 0 };
for (int i = 0; i < arryNum.length; i++) {
    counter[arryNum[i] - 1]++;
}

for (int i = 0; i < counter.length; i++)
    System.out.println((i + 1) + ":" + counter[i]);

Answer 2

I advise you to use a Map:

• If a number doesn't exist in it, add it with the value of 1.
• If the number exists, add 1 to the its value.

Then you print the map as a key and value.

For example, for your array {2,3,4,5,4,4,3} this will work as follows:

Does the map contains the key 2? No, add it with value 1. (The same for 3, 4 and 5)
Does the map contains 4? Yes! Add 1 to its value. Now the key 4 has the value of 2.
...

Answer 3

This is a solution to this problem:

import java.util.Arrays;

public class array05 {
    public static void main(String[] args) {
        //placement of value
        int arryNum[] = {2,3,4,5,4,4,3};

        // Sort the array so counting same objects is easy
        Arrays.sort(arryNum);

        int index = 0;  // The current index
        int curnum;     // The current number
        int count;      // The count of this number
        while (index < arryNum.length) {
            // Obtain the current number
            curnum = arryNum[index];

            // Reset the counter
            count = 0;

            // "while the index is smaller than the amount of items
            // and the current number is equal to the number in the current index,
            // increase the index position and the counter by 1"
            for (; index < arryNum.length && curnum == arryNum[index]; index ++, count++);

            // count should contain the appropriate amount of the current
            // number now
            System.out.println(curnum + ":" + count);
        }
    }   
}

People posted good solutions using Map, so I figured I'd contribute a good solution that will always work (not just for the current values), without using a Map.

Answer 4

If you don't want to use Map, this is how you would do it with Arrays only(if you have numbers from 1 to 9 only)

Integer[] countArray = new Integer[10]

// Firstly Initialize all elements of countArray to zero
// Then
for(i=0;i<arryNum.length();i++){

int j = arryNum[i];
countArray[j]++;

}

This countArray has number of 0's in 1st position, number of 1s in 2nd position and so on

Answer 5

Something like this:

//numbers to count
int arryNum[] = {2,3,4,5,4,4,3};

//map to store results in
Map<Integer, Integer> counts = new HashMap<Integer, Integer>();

//Do the counting
for (int i : arryNum) {
   if (counts.containsKey(i) {
      counts.put(i, counts.get(i)+1);
   } else {
      counts.put(i, 1);
   }
}

//Output the results
for (int i : counts.keySet()) {
   System.out.println(i+":"+counts.get(i));
}

Answer 6

Use Map to store count values:

import java.util.HashMap;
import java.util.Map;

class array05{
  public static void main(String[] args){
      // Container for count values
      Map <Integer, Integer> result = new HashMap<Integer, Integer>();
      int arryNum[] = {2,3,4,5,4,4,3};
      for(int i: arryNum){ //foreach more correct in this case
            if (result.containsKey(i)) result.put(i, result.get(i)+1);
            else result.put(i, 1);
        }
        for (int i: result.keySet()) System.out.println(i + ":" + result.get(i));
  }
}

Result below:

2:1
3:2
4:3
5:1

Answer 7

One approach is to use a map. When you read the first array on each number check if it exists in the map, if it does then just increment the value assigned to the number(key), if not then create a new key in the map with value "1".

Check out http://docs.oracle.com/javase/7/docs/api/java/util/HashMap.html

Answer 8

You can try this way too

 int arrayNum[] = {2,3,4,5,4,4,3};
    Map<Integer,Integer> valMap=new HashMap<>();
    for(int i:arrayNum){ // jdk version should >1.7
        Integer val=valMap.get(i);
        if(val==null){
            val=0;
        }
        valMap.put(i,val+1);
    }
    Arrays.sort(arrayNum);
    for(int i=0;i< arrayNum[arrayNum.length-1];i++){
        System.out.println(i+1+" : "+((valMap.get(i+1)==null) ? 0:valMap.get(i+1)));
    }

Out put

    1 : 0
    2 : 1
    3 : 2
    4 : 3
    5 : 1

But following way is better

    int arrayNum[] = {2,3,4,5,4,4,3};
    Arrays.sort(arrayNum);
    int countArray[]=new int[arrayNum[arrayNum.length-1]+1];
    for(int i:arrayNum){
       countArray[i]= countArray[i]+1;
    }
    for(int i=1;i<countArray.length;i++){
        System.out.println(i+" : "+countArray[i]);
    }

Out put

   1 : 0
   2 : 1
   3 : 2
   4 : 3
   5 : 1

Answer 9

I would prefer some generic solution like this one:

public static <T> Map<T, Integer> toCountMap(List<T> itemsToCount) {
    Map<T, Integer> countMap = new HashMap<>();

    for (T item : itemsToCount) {
        countMap.putIfAbsent(item, 0);
        countMap.put(item, countMap.get(item) + 1);
    }

    return countMap;
}

Answer 10

//Count the times of numbers present in an array
private HashMap<Integer, Integer> countNumbersInArray(int[] array) {
    HashMap<Integer, Integer> hashMap = new HashMap<>();
    for (int item : array) {
        if (hashMap.containsKey(item)) {
            hashMap.put(item, hashMap.get(item) + 1);
        } else {
            hashMap.put(item, 1);
        }
    }
    return hashMap;
}