Count occurrences of elements inside array? (Java)

Question

I have been working on trying to figure out this algorithm for about 6 hours now and can't seem to come up with a solution. I am trying to count the occurrences of elements inside an array and may two more separate arrays. One for the unique instances, and one for how many times these instances occurs. I found some other thinks on here about array lists and hashMaps, but I am only able to use arrays.

For example, I have this array (already sorted):

{cats, cats, cats, dog, dog, fish}

I am trying to get make an array for the instances, so:

{cats, dog, fish}

And finally, how many times these instances occur:

{3, 2, 1}

Here is the code i have so far:

public void findArrs( String[] words )
{
  int counter = 1;
  for(int i = 0; i < words.length - 1; i++){
  if(!(words[i].equals(words[i+1]))){
  counter++; 
  }
 }

 String[] unique = new String[counter];
 int[] times = new int[counter];

 for(int i = 0; i < words.length; i++){

   }    
}

This is all the code I have after all my attempts.

Answer 1

It would be very simple if you use ArrayList. But since you want especially Arrays, here's my code.

int lth = words.length;
// Specify a broad length
String[] unique = new String[lth];
int[] times = new int[lth];

int i = 0;
int j = 0;
int count;
while (i < lth) {
    String w = words[i];
    count = 1;
    while(++i < lth && words[i].equals(w)) ++count;
    unique[j] = w;
    times[j++] = count;
}

// Reduce the length of the arrays    
unique = Arrays.copyOf(unique, j);
times  = Arrays.copyOf(times, j);     

for (i = 0; i < unique.length;++i)
    System.out.println(unique[i] + " " + times[i]);

As you can see the real problem is the length of the Arrays that you have to specify before using them. With ArrayLists you wouldn't have to. Also, since the items are sorted prefer using a while loop instead of a for loop. It just looks good.

Answer 2

This is how it could be done using only arrays. The tricky part is you must know the number of items before the array is created. So I had to create my own function to create a bigger array. Actually two, one for the count and one for the unique values.

If you can use Vectors you will be better off. Here is it without vetors:

public class HelloWorld{

     public static void main(String []args){
        String[] initalArray;

        // allocates memory for 10 integers
        initalArray = new String[6];
        initalArray[0] = "cats";
        initalArray[1] = "cats";
        initalArray[2] = "cats";
        initalArray[3] = "dog";
        initalArray[4] = "dog";
        initalArray[5] = "fish";

        String[] uniqueValues = new String[0];
        int[] countValues = new int[0];
        for(int i = 0; i < initalArray.length; i++)
        {
            boolean isNewValue = true;
            for (int j = 0; j < uniqueValues.length; j++)
            {
                if (uniqueValues[j] == initalArray[i])
                {
                    isNewValue = false;
                    countValues[j]++;
                }
            }

            if (isNewValue)
            {
                // We have a new value!
                uniqueValues = addToArrayString(uniqueValues, initalArray[i]);
                countValues = addToArrayInt(countValues, 1);
            }
        }

        System.out.println("Results:");
        for(int i = 0; i < countValues.length; i++)
        {
            System.out.println(uniqueValues[i] + "=" +  countValues[i]);
        }
     }

     public static String[] addToArrayString(String[] initalArray, String newValue)
     {
         String[] returnArray = new String[initalArray.length+1];
         for(int i = 0; i < initalArray.length; i++)
         {
             returnArray[i] = initalArray[i];
         }
         returnArray[returnArray.length-1] = newValue;

         return returnArray;
     }

     public static int[] addToArrayInt(int[] initalArray, int newValue)
     {
         int[] returnArray = new int[initalArray.length+1];
         for(int i = 0; i < initalArray.length; i++)
         {
             returnArray[i] = initalArray[i];
         }
         returnArray[returnArray.length-1] = newValue;

         return returnArray;
     }
}

As mentioned in the comments, if we know the array is in order, then we don't need to search through the entire previous array and can just check uniqueValues directly.

public class HelloWorld{

     public static void main(String []args){
        String[] initalArray;

        // allocates memory for 10 integers
        initalArray = new String[6];
        initalArray[0] = "cats";
        initalArray[1] = "cats";
        initalArray[2] = "cats";
        initalArray[3] = "dog";
        initalArray[4] = "dog";
        initalArray[5] = "fish";

        String[] uniqueValues = new String[0];
        int[] countValues = new int[0];
        for(int i = 0; i < initalArray.length; i++)
        {
            boolean isNewValue = true;
            if (i > 0)
            {
                if (uniqueValues[uniqueValues.length-1] == initalArray[i])
                {
                    isNewValue = false;
                    countValues[uniqueValues.length-1]++;
                }
            }

            if (isNewValue)
            {
                // We have a new value!
                uniqueValues = addToArrayString(uniqueValues, initalArray[i]);
                countValues = addToArrayInt(countValues, 1);
            }
        }

        System.out.println("Results:");
        for(int i = 0; i < countValues.length; i++)
        {
            System.out.println(uniqueValues[i] + "=" +  countValues[i]);
        }
     }

     public static String[] addToArrayString(String[] initalArray, String newValue)
     {
         String[] returnArray = new String[initalArray.length+1];
         for(int i = 0; i < initalArray.length; i++)
         {
             returnArray[i] = initalArray[i];
         }
         returnArray[returnArray.length-1] = newValue;

         return returnArray;
     }

     public static int[] addToArrayInt(int[] initalArray, int newValue)
     {
         int[] returnArray = new int[initalArray.length+1];
         for(int i = 0; i < initalArray.length; i++)
         {
             returnArray[i] = initalArray[i];
         }
         returnArray[returnArray.length-1] = newValue;

         return returnArray;
     }
}

Answer 3

Make unique, times as instance variable so that you can retrieve them from another class using getter methods.

Note: Modified code can be found through comments (for line "Added line". for block between "Added code starts here" to "Added code ends here"). I tried to explain the implementation in code. Please let me know through comments if I need to work more on my documentation skills

public class someClass(){
  private String[] unique;
  private int[] times;
  //Added code starts here
  public String[] getUnique(){
    return this.unique;
  }

  public int[] getTimes(){
    return this.times;
  }
  //Added code ends here
  //Below implementation would work as intended only when words array is sorted
  public void findArrs( String[] words ) 
  {
    int counter = 1;
    for(int i = 0; i < words.length - 1; i++){
        if(!(words[i].equals(words[i+1]))){
            counter++; 
        }
    }

    unique = new String[counter];
    times = new int[counter];
    //Added line.
    unique[0] = words[0];  
    for(int i=0,j=0; i < words.length&&j < counter; i++){
   //Added code starts here
       if(!(unique[j].equals(words[i]))){
            j++; //increment count when latest element in unique array is not equal to latest element in words array
            unique[j] = words[i]; //add newly found unique word from words array to unique array
            times[j] = 1; //make the count to 1 for first non repeated unique word

        }
        else{

            times[j]++; //increment the count every time the string repeats
        }
   //Added code ends here
   }    
  }
}

Answer 4

String s[] = {"Arranged", "Administered", "Advised", "Administered", "Adapted"}; //Store a pre-defined amount of words

String k="I have administered and advised him to stay away."; //A string that you want to match if it contains those words

String ka[]=k.split("\\s");//Split the string on evry space occurrence so that it extracts each word

for(i=0;i<ka.length;i++)

{for(j=0;j<s.length;j++){

if(ka[i].equalsIgnoreCase(s[j]))

{System.out.println("The occurred words are:" +s[j]);

continue;//Continue is used to find if more that one word has occurred

}

}

}

Answer 5

Assuming that the words array has at least one element:

int numberOfDifferentWords = 1;
String firstWord = words[0];
for(int i = 0; i < words.length; i++) {
    if(!firstWord.equals(words[i])) {
        numberOfDifferentWords++;
    }
}

// These two arrays will contain the results. 
String[] wordResultArray = new String[numberOfDiffentWords];
int[] countResultArray = new int[numberOfDiffentWords];

// This will mark where we should put the next result
int resultArrayIndex = 0;

String currentWord = firstWord;
int currentWordCount = 0;
for(int i = 0; i < words.length; i++) {
    //if we're still on the same word, increment the current word counter
    if(currentWord.equals(words[i])) {
        currentWordCount++;
    }
    //otherwise, transition to a new word
    else {
        wordResultArray[resultArrayIndex] = currentWord;
        wordCountArray[resultArrayIndex] = currentWordCount;
        resultArrayIndex++;

        currentWord = words[i];
        currentWordCount = 1;
    }
}

As other answers have mentioned, this problem could be simplified by using a List such an ArrayList to store the results.

Answer 6

You can achieve it using TreeMap:

public class NumberOfOccurences {

    public static void main(String[] args) {
        String[] testArr = {"cats", "cats", "cats", "dog", "dog", "fish"};
        String output = countNumberOfChild(testArr);

        System.out.println(output);

    }


    public static String countNumberOfChild(String[] list){
        Arrays.sort(list);

        TreeMap<String,Integer> noOfOccurences = new TreeMap<String,Integer>();


        for(int i=0;i<list.length;i++){
            if(noOfOccurences.containsKey(list[i])){
                noOfOccurences.put(list[i], noOfOccurences.get(list[i])+1);
            }
            else{
                noOfOccurences.put(list[i], 1);
            }
        }

        String outputString = null;
        while(!noOfOccurences.isEmpty()){
            String key = noOfOccurences.firstKey();
            Integer value = noOfOccurences.firstEntry().getValue();
            if(outputString==null){
                outputString = key+"="+value;
            }
            else{
                outputString = outputString + ";" + key+"="+value;
            }
            noOfOccurences.remove(key);
        }

        return outputString;
    }
}