# Zählen gleiche Werte in Array



## Ganzir (27. Nov 2008)

Hallo,

wie kann ich in einem Array die Elemente zählen die identisch sind.

Mal angenommen ich habe folgenden Array:


```
int[][] zahlen = 
		 {{34,255,255,56},{127,204,11,34},{123,98,127,34},{34,34,127,17}};
```

Was muss ich nun tun, damit ich die folgende Ausgabe erhalte:

11 = 1 mal
17= 1 mal
34 = 5 mal

usw.

Mit ist die enum-funktion bekannt, jedoch musste ich feststellen, dass ich in enum keine Zahlen verwenden kann.


Greetz
Ganzir


----------



## hdi (27. Nov 2008)

Kann man sicher schöner machen, ich habs jetzt runtergeschrieben, aber es müsste korrekt sein.
Beachte aber bitte unbedingt folgendes: Das ganze funktioniert jetzt nur, wenn dein gegebenes Array 
keine Nullen enthält. Denn Standardmässig ist unser Hilfs-Array mit nullen befüllt. Wenn du Nullen hast,
initialisier das count-Array mit -1 oder sowas. Wenn du auch negative Zahlen hast, und den Wertebereich
nicht kennst, kannst du das so leider nicht mehr lösen...


```
public class ArrayZaehler {

	public static void main(String[] args) {

		int[][] zahlen = { { 34, 255, 255 }, { 127, 204, 11, 34 },
				{ 123, 98, 127, 34 }, { 34, 34, 127, 17 } };
		zaehle(zahlen);
	}

	private static void zaehle(int[][] array) {

       // Wir erstellen uns ein 2d-Hifsarray, dass paarweise die Zahl und die Anzahl ihrer Vorkommen enthält.
       // Es kann nicht länger sein als die Anzahl der Elemente im gegebenen Array (dann würde jedes Element
       // genau 1x vorkommen.)

		int maxLen = 0;
		for (int i = 0; i < array.length; i++) {
			maxLen += array[i].length;
		}
		int[][] count = new int[maxLen][2]; // paarweise Zahl<->ihre Anzahl
		int numFilled = 0;

		// diese schleife geht die blöcke durch, also {..}, {..}
		for (int i = 0; i < array.length; i++) {
			// diese schleife durchsucht die einzelnen blöcke
			for (int j = 0; j < array[i].length; j++) {
				// momentanes element speichern:
				int current = array[i][j];
				// nachsehen, ob es das schon im hilfsarray gibt:
				boolean found = false;
				for (int k = 0; k < count.length; k++) {

					if (current == count[k][0]) {
						// Zahl schon gefunden, ihren counter erhöhen:
						count[k][1] = count[k][1] + 1;
						// und aufhören, weiter zu suchen:
						found = true;
						break;
					}

				}
				// schleife wurde komplett durchsucht, und nix gefunden:
				if (!found) {
					// Zahl gibt es noch nicht, einfügen:
					count[numFilled][0] = current;
					count[numFilled][1] = 1;
					numFilled++;
				}
			}
		}

		// Fertig, das kann man jetz formatiert ausgeben:
		for (int i = 0; i < count.length; i++) {
			if (count[i][0] != 0) { // bzw. != dein Initial-Wert
				System.out.println("Zahl " + count[i][0] + " kommt "
						+ count[i][1] + " mal vor.");
			}
		}
	}
}
```


----------



## Ganzir (27. Nov 2008)

Hallo hdi,

das ist sehr nett was du da geschrieben hast, es funktioniert auch, jedoch bin ich absoluter Anfänger und hatte mir eine etwas plumpere Methode ausgedaucht:


```
public static void main (String args[])
	 {   

		 int z_11 = 0;
		 
		 int[][] zahl = 
		 {{34,255,255,56},{127,204,11,34},{123,98,127,34},{34,34,127,17}};
	 
		 
		 for (int i = 0; i < zahl.length; i++)
		 {
			 for (int j = 0; j < zahl[0].length; j++)

				 System.out.print(zahl[i][j] + "\t");
			 System.out.println();
			 int current = zahl[i][j]; //<-  An dieser Stelle sagt er mit er kann j nicht resolven - kannst du mir sagen wieso? bei dir klappt da doch auch int current = array[i][j]; 
			
			 }

		 }
	
	 }
```


----------



## Marco13 (27. Nov 2008)

Es fehlt noch die { für die innere for-Schleife.

Nochmal eine Lösugn, die man verwenden kann, wenn das ganze nicht ausführungs- sondern Entwicklungszeitritisch ist:

```
import java.util.*;

class ArrayCount
{
    public static void main(String args[])
    {
        int[][] a = {{34,255,255,56},{127,204,11,34},{123,98,127,34},{34,34,127,17}};
        count(a);
    }

    private static void count(int a[][])
    {
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        for (int i=0; i<a.length; i++)
        {
            for (int j=0; j<a[i].length; j++)
            {
                map.put(a[i][j], map.containsKey(a[i][j])?map.get(a[i][j])+1:1);
            }
        }
        for (Integer k : map.keySet())
        {
            System.out.println(k+": "+map.get(k)+" times");
        }
    }


}
```


----------



## hdi (27. Nov 2008)

Jo, und so macht man es schön  Ich hatte mir auch erst gedacht ich sollte ne Map nehmen, aber dachte dann das is genauso kompliziert. Diese Zeile:


```
map.put(a[i][j], map.containsKey(a[i][j])?map.get(a[i][j])+1:1);
```

hat es in sich^^ Das so zu machen kommt einem auch nur, wenn man die Map-Methoden im Kopf hat alle xD


----------



## Marco13 (27. Nov 2008)

Naja - erst hatte ich sie als

```
if (!map.containsKey(a[i][j]))
{
    map.put(a[i][j], 0);
}
map.put(a[i][j], map.get(a[i][j])+1);
```
was etwas übersichtlicher ist - optional dann auch 

```
if (!map.containsKey(a[i][j]))
{
    map.put(a[i][j], 1);
}
else
{
    map.put(a[i][j], map.get(a[i][j])+1);
}
```
aber ...  ich glaube, sie wirkt nur durch die arrayzugriffe so kompliziert:

```
map.put(n, map.containsKey(n)?map.get(n)+1:1);
```
ist doch auch hübsch....


----------

