Существует ли какое-либо реальное использование для примитивного типа байтов Java?

Ответ 1

Удивительно, но я просто использовал byte в Java в первый раз на прошлой неделе, поэтому у меня есть (хотя и необычный) прецедент. Я писал , которая позволяет реализовать функцию в библиотеке, которая может быть вызвана Java. Типы Java должны быть преобразованы в типы на родном языке, в этом случае C

Функция, необходимая для получения массива байтов, но (забыв о типе byte полностью в то время), мне потребовалось char[]. Подпись Java, генерируемая для функции C, дает тип этого параметра как jcharArray, который может быть преобразован в связку jchar s, которые отпечатаны в jni.h до unsigned short. Естественно, это не тот же размер - это 2 байта вместо 1. Это вызвало всевозможные проблемы с базовым кодом. Создание типа Java byte[] привело к jbyteArray, а jbyte в Linux - typedef-ed до signed char, что соответствует размеру

Ответ 2

Недавно Джош Блох упомянутый в презентации, что это одна из ошибок на этом языке.

Я думаю, причина в том, что java не имеет неподписанных числовых типов, а byte должен соответствовать этому правилу. (Примечание: char без знака, но не представляет числа)

Что касается конкретного вопроса: я не могу придумать ни одного примера. И даже если бы были примеры, их было бы меньше, чем для 0..255, и они могли быть реализованы с использованием маскирования (а не большинства)

Ответ 3

byte, short, char типы в основном бесполезны, за исключением случаев, когда они используются в массивах для экономии места.

Ни Java, ни JVM не имеют реальной поддержки для них. Почти все операции над ними будут продвигать их до int или long. Мы даже не можем написать что-то вроде

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

Тогда почему черт поделки вообще с определениями операций на типах byte, short, char вообще? Все, что они делают, скрывается в расширяющихся конверсиях, которые удивят программиста.

Ответ 4

Оцифрованный звук (или любой другой сигнал) с 8-битными подписанными образцами кажется мне единственным разумным примером. Конечно, с подписью байтов нет необходимости обрабатывать такие сигналы, и можно утверждать, что байт Java "идеально подходит".

Лично я думаю, что отсутствие неподписанной ошибки. Не только потому, что больше использовать для unsigned bytes/int, а потому, что я предпочитаю более сильную систему типов. Было бы неплохо указать, что отрицательные числа недопустимы и разрешить проверки компилятора и исключения времени выполнения для нарушений.

Ответ 5

byte широко используется в разработке апплетов для Java-карты. Поскольку карты имеют ограниченные ресурсы, каждый бит памяти драгоценен. Кстати, у процессоров карт есть ограничения в обработке целочисленных значений. Поддержка типа int необязательна, а java.lang.String не поддерживается, поэтому все операции с целым числом и хранение данных выполняются переменными и массивами byte и short. Поскольку целочисленные литералы имеют тип int, они должны быть явно приведены к byte или short в целом коде. Коммуникация с картой осуществляется через команды APDU, которые передаются апплету в виде массива byte, который должен быть разложен до byte, чтобы декодировать командный класс, инструкцию и параметры. Рассматривая следующий код, вы видите, насколько важны типы byte и short для разработки Java-карт:

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

}

Ответ 6

Я думаю, что он подписан, чтобы быть совместимым с short и int.

В отношении того, используется ли он много, он делает понятие "байтовых массивов" конструкцией, а не примитивным.

Это действительно все, что у меня есть.:)

Ответ 7

На машине со словами размером более 8 бит это несколько полезно, если вы хотите сохранить множество значений, которые вписываются в 8-разрядный диапазон в один массив, но обычно это не очень хорошая идея использовать их иначе, поскольку байт на самом деле больше усилий для выхода из памяти, чем int.

Помните, что эта Java была разработана для очень маленьких потребительских устройств (телевизионных приставных телевизоров). Я ожидаю, что если бы это было использовано на малых 8-разрядных микропроцессорах, это было бы более полезно, поскольку оно точно соответствовало размеру слова и могло бы использоваться для общих операций "Math" в очень малом масштабе.

Единственная причина, по которой я могу убедиться, что он подписан, заключается в том, что беззнаковый байт, взаимодействующий с int, может быть немного запутанным - но я не уверен, что он более запутан, чем подписанный!

Ответ 8

Размер байта - 8 бит. Размер байта помогает обрабатывать ввод и вывод при выполнении таких функций, как запись в файл или чтение из файла. Рассмотрим сценарий, в котором вы хотите прочитать ввод с клавиатуры или из любого файла. Если вы используете структуру данных "byte", вы знаете, что получаете один символ за раз, так как размер составляет 8 бит. Поэтому каждый раз, когда вы получаете входной поток, вы знаете, что на самом деле вы получаете по одному символу за раз.

Ответ 9

Я часто использовал его, когда я программировал программное обеспечение и игры для J2ME. На большинстве J2ME-устройств у вас ограниченные ресурсы, поэтому сохранение, например, карты уровня в байтовом массиве, менее ресурсоемким, чем сохранение его в массиве int.

Ответ 10

Я использую байты прямо сейчас в java для проекта bluetooth android.