public boolean habenSelbeDezimalziffern(int a, int b) {
            int[][] ziffern = new int[2][9];                   //Anlegen eines Arrays mit neun Plätzen pro Zahl, auf den neun Plätzen wird dann die Anzahl jeder Ziffer abgespeichert
                                                               //Beispiel 88137 entspricht {1,0,1,0,0,0,1,2,0}
            int[] ab = {a, b};                                 //Speichern der beiden Zahlen in einem Array, um eine Schleifen-Lösung zu ermöglichen
 
            for(int i = 0; i < ab.length; i++) {
                    while(ab[i] > 0) {                         //Überprüfung, ob die zu überprüfende Zahl schon komplett zerteilt wurde
                            ziffern[i][(ab[i] % 10) - 1] += 1; // "ab[i] % 10" ergibt die letzte Ziffer einer Integer-Zahl, die auf ab[i] abgespeichert ist (*)
                                                               //Da die Anzahl der Ziffer 1 auf dem Index 0 abgespeichert wird, addieren wir 1 zu der vorhandenen Anzahl (deswegen +=)
                                                               //auf dem Index ((ab[i] % 10) - 1) hinzu
                            ab[i] = ab[i] / 10;                //Jetzt teilen wir die Zahl durch 10 (beachte Regeln der Integer-Division) und speichern sie ab, damit löschen wir die soeben
                                                               //gefundene Ziffer und können nach der nächsten Ziffer prüfen
                    }
            }
                                                               //Jetzt haben wir alle Ziffern, beider Zahlen a und b gefunden und die entsprechende Anzahl abgespeichert und können nun vergleichen
            for(int i = 0; i < ziffern[0].length; i++) {
                    if(ziffern[0][i] != ziffern[1][i]) {       //Wenn die Anzahl der (i+1)ten Ziffer ungleich ist, dann wissen wir, dass die beiden Zahlen nicht die selben Ziffern haben und wir
                            return false;                      //können frühzeitig abbrechen, ansonsten gehen wir weiter, bis alle Ziffern geprüft sind
                    }
            }
 
            return true;
    }

(*) % wird Modulo ausgesprochen, das Ergebnis von 10 % 3 ist 1, da 10/3 = 3 Rest: 1 ist

ursprüngliche Lösung von CrazyFisch (korrigiert/kommentiert):

 
    public boolean habenSelbeDezimalZahlen(int a , int b) {
            int usedA = a;                                        //Unnötiges Zwischenspeichern
            int usedB = b;
 
            int size = 0;
            int sizeb = 0;
 
            int x;
 
            int ok = 0;
            int bigsize = 0;
 
            //Länge herrausfinden
            while((a % 10) > 0) {
//                    x = a % 10;                                 //sieht unnötig aus, da das Ergebnis nicht verwendet wird.
                    size ++;
                    a = a / 10;
            }
            while((b % 10) > 0) {
//                    x = b % 10;                                 //sieht unnötig aus, da das Ergebnis nicht verwendet wird.
                    sizeb ++;
                    b = b / 10;
            }
 
            int  dec [] = new int[size];
            int decb [] = new int[sizeb];
 
            //Ziffern in richtiger Reihenfolge in Array abspeichern
            while((usedA % 10) > 0) {                             //hier wäre ein richtige for-Schleife übrigens besser gewesen, da die Länge schon bekannt ist
                    x = usedA % 10;
                    dec[size-1] = x;
                    usedA = usedA / 10;
                    size--;
            }
 
            while((usedB % 10) > 0) {                             //siehe Kommentar oben (dies ist übrigens ein Hinweis, dass Code kopiert wurde, also durch eine Hilfsmethode
                    x = usedB % 10;                               //oder eine Schleife besser zu lösen gewesen wäre)
                    decb[sizeb-1] = x;
                    usedB = usedB / 10;
                    sizeb--;
            }
 
            //eigentliche Prüfung der Ziffern
            for(int i=0; i < dec.length; i++) {
                    for(int j=0; j < decb.length; j++) {
                            if(dec[i] == decb[j]) {
                                    ok++;
                                    dec[i] = 0;                   //muss gemacht werden, damit die Ziffer nicht nochmal gefunden wird.
                                    dec[j] = 0;
                            }
                    }
            }
 
            // Anzahl der richtigen Ziffern feststellen
            if(dec.length > decb.length) {                        //Diese Verkettung der if-else Bedingung ist ungeschickt, da direkt >= verwendet hätte werden sollen,
                    bigsize = dec.length;                         //anstatt > somit fällt ein if-Vergleich weg
            }                                                     //Des Weiteren fällt auf, dass wenn die Längen schon unterschiedlich sind, das Ergebnis gar nicht richtig sein kann
            if(dec.length < decb.length) {
                    bigsize = decb.length;
            } else {
                    bigsize = dec.length;
            }
 
            if(bigsize == ok) {                                   //bigsize == ok ist ein boolscher Term, beim Lösen kommt entweder "true" oder "false" heraus
                    return true;                                  //also wäre ein "return (bigsize == ok)" besser
            } else {
                    return false;
            }
    }