web-dev-qa-db-fra.com

Y a-t-il des utilisations de la vie réelle pour le Java type primitif d'octet?

Pour une raison inexplicable, le type primitif byte est signé en Java. Cela signifie que les valeurs valides sont -128..127 au lieu de la plage habituelle 0..255 représentant 8 bits significatifs dans un octet (sans pit-signal).

Cela signifie que tous les codes de manipulation d'octets utilisent généralement des calculs entier et finissent par masquer les 8 derniers bits.

Je me demandais s'il y a n'importe quel Scénario de vie réel où le type Java byte Type primitif convient parfaitement ou s'il s'agit simplement d'une décision de conception complètement inutile?

EDIT: Le seul cas d'utilisation réelle était un espace réservé à un octet pour le code natif. En d'autres termes, ne pas être manipulé comme un octet à l'intérieur Java code.

EDIT: J'ai maintenant vu un endroit où une boucle restreinte interne devait diviser par 7 (chiffres 0..32) de sorte qu'une table de recherche peut être effectuée avec des octets comme le type de données afin que l'utilisation de la mémoire puisse être maintenue à faible tenue de l'utilisation du cache L1. . Cela ne fait pas référence à la signature/non-signer mais était un cas d'utilisation réelle.

javatypesbyte
56
Thorbjørn Ravn Andersen

Josh Bloch récemment mentionné dans une présentation que c'est l'une des erreurs dans la langue.

Je pense que la raison derrière ceci est que Java n'a pas de types numériques non signés, et byte doit être conforme à cette règle. (Remarque: char est non signé, mais ne représente pas de chiffres)

Quant à la question particulière: je ne peux penser à aucun exemple. Et même s'il y avait des exemples, ils seraient moins que ceux pour 0..255, et ils pourraient être mis en œuvre à l'aide de masquage (plutôt que la majorité)

33
Bozho

byte, short, char Les types sont principalement inutiles, sauf lorsqu'ils sont utilisés dans des tableaux pour économiser de l'espace.

Ni Java ou JVM a un support réel pour eux. Presque toutes les opérations sur eux vont les promouvoir à int ou long d'abord. Nous ne pouvons même pas écrire quelque chose comme

short a=1, b=2;
a = a + b;  // illegal
a = a << 1; // illegal

Alors pourquoi le diable se préoccupe même de définir des opérations sur des types de byte, short, char Du tout?

Tout ce qu'ils font sont en train de se faufiler dans des conversions d'élargissement qui surprendront le programmeur.

16
irreputable

Le son numérisé (ou tout autre signal) avec des échantillons signés de 8 bits semble être le seul exemple raisonnable pour moi. Bien sûr, avoir signé des octets n'est pas nécessaire de gérer ces signaux et on peut soutenir que Java octet "s'adapte parfaitement".

Personnellement, je pense que cela ne pas avoir non signé est une erreur. Non seulement parce qu'il y a plus d'utilisation pour des octets/intens non signés, mais parce que je préfère un système de type plus fort. Il serait agréable de pouvoir spécifier que des nombres négatifs ne sont pas valides et permettent des contrôles du compilateur et des exceptions d'exécution des violations.

4
lokori

byte a une utilisation approfondie dans le développement de l'applet pour Java carte. Parce que les cartes ont des ressources limitées, chaque mémoire est précieuse. Par la manière dont les processeurs de cartes ont des limitations au traitement des valeurs entière. . int Type Support est facultatif et Java.lang.String n'est pas pris en charge, donc toutes les opérations entière et le stockage de données sont effectuées par byte et short variables et tableaux. Comme les littéraux entier sont de type int Type, ils doivent être explicitement mises à byte ou short dans le code complet. La communication avec la carte passe par les commandes APDU qui sont transmises à Applet comme une matrice de bytes qui doit être décomposée à bytes à décoder la classe de commande, les instructions et les paramètres. En regardant le code suivant, vous voyez combien byte et short types sont importants pour Java Développement de cartes:

package somepackage.SomeApplet;

import javacard.framework.*;
import org.globalplatform.GPSystem;
import org.globalplatform.SecureChannel;

public class SomeApplet extends Applet {

    // Card status
    private final static byte ST_UNINITIALIZED     = (byte) 0x01;
    private final static byte ST_INITIALIZED       = (byte) 0x02;

    // Instructions & Classes
    private final static byte PROP_CLASS           = (byte) 0x80;     

    private final static byte INS_INIT_UPDATE      = (byte) 0x50;
    private final static byte INS_EXT_AUTH         = (byte) 0x82;

    private final static byte INS_PUT_DATA         = (byte) 0xDA;
    private final static byte INS_GET_RESPONSE     = (byte) 0xC0;
    private final static byte INS_GET_DATA         = (byte) 0xCA;


    private final static short SW_CARD_NOT_INITIALIZED       = (short) 0x9101;  
    private final static short SW_CARD_ALREADY_INITIALIZED   = (short) 0x9102;  

    private final static byte OFFSET_SENT = 0x00;
    private final static byte OFFSET_RECV = 0x01;
    private static short[] offset;

    private static byte[] fileBuffer;
    private static short fileSize = 0;

    public static void install(byte[] bArray, short bOffset, byte bLength) {
        new SomeApplet( bArray, bOffset, bLength);
    }

    public RECSApplet(byte[] bArray, short bOffset, byte bLength) {
        offset = JCSystem.makeTransientShortArray((short) 2, JCSystem.CLEAR_ON_RESET);
        fileBuffer = new byte[FILE_SIZE];

        byte aidLen = bArray[bOffset];
        if (aidLen== (byte)0){
            register();
        } else {
            register(bArray, (short)(bOffset+1), aidLen);
        }
    }

    public void process(APDU apdu) {
        if (selectingApplet()) {
            return;
        }
        byte[] buffer = apdu.getBuffer();
        short len = apdu.setIncomingAndReceive(); 

        byte cla = buffer[ISO7816.OFFSET_CLA];
        byte ins = buffer[ISO7816.OFFSET_INS];
        short lc = (short) (buffer[ISO7816.OFFSET_LC] & 0x00ff); 

        while (len < lc) {
            len += apdu.receiveBytes(len);
        }

        SecureChannel sc = GPSystem.getSecureChannel();
        if ((short)(cla & (short)0x80) == ISO7816.CLA_ISO7816) {
            switch (ins) {
                case INS_PUT_DATA:
                    putData(buffer, ISO7816.OFFSET_CDATA, offset[OFFSET_RECV], len);

                    if ((cla & 0x10) != 0x00) {
                        offset[OFFSET_RECV] += len;
                    } else {
                        fileSize = (short) (offset[OFFSET_RECV] + len);
                        offset[OFFSET_RECV] = 0;
                    }
                    return;

                case INS_GET_DATA:
                case INS_GET_RESPONSE:
                    sendData(apdu);
                    return;
                default:
                    ISOException.throwIt(ISO7816.SW_INS_NOT_SUPPORTED);
            }

        }
        else if ((byte) (cla & PROP_CLASS) == PROP_CLASS) {
            switch (ins) {
                case INS_INIT_UPDATE:
                case INS_EXT_AUTH:
                    apdu.setOutgoingAndSend(ISO7816.OFFSET_CDATA, sc.processSecurity(apdu));
                    return;
                default:
                    ISOException.throwIt(ISO7816.SW_INS_NOT_SUPPORTED);
            }
        } else
            ISOException.throwIt(ISO7816.SW_CLA_NOT_SUPPORTED);
    }

    // Some code omitted

}
3
Bahribayli

Sur une machine avec des mots de plus de 8 morceaux, il est un peu utile si vous souhaitez stocker de nombreuses valeurs qui correspondent à une gamme 8 bits en une seule matrice, mais généralement, ce n'est pas une bonne idée de les utiliser autrement, car un octet est en fait plus d'effort pour sortir de la mémoire qu'un Int.

N'oubliez pas que cela =Java a été conçu pour de très petits appareils de consommation (boîtes de télévision à jeun). J'attends s'il avait été utilisé de cette manière sur de petits microprocesseurs 8 bits, il aurait été plus utile que Cela correspondrait à la taille de mot exactement et pourrait être utilisé pour des opérations générales "mathématiques" à très petite échelle.

La seule raison pour laquelle je peux voir pour le faire signé est qu'un octe non signé interagissant avec un int peut être un peu déroutant - mais je ne suis pas convaincu que ce n'est plus déroutant que celui d'une personne signée.

1
Bill K

La taille de l'octet est de 8 bits. La taille de l'octet aide à traiter l'entrée et la sortie lors de la réalisation de fonctions telles que l'écriture dans un fichier ou la lecture d'un fichier. Considérez un scénario dans lequel vous souhaitez lire une entrée du clavier ou de n'importe quel fichier. Si vous utilisez la structure de données "octet", vous savez que vous recevez un caractère à la fois car la taille est de 8 bits. Donc, chaque fois que vous recevez un flux d'entrée, vous savez que vous recevez un personnage à la fois.

0
TiwariVivek