Input/Output fehlerhafter Algorithmus zum Ersetzen von Array-Werten nach logischem Schema

[datfrog]

Hallo!
Ich habe einen Algorithmus geschrieben, der leider nicht zu 100% funktioniert.
Er dient zum Erstellen eines Umkehrschlüssels anhand des Ursprungsschlüssels und insgesamt für das Ver- und Entschlüsseln einer Nachricht. Dies funktioniert insgesamt, nur leider wird der Umkehrschlüssel nicht richtig umgewandelt.

Der Ursprungsschlüssel ist ein int-Array, welcher das Alphabet symbolisiert und dem für die Stellen von 0-25 (quasi a - z) unterschiedliche Zahlen zwischen 0 und 25 genau einmal und nicht erneut an die gleiche Stelle zugeordnet sind (i.F. einer bijektiven Abbildung).

Als Beispiel:
- an der Stelle [0] die Zahl 12: Die Stelle 0 steht für a und die Stelle 12 für b
In meiner Nachricht (char-Array) wird nun jedes a zu einem b verschlüsselt, indem ich die Nachricht durchsuche und alle Stellen mit dem Wert 0 (also a) durch den Wert meines int-Arrays an der Stelle 0 (also 12) ersetze.

Mein Umkehrschlüssel soll nun später auch mit diesem Schema funktionieren.
Bedeutete - wieder am Beispiel der Stelle [0] = 12 :
Wenn mein Zähler (reverse) gleich dem Wert des int-Arrays an der Stelle 0 ist, soll mein neues int-Array an der Stelle des Wertes den Index des Arrays erhalten.
-> Somit erhält mein Wert an der Stelle [12] den Indexwert 0 als neuen Wert.

Dies funktioniert für 15 von 25 Buchstaben, wohinter jedoch kein Muster zu erkennen ist, weshalb es an manchen Stellen funktioniert und dann noch wieder nicht.
Vielleicht entdeckt ihr in meinem vermeintlich logischem Schema doch einen Fehler oder Fall, den es zu beachten gälte.

Vielen Dank im Voraus!

[CODE lang="java" title="Algorithmus Umkehrschlüssel"]static char[] bijectKey(int[] bK) {

int countKey;
int reverse;

for (countKey = 0; countKey < bK.length; countKey++) {

reverse = bK[countKey]; //
bK[reverse] = countKey; //

}
for (int j = 0; j < bK.length; j++) {
biKey[j] = (char) (bK[j] + 97);
}
return biKey;
}[/CODE]

 

[BestGoalkeeper]

Mal eine kleine Hilfe; weil ich denke, dass du mit dem bisherigen Ansatz nicht weiterkommst:

import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;

public class Keys {
    public static char getCharFromCp(int cp) {
        return (char) ('a' + cp);
    }

    public static List<HashMap<Character, Character>> getBijectKeys(Random r) {
        int n = 'z' - 'a' + 1;
        LinkedHashSet<Integer> lhs = new LinkedHashSet<>();
        while (lhs.size() < n) {
            lhs.add(r.nextInt(n));
        }
        HashMap<Character, Character> a = new HashMap<>();
        HashMap<Character, Character> b = new HashMap<>();
        int i = 0;
        for (Integer key : lhs) {
            a.put(getCharFromCp(i), getCharFromCp(key));
            b.put(getCharFromCp(key), getCharFromCp(i));
            i++;
        }
        return Arrays.asList(a, b);
    }

    public static String enc(String s, List<HashMap<Character, Character>> keys) {
        return s.chars().mapToObj(i -> String.valueOf(keys.get(0).get((char) i))).collect(Collectors.joining());
    }

    public static String dec(String s, List<HashMap<Character, Character>> keys) {
        return s.chars().mapToObj(i -> String.valueOf(keys.get(1).get((char) i))).collect(Collectors.joining());
    }

    public static void main(String[] args) {
        List<HashMap<Character, Character>> keys = getBijectKeys(new Random(0));
        String hallo = "hallo";
        String hallo2 = enc(hallo, keys);
        String hallo3 = dec(hallo2, keys);
        System.out.println(hallo + " " + hallo2 + " " + hallo3);
    }
}

Wobei man auch eine Liste hätte mischen können...