Conversion long -> byte[]

Version imprimable

Salut,

Je dois ecrire un long dans un fichier, et ce long doit tenir au grand max sur 8 octets. Pour diverses raisons, je dois passer par une String pour ecrire les octets dans mon fichier, comme dans le code ci-dessous. Mais au-dela d'une certaine valeur (99.999.999), la String qui represente mon long est codee sur plus de 8 octets. Comment faire pour que la String representant mon long soit codee sur maximum 8 octets ?
Code:

1 2 3 4 5 6 7 8 9 10 long goodValue = 99999999l; String correctSizeString = String.valueOf(goodValue); int correctSize = correctSizeString.getBytes().length; long badValue = 100000000; String badSizeString = String.valueOf(badValue); int badSize = badSizeString.getBytes().length; System.out.println("Correctly encoded [" + correctSize + "]"); System.out.println("Wrongly encoded [" + badSize + "]");
Code:

1 2 Correctly encoded [8] Wrongly encoded [9]
Merci.

Nuriel

11/08/2010, 20h00
tchize_

si ça doit faire 8 caractères, la liste des valeurs possible est donc [-9999999,99999999], il suffit de tester si le long en question rentre dans le range, et si pas le refuser. Notez que c'est déjà beaucoup plus court que la liste des valeurs admissibles pour un entier.
11/08/2010, 22h18
thelvin

Soyons logiques : si le long doit faire exactement 8 bytes, il s'agit probablement de sa représentation binaire, qui tient effectivement sur 8 octets.

Et donc, dans ce cas-là, il ne faut pas passer par une String, bien entendu -_-°.
Idéalement utiliser un DataOutputStream avec son writeLong(), mais si ça ne va pas ou s'il faut écrire en little endian, décomposer manuellement le long en bytes (comme indiqué dans DataOutput.writeLong(), mais en sens inverse.)

Voir Long.toBinaryString(). Il peut y avoir besoin de rajouter des 0 cependant.

Citation:

Envoyé par http://download.oracle.com/javase/6/docs/api/java/lang/Long.html#toBinaryString(long)

This value is converted to a string of ASCII digits in binary (base 2) with no extra leading 0s.
Code:

1 2 3 4 5 6 7 8 9 10 String s = Long.toBinaryString(l); if (s.length() < 64) { StringBuilder builder = new StringBuilder(64); for (int i = 0 ; i < 64 - s.length() ; i++) { builder.append("0"); } builder.append(s); s = builder.toString(); }

12/08/2010, 10h57
tchize_

Citation:

Envoyé par bouye

Voir Long.toBinaryString(). Il peut y avoir besoin de rajouter des 0 cependant.

cf son poste d'origine: ca doit tenier sur 8 octets dans la string (8 caractères je suppose donc), tu va stocker un byte en base 2 :D
12/08/2010, 11h51
bouye

On s'en fout, il a la representation binaire sous forme de String, à lui de coller ça dans 8 octets désormais. C'est pas comme si c'était dur (plus rapide de passer sans String, mais bon... tant pis pour lui).

Alternativement, il n'a qu'à convertir chacun des 8 octets en byte puis en char, ca fera une String de 8 charactères et à lui d'éviter d'en stocker 16 à l'écriture.

Ou alors tu prends les octets 2 à 2 tu formes une chaine de 4 caractères. Voilà pas dur, rien de tordu...
12/08/2010, 12h22
tchize_

ou alors en notation base64 tant qu'on y est :D

Merci de votre aide. J'ai decide de convertir chacun de mes caracteres dans ma chaine en char, puis en byte, et d'ecrire mon tableau de bytes. Je recois d'une autre partie du code un tableau de String, representant ce que je dois ecrire dans mon fichier. L'une de ces valeurs est en fait un numeric long, meme s'il est represente en String. Comme je souhaite eviter d'avoir des cas particuliers selon le type de la donnee, je vais faire limiter les valeurs possibles a celles donnees plus haut. Ci-dessous ma methode d'ecriture dans mon fichier.

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
private void persistRoom(long newRecordPosition, String[] data) throws IOException {
 
    	/*
    	 * To avoid writing on the disk field by field, converting
    	 * each of them in a byte array, and then copy those arrays
    	 * into writtenResult which in turn will be written on the disk at once
    	 */
    	byte[] writtenResult = new byte[RECORD_WITH_STATUS_LENGTH];
    	int currentPosition = 0;
 
		//Setting the deleted flag
    	System.arraycopy(new byte[]{RECORD_STATUS_VALID_FLAG}, 
    			0, writtenResult, currentPosition, RECORD_STATUS_FIELD_SIZE);
    	currentPosition += RECORD_STATUS_FIELD_SIZE;
 
		/*
    	 * Testing the validity of the record
    	 * If a field is encoded on more than its size,
    	 * Throw a db error exception. 
    	 */
		for(int i = 0; i < data.length; i++) {
			String tempField = data[i];
 
			/*
			 * Checking that the data received has the expected size or less.
			 * data[i] should have at most size fieldLength[i]
			 * This protects the following loop from a ArrayOutOfBoundException
			 */
			byte[] tempByteArray = new byte[fieldLength[i]];
 
			if(tempField.length() > tempByteArray.length) {
				throw new DatabaseFailureException("Field [" + fieldName[i] 
				                                   + "] with value [" + data[i] 
				                                   + "] is too big to be encoded. " 
				                                   + "Expected size [" + fieldLength[i] 
				                                   + "] Found size [" 
				                                   + tempField.length() + "]");
			}
 
			/*
			 * Padding the data with BLANK_BYTE in case it is smaller than
			 * the expected size.
			 */
			for(int j = 0; j < tempField.length(); j++) {
				if(j < tempByteArray.length) {
					tempByteArray[j] = (byte)tempField.charAt(j);
				} else {
					tempByteArray[j] = BLANK_BYTE;
				}
			}
 
			log.finest("Field converted from [" + tempField 
					+ "] to [" + new String(tempByteArray));
			System.arraycopy(tempByteArray, 0, writtenResult, 
								currentPosition, tempByteArray.length);
			currentPosition += fieldLength[i];
		}
 
    	dbFileAccess.seek(newRecordPosition);
	dbFileAccess.write(writtenResult);
    }