La conversion à partir de l'octet de type int en java

J'ai généré une sécurité de nombres aléatoires, et mettre sa valeur dans un octet. Voici mon code.

SecureRandom ranGen = new SecureRandom();
byte[] rno = new byte[4]; 
ranGen.nextBytes(rno);
int i = rno[0].intValue();

Mais j'obtiens une erreur :

 byte cannot be dereferenced

Quelle erreur avez-vous ?
Il y a une différence entre byte et Octet. Ce dernier est un objet, qui serait en charge de la .intValue() méthode. Le premier est le nombre d'octets brut de valeur et juste de l'attribuer comme int i = rno[0];
Voir aussi stackoverflow.com/questions/2383265/convert-4-bytes-to-int

InformationsquelleAutor Ashwin | 2012-03-06

java type-conversion

66

Votre tableau est de byte primitives, mais que vous essayez d'appeler une méthode sur eux.

Vous n'avez pas besoin de faire quelque chose explicite pour convertir un byte à un int, juste:
```
int i=rno[0];
```
...car il n'est pas abattu.

Noter que le comportement par défaut de byte-à-int de conversion est de préserver le signe de la valeur (rappelez-vous byte est un type signé en Java). Ainsi, par exemple:
```
byte b1 = -100;
int i1 = b1;
System.out.println(i1); //-100
```
Si vous avez pensé de la byte non signés (156) plutôt que de signé (-100), pour obtenir l'équivalent de la valeur dans le int vous auriez besoin de masquer le signe de bits:
```
byte b2 = -100; //Or `= (byte)156;`
int i2 = (b2 & 0xFF);
System.out.println(i2); //156
```
Juste pour être complet, #1: Si vous ne souhaitez utiliser les différentes méthodes de Byte pour une raison quelconque (vous n'avez pas besoin d'ici), vous pouvez utiliser un boxe de conversion:
```
Byte b = rno[0]; //Boxing conversion converts `byte` to `Byte`
int i = b.intValue();
```
Ou la Byte constructeur:
```
Byte b = new Byte(rno[0]);
int i = b.intValue();
```
Mais encore une fois, vous n'avez pas besoin de ça ici.

Juste pour être complet, #2: Si c' ont été un abattu (par exemple, si vous essayez de convertir un int à un byte), tous vous avez besoin est un plâtre:
```
int i;
byte b;

i = 5;
b = (byte)i;
```
Ceci assure le compilateur que vous savez que c'est d'un triste, donc vous n'avez pas la possibilité "d'une perte de précision" erreur.
- À l'aide de l'Octet constructeur n'est pas une bonne idée. Il suffit de ne Byte b = rno[0]; à la place.
- Je devrais avoir mentionné la boxe conversions, que faire maintenant.
- Pourquoi est-boxe de conversion supérieur à Octet constructeur dans ce cas? ma compréhension de la boxe de conversion les extrémités à l'aide de l'Octet constructeur à la fin, de toute façon? est ma compréhension incorrecte?
- Oui. La boxe va utiliser Byte.valueOf, pas new Byte(), pour éviter d'allouer une nouvelle instance s'il en existe déjà un pour que la valeur d'un octet; plus d'infos ici. (Les specs n'est pas réellement dire qu', mais qu'est ce qu'elle fait. Vous pouvez dire en regardant le bytecode.)
InformationsquelleAutor T.J. Crowder
33
```
byte b = (byte)0xC8;
int v1 = b;       //v1 is -56 (0xFFFFFFC8)
int v2 = b & 0xFF //v2 is 200 (0x000000C8)
```
La plupart du temps, v2 est la façon dont vous avez réellement besoin.
- c'est parce que l'ordinateur 32 bits générés le long 0xffffffc8, Merci.
- Cette réponse est la bonne, et v2 est presque toujours ce que vous voulez. La conversion implicite de byte int sans & 0xff est une source de bugs en Java.
- Ce n'est pas vraiment due à des "bugs" en Java" de la conversion implicite. C'est grâce à développeur d'un malentendu. Java byte primitive prend uniquement en charge les valeurs entre -128 à 127. Si quelqu'un essaie de les farcir une valeur non signée (comme 0xC8) en cela, il est possible de rouler dessus avec un tas de meneurs (en raison de la notation en complément à deux). De même, pour cette question, un peu d'espace peut avoir un bit de signe et une numérique de promotion va faire de même.
- Java est en train de faire conversion numérique sous le capot, selon la JLS, ce qui signifie que les deux opérandes sont convertis en int primitives, de toute façon.
- Pas de bugs en Java, des bugs dans le code de l'utilisateur écrit en Java 🙂 la Plupart des programmeurs ne se rendent pas compte octets sont signés en Java, et franchement, c'est stupide comportement par défaut de traiter octets signée en Java spec, mais ils l'ont fait pour des raisons de cohérence avec les autres types intégraux, puisque aucun d'entre eux ont unsigned versions. Le même problème arrive avec la conversion de courts-métrages à ints, puisque les gens aussi, généralement, ne se rendent pas compte shorts sont signés. (Il est plus facile de déclencher l'extension du signe de bugs avec les octets si, en raison du nombre limité de valeurs.) Les gens ne s'attendent ints et aspire à être signé si.
InformationsquelleAutor Sheng.W
30

si vous souhaitez combiner les 4 octets en un seul int ce que vous devez faire
```
int i= (rno[0]<<24)&0xff000000|
       (rno[1]<<16)&0x00ff0000|
       (rno[2]<< 8)&0x0000ff00|
       (rno[3]<< 0)&0x000000ff;
```
J'utilise 3 opérateurs spéciaux | est l'logiques bit à bit OU & est logique, et << est le décalage à gauche

en essence je combiner les 4 octets de 8 bits en un seul 32 bits int en déplaçant les octets en place et le joint torique ensemble

J'ai aussi assurer un signe de promotion n'affectera pas le résultat avec & 0xff
- Je le ferais (rno[0]&0x000000ff)<<24|(rno[1]&0x000000ff)<<16| ... etc. donc, je peux alors faire que ET-ing opérande constante. Alternativement, vous pourriez tout aussi bien faire ((int)rno[0])<<24|((int)rno[1])<<16| ... comme le type coulée met automatiquement les valeurs d'octets dans la primitive int de l'espace.
- Votre "Ou" suggestion est incorrect! Voir Sheng.W réponse. Vous presque toujours besoin de faire des b & 0xff) pour convertir un octet de type int, pas ((int) b) ou l'équivalent implicite en fonte, en raison de l'extension du signe.
- Vous me @LukeHutchison ... La deuxième, dans mon commentaire ne fonctionne que pour des valeurs non signées (espace positif) au sein de la gamme de la Java primitive (jusqu'à 127).
- La plage positive de la valeur signée n'est pas une valeur non signée, il a encore le signe '+' 🙂 Octets et les shorts et les services de renseignements et longs sont signés en Java, il n'existe pas de version non signée!
InformationsquelleAutor ratchet freak
6

Types de données primitifs (comme octet) n'ont pas de méthodes en java, mais vous pouvez directement faire:
```
int i=rno[0];
```
- mais il y a une fonction appelée octet.intValue() en java docs
- Non, c'est Byte.intValue, tandis que Byte est une classe, byte est un type de données primitif.
- l'a obtenu. merci
- Cette réponse est incomplète. Voir Sheng.W réponse. Vous presque toujours besoin de faire (b & 0xff) pour convertir un byte à int, pas ((int) b) ou l'équivalent implicite fonte, int i = b;, en raison de l'extension du signe de la haute-peu-ensemble d'octets. L'oubli de ce qui est une source commune de bugs.
InformationsquelleAutor MByD
3

Octets sont convertie à ints.

Juste dire
```
int i= rno[0];
```
- Mais notez que le signe est préservé, ce qui n'est pas toujours ce que vous voulez (Java n'a pas d'octets non signés)
InformationsquelleAutor Saintali
2

J'ai pensé qu'il serait:
```
byte b = (byte)255;
int i = b &255;
```
InformationsquelleAutor joe

Vous devez vous connecter pour publier un commentaire.