unsigned short en java

Si vous avez vraiment besoin d'une valeur avec exactement 16 bits:

Solution 1: Utilisez le short signé disponible et arrêtez de vous inquiéter du signe, sauf si vous avez besoin de faire une comparaison (, >=) ou division (/, %, >>) Opérations. 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 périmé, mais pour le bénéfice de tous ceux qui viennent après. Le caractère est un type numérique. Il prend en charge tous les opérateurs mathématiques, les opérations de bits, etc. C'est un 16 non signé.

Nous traitons les signaux enregistrés par du matériel embarqué personnalisé, donc nous gérons beaucoup de 16 non signés des A-D. Nous utilisons des caractères partout depuis des années et n'avons jamais eu de problèmes.

Vous pouvez utiliser un char, car il s'agit d'une valeur 16 bits non signée (bien que techniquement c'est un caractère unicode, donc pourrait changer potentiellement pour être une valeur 24 bits à l'avenir)... l'autre alternative consiste à utiliser un int et à s'assurer qu'il est à portée.

Ne pas utiliser un char - utiliser un int :-)

Et voici un lien de discuter de Java et de l'absence de unsigned.

Aucun type de ce type en java

Depuis 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);
}

Yep pas une telle chose si vous voulez utiliser la valeur dans le code par rapport aux opérations de bits.

"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 une telle méthode, java est un langage de haut niveau. C'est pourquoi Java n'a pas de types de données non signés.

Il a dit qu'il voulait créer un tableau court multidimensionnel. Pourtant, personne n'a suggéré des opérateurs bit à bit? D'après ce que j'ai lu, vous voulez utiliser des entiers de 16 bits sur des entiers de 32 bits pour économiser de la mémoire?

Donc, tout d'abord pour commencer 10 000 x 10 000 valeurs courtes est 1 600 000 000 bits, 200 000 000 octets, 200 000 kilo-octets, 200 mégaoctets.

Si vous avez besoin de quelque chose avec 200 Mo de consommation de mémoire, vous voudrez peut-être redessiner cette idée. Je ne crois pas non plus que cela va même compiler et encore moins courir. Vous ne devrait jamais initialiser de grands tableaux comme ça 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 au besoin. C'est difficile d'avoir de BONNES performances de vitesse. Il y a d'autres choses que vous pouvez faire, mais ces deux sont mes préférés quand bien fait.

Bon retour à ce que je disais à propos des opérateurs bit à bit.

Donc un entier 32 bits ou en Java "int". Vous pouvez stocker ce qu'on appelle des "bits" à cela, disons que vous aviez 32 valeurs booléennes qui en Java toutes les valeurs prennent 32 bits (sauf long) ou pour les tableaux, elles prennent 8 pour byte, 16 pour short et 32 pour int. Donc, à moins que vous n'ayez des tableaux, vous ne bénéficiez d'aucun avantage mémoire en utilisant un octet ou un court. Cela ne signifie pas que vous ne devriez pas l'utiliser comme un moyen de vous assurer que vous et les autres connaissez la plage de données Cette valeur devrait avoir.

Maintenant, comme je le disais, vous pouvez effectivement stocker 32 booléens dans un seul entier en faisant ce qui 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;

Donc maintenant un short se compose de 16 bits donc 16 + 16 = 32 qui s'intègre parfaitement dans un entier 32 bits. Ainsi, chaque valeur int peut être composée de 2 valeurs courtes.

int two_shorts = value | (value2 << 16);

Donc ce que ce qui précède fait est la valeur est quelque chose entre -32768 et 32767 ou comme une valeur non signée 0-65535. Donc, disons que la valeur égale à -1, donc en tant que valeur non signée, c'était 65535. Ce signifierait que les bits 1 à 16 sont activés, mais lors de l'exécution du calcul, considérez la plage 0-15.

Nous devons donc activer les bits 17-32. Nous devons donc commencer par 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 fait "

int assumed_value = 262143;

Disons donc que nous voulons récupérer les deux Valeurs entières 16 bits.

short value1 = (short)(assumed_value & 0xFFFF); //-1
short value2 = (short)(assumed_value >> 16); //=3

Pensez aussi fondamentalement aux opérateurs binaires comme des puissances de 2. C'est tout ce qu'ils sont vraiment. Je l'ai surtout posté pour aider tous ceux qui peuvent rencontrer cette recherche de tableaux courts non signés ou même éventuellement multidimensionnels. S'il y a des fautes de frappe, je m'excuse rapidement écrit cela.

Si l'utilisation d'une bibliothèque tierce est une option, il y a jOOU (une bibliothèque dérivée de jOOQ), qui offre des types de wrapper 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 d'octet) pour les types non signés, mais peut-être que c'est toujours assez bon 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)

Java n'a pas de types non signés. De quoi avez-vous besoin?

Java a cependant le type de données 'byte'.

Vous pouvez coder vous-même une classe ShortUnsigned et définir des méthodes pour les opérateurs que vous voulez. Vous ne pourrez pas surcharger + et - et les autres sur eux, ni avoir de conversion de type implicite avec d'autres types d'objets primitifs ou numériques, hélas.

Comme certains des autres répondants, je me demande pourquoi vous avez ce besoin urgent de short non signé qu'aucun autre type de données ne remplira.

Programme Simple pour montrer pourquoi les nombres non signés sont nécessaires:

package shifttest;
public class ShiftTest{
    public static void main(String[] args){
        short test = -15000;
        System.out.format ("0x%04X 0x%04X 0x%04X 0x%04X 0x%04X\n",
            test, test>>1, test>>2, test>>3, test>>4);
    }
}

Résultats:

0xC568 0xFFFFE2B4 0xFFFFF15A 0xFFFFF8AD 0xFFFFFC56

Maintenant pour ceux qui ne sont pas des types de système:

JAVA fait un décalage arithmétique parce que l'opérande est signé, cependant, il y a des cas où un décalage logique serait approprié mais JAVA (Sun en particulier), jugé inutile, dommage pour nous sur leur myopie. Maj, et, ou, et exclusif ou sont des outils limités lorsque tout ce que vous avez sont signés plus de numéros. C'est un problème particulier lors de l'interface avec des périphériques matériels qui parlent de "vrais" bits d'ordinateur de 16 bits ou plus. "char" n'est pas garanti pour fonctionner (il est de deux octets de large maintenant) mais dans plusieurs langues GIF orientales telles que le Chinois, Le coréen et le japonais, nécessitent au moins 3 octets. Je ne connais pas le nombre nécessaire pour les langues de style sandscript. Le nombre d'octets ne dépend pas du programmeur plutôt du comité de normalisation pour JAVA. Donc baser char comme 16 bits a un aval risque. Pour implémenter en toute sécurité des shorts non signés JAVA, comme la classe spéciale est la meilleure solution basée sur les ambiguïtés susmentionnées. L'inconvénient de la classe est l'incapacité de surcharger les opérations mathématiques de cette classe spéciale. Beaucoup de contributeurs pour ce fil de précision ont souligné ces problèmes, mais ma contribution est un exemple de code de travail et mon expérience avec les langages GIFs 3 octets en C++ sous Linux.