unsigned short в java

Если вам действительно нужно значение с ровно 16 битами:

Решение 1: используйте доступный подписанный короткий и перестаньте беспокоиться о знаке, если вам не нужно делать сравнение (, >=) или операции деления ( / ,%,>>). См.ответ для того, как обрабатывать подписанные номера, как если бы они были без знака.

решение 2 (где Решение 1 не применяется): используйте нижние 16 бит int и удалите более высокие биты с & 0xffff, где необходимый.

Это действительно устаревшая нить, но для тех, кто придет после. Char является числовым типом. Он поддерживает все математические операторы, битовые операции и т. д. Это беззнаковый 16.

мы обрабатываем сигналы, записанные пользовательским встроенным оборудованием, поэтому мы обрабатываем много неподписанных 16 из A - D. Мы используем chars повсюду в течение многих лет и никогда не имели никаких проблем.

вы можете использовать char, так как это беззнаковое 16-битное значение (хотя технически это символ unicode, поэтому в будущем может измениться на 24-битное значение)... другой альтернативой является использование int и убедитесь, что он находится в пределах диапазона.

Не используйте символ-используйте int: -)

и вот это ссылка обсуждает Java и отсутствие unsigned.

нет такого типа в java

Из 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);
}

Да нет такой вещи, если вы хотите использовать значение в коде против битовых операций.

" в Java SE 8 и более поздних версиях вы можете использовать тип данных int для представления 32-разрядного целого числа без знака, которое имеет минимальное значение 0 и максимальное значение 232-1." однако это относится только к int и long, но не short : (

нет, на самом деле такого метода нет, java-язык высокого уровня. Вот почему в Java нет беззнаковых типов данных.

Он сказал, что хочет создать многомерный короткое время. Но никто не предложил побитовые операторы? Из того, что я читал, вы хотите использовать 16-битные целые числа над 32-битными целыми числами для сохранения памяти?

так, во-первых, для начала 10 000 х 10 000 коротких значений 1,600,000,000 бит, 200 000 000 байт, 200 000 килобайт, мегабайт 200.

Если вам нужно что-то с 200 МБ потребления памяти, вы можете изменить эту идею. Я также не верю, что даже скомпилирую let один беги. Вы никогда не должны инициализировать большие массивы, если что-то использует 2 функции, называемые загрузкой по требованию и кэшированием данных. По сути, загрузка по требованию относится к идее загружать только данные по мере необходимости. Затем кэширование данных делает то же самое, но использует пользовательский фрейм для удаления старой памяти и добавления новой информации по мере необходимости. Это сложно, чтобы иметь хорошую производительность скорости. Есть и другие вещи, которые вы можете сделать, но эти два мои любимые, когда закончите право.

Хорошо, вернемся к тому, что я говорил о побитовых операторах.

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

теперь, как я говорил, Вы можете эффективно хранить 32 логических значения в одно целое число, выполнив следующее:

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;

Итак, теперь короткий состоит из 16 бит, поэтому 16 + 16 = 32, который идеально вписывается в 32-битное целое число. Таким образом, каждое значение int может состоять из 2 коротких значений.

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

таким образом, вышеизложенное значение является чем - то между -32768 и 32767 или как беззнаковое значение 0-65535. Так допустим, значение равно -1, так как беззнаковое значение равно 65535. Это означало бы, что биты с 1 по 16 включены, но при фактическом выполнении математики учитывайте диапазон 0 - 15.

поэтому нам нужно активировать бит 17 - 32. Поэтому мы должны начать с чего-то большего, чем 15 бит. Итак, мы начинаем с 16 бит. Поэтому, взяв значение 2 и умножив его на 65536, что и делает "

int assumed_value = 262143;

допустим, мы хотим получить два 16-битных целочисленных значений.

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

также в основном думают о побитовых операторах как о степенях 2. Это все, чем они являются на самом деле. Никогда не смотрите на это с точки зрения 0 и 1. Я в основном разместил это, чтобы помочь всем, кто может столкнуться с этим поиском неподписанных коротких или даже, возможно, многомерных массивов. Если есть какие-либо опечатки, я прошу прощения, быстро написал это.

Если использование сторонней библиотеки является опцией, есть jOOU (библиотека спина от jOOQ), который предлагает типы оболочки для целых чисел без знака в Java. Это не совсем то же самое, что поддержка примитивного типа (и, следовательно, байтового кода) для неподписанных типов, но, возможно, это все еще достаточно хорошо для вашего варианта использования.

import static org.joou.Unsigned.*;

// and then...
UShort s = ushort(1);

(отказ от ответственности: я работаю в компании за этими библиотеками)

в Java нет беззнаковых типов. Зачем он тебе?

Java имеет тип данных "byte", однако.

вы можете закодировать себя ShortUnsigned class и определите методы для тех операторов, которые вы хотите. Вы не сможете перегрузить + и - и другие на них, а также неявное преобразование типов с другими примитивными или числовыми типами объектов, увы.

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

простая программа, чтобы показать, почему необходимо беззнаковые числа:

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

результаты:

0xC568 0xFFFFE2B4 0xFFFFF15A 0xFFFFF8AD 0xFFFFFC56

теперь для тех, которые не являются типами системы:

JAVA делает арифметический сдвиг, потому что операнд подписан, однако, есть случаи, когда логический сдвиг был бы уместен, но JAVA (в частности, Sun), считал его ненужным, слишком плохо для нас по их близорукости. Сдвиг, и, или и исключающее или ограничены средства, когда все вы уже подписаны больше числа. Это особая проблема при взаимодействии с аппаратными устройствами, которые говорят "реальные" компьютерные биты, которые 16 бит или более. "char" не гарантированно работает (теперь он имеет два байта), но в нескольких восточных языках gif, таких как китайский, корейский и японский, требуется не менее 3 байтов. Я не знаком с числом, необходимым для языков стиля sandscript. Количество байтов зависит не от программиста, а от комитета стандартов для JAVA. Так основывая char как 16 битов имеет нисходящий риск. Для безопасной реализации unsigned shorts JAVA, as special class является лучшим решением, основанным на вышеупомянутых неоднозначностях. Недостатком класса является невозможность перегрузки математических операций для этого специального класса. Многие из участников этой темы точно указали на эти проблемы, но мой вклад-это пример рабочего кода и мой опыт работы с 3-байтовыми языками gifs в C++ под Linux.