Zählen der vorkommen der Elemente im array? (Java)

Dies ist, wie es getan werden könnte, nur mithilfe von arrays. Der schwierige Teil ist, Sie müssen wissen, die Anzahl der Elemente, bevor das array angelegt wird. Also musste ich meine eigene Funktion zu erstellen, die einem größeren array. Eigentlich zwei, eine für die Zählung und eine für die eindeutige Werte.

Wenn kann man Vektoren verwenden, werden Sie besser dran. Hier ist es ohne 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;
     }
}

Wie bereits erwähnt in den Kommentaren, wenn wir wissen, dass das array in Ordnung ist, dann brauchen wir nicht suchen über den gesamten vorherigen array und kann nur überprüfen uniqueValues-direkt.

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;
     }
}

InformationsquelleAutor ansible

Unter der Annahme, dass die words array muss mindestens ein 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;
    }
}

Anderen Antworten erwähnt habe, könnte dieses problem vereinfacht werden, indem eine Liste wie ArrayList zum speichern der Ergebnisse.

InformationsquelleAutor martiansnoop

Es wäre sehr einfach, wenn man ArrayList verwenden. Aber da Sie wollen, vor allem, Arrays, hier ist mein 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]);

Wie Sie sehen können, das eigentliche problem ist die Länge der Arrays, die Sie angeben müssen, bevor Sie Sie verwenden. Mit ArrayLists, die Sie nicht haben, um.
Auch, da die Elemente sortiert werden, lieber mit einer while-Schleife statt einer for-Schleife. Es sieht einfach gut aus.

InformationsquelleAutor user3173787

Hier ist ganz einfach JavaScript:

var myarray = {"cats", "cats", "cats", "dog", "dog", "fish"};
var values = [];
var instanceCount = []
for(var i = 0; i < myarray.length; i++){
    var value = myarray[i];
    var counter = 0;
    for(var j = 0; j < myarray.length; j++){
        if(firstVal == myarray[j]) counter++;
    }
    //Build your arrays with the values you asked for
    values.push(value);
    instanceCount.push(counter);

    //Remove All occurences further in the array
    var idx = myarray.indexOf(value);
    while (idx != -1) {
        myarray.splice(idx, 1);
        idx = array.indexOf(myarray, idx + 1);
    }
}

//Handle Result here

InformationsquelleAutor Pierre