Tu ne peux pas vraiment. Java n'a aucun type de données non signé, à l'exception de char.
Certes, vous pourriez utiliser char - c'est un type non signé de 16 bits - mais ce serait horrible à mon avis, puisque char est clairement destiné au texte: lorsque le code utilise char, je pense qu'il l'utilise pour Unités de code UTF-16 représentant un texte intéressant pour le programme, et non des entiers arbitraires 16 bits non signés sans relation avec le texte.
Si vous avez vraiment besoin d'une valeur avec exactement 16 bits:
Solution 1: Utilisez le raccourci signé disponible et cessez de vous soucier du signe, sauf si vous devez effectuer des opérations de comparaison (<, <=,>,> =) ou de division (/,%, >>). Voir cette réponse pour savoir comment gérer les numéros signés comme s'ils n'étaient pas signés.
Solution 2 (où la solution 1 ne s'applique pas): Utilisez les 16 bits inférieurs de int et supprimez les bits supérieurs avec & 0xffff si nécessaire.
C'est un fil vraiment fade, mais pour le bénéfice de tous ceux qui viendront après. Le caractère est un type numérique. Il supporte tous les opérateurs mathématiques, les opérations sur les bits, etc. C'est un 16 non signé.
Nous traitons les signaux enregistrés avec du matériel embarqué personnalisé, de sorte que nous traitons un grand nombre de 16 non signés provenant de l'adaptateur. Nous utilisons des personnages partout depuis des années et n'avons jamais eu de problèmes.
Vous pouvez utiliser un caractère, car il s'agit d'une valeur 16 bits non signée (bien que, techniquement, il s'agisse d'un caractère unicode, elle pourrait éventuellement être modifiée pour devenir une valeur 24 bits à l'avenir) c'est à portée.
N'utilisez pas de personnage - utilisez un int :-)
Et voici un lien discutant de Java et de l'absence de unsigned .
Aucun type de ce type en Java
De DataInputStream.Java
public final int readUnsignedShort() throws IOException {
int ch1 = in.read();
int ch2 = in.read();
if ((ch1 | ch2) < 0)
throw new EOFException();
return (ch1 << 8) + (ch2 << 0);
}
Eh oui, si vous voulez utiliser la valeur dans les opérations code vs.
"Dans Java SE 8 et versions ultérieures, vous pouvez utiliser le type de données int pour représenter un entier 32 bits non signé, qui a une valeur minimale de 0 et une valeur maximale de 232-1." Cependant cela ne s'applique qu'à int et long mais pas à court :(
Non, vraiment, il n'y a pas de telle méthode, Java est un langage de haut niveau. C'est pourquoi Java n'a aucun type de données non signé.
Il a déclaré qu'il souhaitait créer un tableau court multidimensionnel. Pourtant, personne n'a suggéré d'opérateurs au niveau des bits? D'après ce que j'ai lu, vous voulez utiliser des entiers 16 bits sur des entiers 32 bits pour économiser de la mémoire?
Donc, pour commencer, commencer par 10 000 x 10 000 valeurs courtes correspond à 1 600 000 000 bits, 200 000 000 octets, 200 000 kilo-octets, 200 mégaoctets.
Si vous avez besoin de 200 Mo de consommation de mémoire, vous voudrez peut-être revoir cette idée. Je ne crois pas non plus que cela va même compiler et encore moins courir. Vous ne devriez jamais initialiser de grands tableaux de ce type si quelque chose utilise 2 fonctionnalités appelées Chargement à la demande et Mise en cache des données. Essentiellement, le chargement à la demande fait référence à l'idée de ne charger que les données nécessaires. Ensuite, la mise en cache des données fait la même chose, mais utilise un travail de cadre personnalisé pour supprimer l'ancienne mémoire et ajouter de nouvelles informations selon les besoins. Celui-ci est difficile à obtenir de bonnes performances de vitesse. Il y a d'autres choses que vous pouvez faire, mais ces deux-là sont mes préférées quand c'est bien fait.
Revenons à ce que je disais à propos des opérateurs au niveau des bits.
Donc, un entier 32 bits ou en Java "int". Vous pouvez stocker ce que l'on appelle des "bits" dans ceci. Supposons que vous ayez 32 valeurs booléennes qui toutes en Java prennent 32 bits (sauf les longueurs) ou 8 pour les tableaux, 8 pour octet, 16 pour court et 32 pour int. . Donc, à moins que vous n'ayez des tableaux, l'utilisation d'un octet ou d'un court-circuit ne vous procure aucun avantage en termes de mémoire. Cela ne signifie pas que vous ne devriez pas l'utiliser comme moyen de vous assurer, à vous et à d'autres personnes, de connaître la plage de données que cette valeur devrait avoir.
Comme je le disais, vous pouvez stocker efficacement 32 Booléens dans un seul entier en procédant comme suit:
int many_booleans = -1; //All are true;
int many_booleans = 0; //All are false;
int many_booleans = 1 | 2 | 8; //Bits 1, 2, and 4 are true the rest are false;
Alors maintenant, un court-circuit est composé de 16 bits, donc 16 + 16 = 32, ce qui correspond parfaitement à un entier de 32 bits. Ainsi, chaque valeur int peut être composée de 2 valeurs courtes.
int two_shorts = value | (value2 << 16);
La valeur ci-dessus correspond donc à une valeur comprise entre -32768 et 32767 ou à une valeur non signée comprise entre 0 et 65535. Supposons donc que la valeur soit égale à -1, de sorte qu'une valeur non signée est 65535. Cela signifie que les bits 1 à 16 sont activés. , mais lorsque vous effectuez le calcul, considérez la plage 0-15.
Nous devons donc activer les bits 17 à 32. Nous devons donc commencer à quelque chose de plus grand que 15 bits. Nous commençons donc à 16 bits. Donc, en prenant value2 et en le multipliant par 65536, c'est ce que "<< 16" fait. Supposons maintenant que valeur2 soit égal à 3, il correspondrait à OR 3x65536 = 196608. La valeur de notre entier serait donc égale à 262143.
int assumed_value = 262143;
alors disons que nous voulons récupérer les deux valeurs entières de 16 bits.
short value1 = (short)(assumed_value & 0xFFFF); //-1
short value2 = (short)(assumed_value >> 16); //=3
Pensez aussi fondamentalement aux opérateurs de bits comme des puissances de 2. C'est tout ce qu'ils sont vraiment. Ne jamais regarder les termes de 0 et 1. J'ai principalement posté ceci pour aider ceux qui pourraient trouver cette recherche de tableaux courts non signés ou même éventuellement multidimensionnels. S'il y a des fautes de frappe, je m'excuse.
Si l'utilisation d'une bibliothèque tierce est une option, il existe jOOU (une bibliothèque dérivée de jOOQ ), qui propose des types d'encapsuleur pour les nombres entiers non signés en Java. Ce n'est pas exactement la même chose que d'avoir un support de type primitif (et donc de code octet) pour les types non signés, mais cela reste peut-être suffisant pour votre cas d'utilisation.
import static org.joou.Unsigned.*;
// and then...
UShort s = ushort(1);
(Avertissement: je travaille pour l'entreprise derrière ces bibliothèques)