[Débutant] incrémenter un identifiant composé de chiffres et de lettres

Version imprimable

21/02/2008, 16h35
jmnicolas

[Débutant] incrémenter un identifiant composé de chiffres et de lettres
Bonjour,

je cherche à créer un identifiant unique composé de chiffres et de lettres, mais pas toutes les lettres ni tous les chiffres.

Imaginons que les valeurs possibles pour l'identifiant soient :

Code:

3 8 B Y

(en réalité j'en ai plus mais c'est juste pour l'exemple).

Mon identifiant est composé de n positions utilisant chacune une de ces lettres ou chiffres. En gros dans l'ordre ça donne :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 3 8 B Y 33 38 3B 3Y 83 88 8B 8Y B3 ...
Donc je voudrais faire un truc du style :

analyser la position la plus à droite (grâce à substr)

si c'est la dernière lettre de "l'alphabet" remplacer par la première (dans mon exemple si c'est Y remplacer par 3) et analyser la position de gauche

sinon "incrémenter" la position de 1 (si on est à 3 passer à 8).

Je vois pas trop quel type de "liste" il me faut choisir, il me semble que enum ne convienne pas, et qu'une arraylist soit peut être trop "marteau pour écraser un moustique".

Donc si vous avez des suggestions je suis preneur :)
21/02/2008, 16h55
kourkoul

je n ai peut etre pas tres bien compris ton pb , mais il me semble que tu pourrais utiliser une table de correcpondance, pas exemple
["3", "8", "B", "Y"]

puis tu pourrais utiliser un Integer par exemple comme compteur

et si a un moment ta besoin de generer un ID a partir d un nombre
tu prends chaque chiffre et tu l utilises comme indice du tableeau de traduction :
0 te donnerait "3" etc

et si tu as plus (ou moins) d'elements dans le tableau de traduction que le decimal, tu peux convertir to entier dans n importe quelle base puis faire la correcpondance

peut etre il existe une meilleure solution, mais je te donne des idees :)

++

Salut,

En fait dans ton exemple tu utilises une base 4 mais avec des caractères différents : au lieu d'utiliser 0,1,2,3 tu utilises 3,8,B,Y.

En se basant sur les méthodes toString(int,int) et parseInt(String,int) de la classe Integer il est facile de faire des méthodes permettant de générer des nombres en bases n avec les caractères que tu veux :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
class MyNumber {
 
	/** Tableau des caractères utilisées pour générer le nombre */
	private final static char[] DIGITS = { '3', '8', 'B', 'Y' };
	private final static int RADIX = DIGITS.length;
 
	/** Méthode de convertion d'un int vers notre format */
	public static String toString(int i) {
 
		char buf[] = new char[33];
		boolean negative = (i < 0);
		int charPos = 32;
 
		if (!negative) {
			i = -i;
		}
 
		while (i <= -RADIX) {
			buf[charPos--] = DIGITS[-(i % RADIX)];
			i = i / RADIX;
		}
		buf[charPos] = DIGITS[-i];
 
		if (negative) {
			buf[--charPos] = '-';
		}
 
		return new String(buf, charPos, (33 - charPos));
	}
 
	/** Retourne simplement l'index du caractères dans le tableau des digits */
	private static int digit(char c) {
		return Arrays.binarySearch(DIGITS, c);
	}
 
	/** Méthode de convertion d'un chaine de notre format vers un int */
	public static int toInteger(String s) throws NumberFormatException {
		if (s == null) {
			throw new NumberFormatException("null");
		}
 
		int result = 0;
		boolean negative = false;
		int i = 0, max = s.length();
		int limit;
		int multmin;
		int digit;
 
		if (max > 0) {
			if (s.charAt(0) == '-') {
				negative = true;
				limit = Integer.MIN_VALUE;
				i++;
			} else {
				limit = -Integer.MAX_VALUE;
			}
			multmin = limit / RADIX;
			if (i < max) {
				digit = digit(s.charAt(i++));
				if (digit < 0) {
					throw new NumberFormatException("For input string: \"" + s
							+ "\"");
				} else {
					result = -digit;
				}
			}
			while (i < max) {
				// Accumulating negatively avoids surprises near MAX_VALUE
				digit = digit(s.charAt(i++));
				if (digit < 0) {
					throw new NumberFormatException("For input string: \"" + s
							+ "\"");
				}
				if (result < multmin) {
					throw new NumberFormatException("For input string: \"" + s
							+ "\"");
				}
				result *= RADIX;
				if (result < limit + digit) {
					throw new NumberFormatException("For input string: \"" + s
							+ "\"");
				}
				result -= digit;
			}
		} else {
			throw new NumberFormatException("For input string: \"" + s + "\"");
		}
		if (negative) {
			if (i > 1) {
				return result;
			} else { /* Only got "-" */
				throw new NumberFormatException("For input string: \"" + s
						+ "\"");
			}
		} else {
			return -result;
		}
	}
}

:arrow: Ca a l'air de fonctionner normalement :

Code:

1
2
3
4
5
	for (int i = 0; i < 20; i++) {
		String s = MyNumber.toString(i);
		int v = MyNumber.toInteger(s);
		System.out.printf("%10d %10.10s %10d%n", i, s, v);
	}

Et si tu veux ajouter des caractères il suffit de modifier le tableau DIGITS...

a++

21/02/2008, 17h21
kourkoul

ca fait plaisir de voir que mes idees de jeune innocent correspondent plus aux idees des grands utilisateurs experimentes de ce forum :)
++

Bon après avoir cogité hier soir, et par pur esprit de contradiction ( et surtout parce que j'ai du mal à comprendre l'exemple d'adiGuba ;) ) j'ai décidé de ne pas utiliser un tableau qui stockerait toutes mes lettres possibles mais plutôt une string !

Grâce à la méthode indexOf ça me permet de déterminer le char suivant celui actuel.

Je vous livre une ébauche de code, ça ne compile pas mais l'idée est là.

rangeOfPossibilities est une string qui contient toutes mes lettres et firstChar et lastChar sont des char qui recensent la première et dernière lettre de rangeOfPossibilities.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 public String createNewId() { // ici on récupérera la dernière ID connue (lue dans le fichier texte) String lastId = "79DDDDD" ; String newId = lastId ; int i ; // on parcourt chaque char de lastId en partant de la fin if (lastId != null) { for (i = lastId.length() - 1 ; i >= 0 ; i--) { if (lastId.charAt(i) != lastChar) { // on récupère l'index de la lettre suivant la lettre actuelle int nextIndex = rangeOfPossibilities.indexOf(lastId.charAt(i)) + 1 ; // on attribue la nouvelle lettre à la nouvelle ID newId.charAt(i) = rangeOfPossibilities.charAt(nextIndex) ; break ; } else newId.charAt(i) = firstChar ; } } else newId = "" + firstChar ; return newId ; }