String Kombination erstellen anhand fortlaufender Zahl (Vertragsnummer)

[internet]

Hallo,

ich würde gerne für eine Vertragsverwaltung meine Vertragsnummer in der Form gestalten, sodass man nicht gleich nachvollziehen kann, wieviel Verträge ich habe.
Eine Nummer darf es nur 1x geben.

Beispiel:
PAS6-AS8D

Das ganze soll durch eine fortlaufende Nummer erstellt werden:
Also:
1 = PAS6-AS8D
2 = POAO-AS3D

Wie könnte man sowas lösen?

Klar, ich könnte natürlich einen Zufallsstring generieren und dann jedes Mal gegen die Datenbank prüfen, ob es diese Vertragsnummer schon gibt. Aber das würde dann u.U. mehrere SQL Abfragen sein (falls die Vertragsnummer bereits besteht)...

Danke für jede Hilfe

 

[Gelöschtes Mitglied 65838]

du kannst dir in sql UIDs generieren lassen

How to automatically generate unique id in SQL like UID12345678?

I want to automatically generate unique id with per-defined code attach to it. ex: UID12345678 CUSID5000 I tried uniqueidentifier data type but it generate a id which is not suitable for a use...

stackoverflow.com

 

[internet]

danke, aber mir wäre das in Java aber lieber

 

[temi]

Wir haben mal für eine eindeutige ID einfach die Unix-Timestamp hergenommen und die zur einfacheren Lesbarkeit als Hexwert verwendet.
https://www.unixtimestamp.com

Beispiel: Die Vertragsnummer vor wenigen Minuten wäre die 61AB7AB4 geworden.

 

[internet]

Wir haben mal für eine eindeutige ID einfach die Unix-Timestamp hergenommen und die zur einfacheren Lesbarkeit als Hexwert verwendet.
https://www.unixtimestamp.com

Beispiel: Die Vertragsnummer vor wenigen Minuten wäre die 61AB7AB4 geworden.

die Idee gefällt mir... hast du auch ein Code Snippet?

 

[mrBrown]

Wir haben mal für eine eindeutige ID einfach die Unix-Timestamp hergenommen und die zur einfacheren Lesbarkeit als Hexwert verwendet.

Da muss man allerdings aufpassen, dass nur eine pro Sekunde erzeigt werden darf.

Klar, ich könnte natürlich einen Zufallsstring generieren und dann jedes Mal gegen die Datenbank prüfen, ob es diese Vertragsnummer schon gibt. Aber das würde dann u.U. mehrere SQL Abfragen sein (falls die Vertragsnummer bereits besteht)...

Das musst du so oder so machen, wenn Eindeutigkeit gefordert ist.

Die Wahrscheinlichkeit von Kollisionen kannst du dann nur über die Länge reduzieren. UUIDs zB sind lang genug, dass doppelte IDs nahezu ausgeschlossen sind, aber durch die Länge nicht wirklich praktikabel.

 

[Neumi5694]

Du kannst anstatt der Systemzeit auch einem Random-Long wert verwenden, um irgendwas daraus zu erstellen.
Wichtig ist, dass du eine zentrale Stelle hast, welche die IDs vergibt und bei Erstelleung auch gleich mit prüft, ob die ID schon vergeben ist und dann gegebenenfalls eine neue generiert.

 

[Gelöschtes Mitglied 65838]

Du kannst anstatt der Systemzeit auch einem Random-Long wert verwenden, um irgendwas daraus zu erstellen.
Wichtig ist, dass du eine zentrale Stelle hast, welche die IDs vergibt und bei Erstelleung auch gleich mit prüft, ob die ID schon vergeben ist und dann gegebenenfalls eine neue generiert.

die zentrale stelle wäre eine datenbank ... die wird das schon gebacken kriegen einen eindeutigen key erzeugen zu können aber das ist ja nicht gewünscht

also muss man da schon weit ausholen

random key erzeugen -> db fragen obs schon gibt -> wenns schon gibt dann gleich nochmal einen erzeugen

 

[mrBrown]

die zentrale stelle wäre eine datenbank ... die wird das schon gebacken kriegen einen eindeutigen key erzeugen zu können aber das ist ja nicht gewünscht

Die meisten DBs können entweder fortlaufende Nummern generieren, das widerspricht der einzigen Anforderung:

ich würde gerne für eine Vertragsverwaltung meine Vertragsnummer in der Form gestalten, sodass man nicht gleich nachvollziehen kann, wieviel Verträge ich habe.

oder genieren UUIDs, die alles andere als Menschen-Benutzbar sind

 

[berndoa]

Ich muss da gerade an die Sache mit der Diagonalisierung denken, die mir mal in einem MAthebeweis enutzt wurde:
Du hast also eine Liste an schon vorhandenen Nummern, wie bspw.
1 = PAS6-AS8D
2 = POAO-AS3D

Dann generierst du eine (in dem Fall 8 stellige) neue Nummer, in dem
du guckst dass die 1. ziffer nicht mit der 1. ziffer der ersten Zahl überinstimmt
(also mit was anderem als P beginnt)
Dann 2. ziffer was anderes als die 2. ziffer der 2. zahl
(also als 2. ziffer kein O benutzen)
etc.

klingt umständlich, mahct aber sinn und stellt sicher dass sich die erzeugte Zahl iM Vergleich zu jeder der bisherigen Nummern in mindestens einer Ziffer unterscheidet.
Hier mit nur 2 Zahlen bisher war das "overkill", da würde es schon reichen wenn du die Zahl mit Q oder so beginnst.
Das funktioniert erst besser wenn du mehr als 8 Zahlen da hast (also zahlenanzahl>Zahlenlänge).

Oder so.

Zumindest lässt sich diese Methode hier sicherlich abgewandelt irgendwie anwenden.

Das kam in mathe vor als es zu beweisne galt dass die Menge an reellen zahlen (bzw. bereits alle Zahlen der Form 0.irgendwas) überabzählbar ist

 

[Oneixee5]

Du könntest so etwas versuchen:

//    final List<Character> list = Arrays.asList('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
//            'O', 'P', 'U', 'V', 'W', 'X', 'Y', 'Z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9');
//    Collections.shuffle(list);


    private static final List<Character> CHARS1 = Arrays.asList('Y', '7', 'B', '4', 'C', 'D', 'H', 'P', 'Z', 'O', 'E',
            '0', 'L', '1', '5', '9', '3', 'V', 'N', 'J', 'F', 'U', 'K', '2', 'X', 'A', '6', 'I', 'W', '8', 'M', 'G');

    private static final List<Character> CHARS2 = Arrays.asList('P', '1', 'V', 'D', 'B', 'O', 'H', 'Y', 'W', 'F', '0',
            'E', 'M', '5', 'U', 'I', '8', '9', 'K', 'N', 'J', 'X', 'Z', 'G', '6', '4', 'L', '3', 'A', '7', '2', 'C');

    public static String convert(final List<Character> chars, int decimal) {
        int index;
        String result = "";
        final int len = chars.size();
        while (decimal > 0) {
            index = decimal % len;
            result = chars.get(index) + result;
            decimal = decimal / len;
        }
        return result;
    }

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

        final Set<String> set = new HashSet<>();
        String contractId;
        for (int i = 1; i < 1000000000; i++) {
            contractId = convert(CHARS1, 1000000000 + i) + "-" + convert(CHARS2, 1000000000 + i);
            set.add(contractId);

            if (i % 1000 == 0) {
                final long heapFreeSize = Runtime.getRuntime().freeMemory();
                System.out.format("round: %s \t   free heap size: %s \t example contract id: %s%n",
                        i, humanReadableByteCount(heapFreeSize), contractId);

                if (i > 1000000 && heapFreeSize < 120000000) {
                    // low memory, here it probably makes no sense to continue
                    throw new OutOfMemoryError();
                }
            }

            //System.out.println(" of " + i + " is: \t" + convert(CHARS1, 1000000000 + i) + "-" + convert(CHARS2, 1000000000 + i));
        }

        System.out.format("resulting set contains %s unique items", set.size());
    }

    public static String humanReadableByteCount(final long bytes) {
        final long absB = bytes == Long.MIN_VALUE ? Long.MAX_VALUE : Math.abs(bytes);
        if (absB < 1024) {
            return bytes + " B";
        }
        long value = absB;
        final CharacterIterator ci = new StringCharacterIterator("KMGTPE");
        for (int i = 40; i >= 0 && absB > 0xfffccccccccccccL >> i; i -= 10) {
            value >>= 10;
            ci.next();
        }
        value *= Long.signum(bytes);
        return String.format("%.1f %ciB", value / 1024.0, ci.current());
    }

Man erschafft quasi sein eigenes Zahlensystem, welches man sogar wieder ins Dezimalsystem umrechnen könnte.
Wenn du nicht in der DB nachschauen willst, ob Vertragsnummern kollidieren, dann kann man sich einen Vorrat an eindeutigen Vertragsnummern speichern. Das wird hier in einem Set gemacht. Diesen Vorrat müsste man natürlich irgendwo speichern und benutzte Vertragsnummern entfernen. Wie so eine Art Sequenz in einer DB.

round: 37458000        free heap size: 182,3 MiB      example contract id: M8LKN3-27MZK8
round: 37459000        free heap size: 180,3 MiB      example contract id: M8L2VX-27MG96
round: 37460000        free heap size: 179,3 MiB      example contract id: M8LXVY-27M69P
round: 37461000        free heap size: 177,3 MiB      example contract id: M8LA3Z-27M48W
round: 37462000        free heap size: 175,3 MiB      example contract id: M8L693-27MLI8
round: 37463000        free heap size: 174,3 MiB      example contract id: M8LI5X-27M3U6
round: 37464000        free heap size: 172,3 MiB      example contract id: M8LW5Y-27MAUP
round: 37465000        free heap size: 171,3 MiB      example contract id: M8L81Z-27M75W

Für das Beispiel muss man darauf achten, dass der JVM genug Speicher zur Verfügung steht - und das dauert ein Weilchen!

 

[Oneixee5]

Man könnte das auch so machen:

        for (int i = 1; i < 1000000000; i++) {
            for (int j = 1; i < 1000000000; j++) {
                contractId = convert(CHARS1, 1000000000 + i) + "-" + convert(CHARS2, 1000000000 + j);
                set.add(contractId);
...

Dann wäre der Bereich der erzeugten Vertragsnummern noch viel größer.

 

[mihe7]

Wobei mir hier ein String für das Alphabet besser gefallen würde. Außerdem muss man die Darstellung der Zahl nicht unbedingt mit der höchstwertigen Stelle beginnen lassen

    public static String convert(final String chars, int decimal) {
        int index;
        StringBuilder result = new StringBuilder();
        final int len = chars.length();
        while (decimal > 0) {
            index = decimal % len;
            result.append(chars.charAt(index));
            decimal = decimal / len;
        }
        return result.toString();
    }

EDIT: noch ein Beispiel:

jshell> System.out.println(convert("AB3C4P5Q7S6", 2021) + "-" + convert("42A31F75G9Z60X", 10006))
7QPB-Z493
jshell> System.out.println(convert("AB3C4P5Q7S6", 2021) + "-" + convert("42A31F75G9Z60X", 10012))
7QPB-A293

 

[Oneixee5]

Wobei mir hier ein String für das Alphabet besser gefallen würde. Außerdem muss man die Darstellung der Zahl nicht unbedingt mit der höchstwertigen Stelle beginnen lassen

Ja, das stimmt, es handelt sich nicht um eine fertige Implementierung. Der Code ist als Beispiel gedacht und die Chars sollten sich leicht an Zufallskombinationen anpassen lassen. Die Vertragsnummern sollten immer die einheitliche maximale Länge haben. Es kann gern alles geändert und verbessert werden.