Беззнаковый короткий в Java

Вы действительно не можете. В Java нет беззнаковых типов данных, кроме char.

По общему признанию, вы могли бы использовать char - это 16-битный беззнаковый тип - но это было бы ужасно, на мой взгляд, поскольку char явно предназначен для текста: когда код использует char, я ожидаю, что это будет используя его для кодовых единиц UTF-16, представляющих интересный для программы текст, а не произвольные беззнаковые 16-битные целые числа, не имеющие отношения к тексту.

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

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

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

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

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

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

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

А вот ссылка, в которой обсуждается 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 такого типа нет

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

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

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

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

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

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

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

Итак, 32-битное целое число или в Java "int". Вы можете хранить в нем то, что называется «битами», поэтому предположим, что у вас есть 32 логических значения, которые в Java все значения занимают 32 бита (кроме long), или для массивов они занимают 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 может состоять из двух коротких значений.

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

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

Итак, нам нужно затем активировать биты 17–32. Итак, мы должны начать с чего-то большего, чем 15 бит. Итак, мы начинаем с 16 бит. Итак, взяв значение2 и умножив его на 65536, это то, что делает «‹---------------- 16». Теперь предположим, что value2 равняется 3, это будет OR 3x65536 = 196608. Таким образом, наше целочисленное значение будет равно 262143.

int assumed_value = 262143;

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

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

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

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

import static org.joou.Unsigned.*;

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

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

Невозможно объявить тип unsigned short, но в моем случае мне нужно было получить беззнаковое число, чтобы использовать его в цикле for. В классе Short есть метод toUnsignedInt, который возвращает аргумент, преобразованный в int беззнаковым преобразованием:

short signedValue = -4767;
System.out.println(signedValue ); // prints -4767

int unsignedValue = Short.toUnsignedInt(signedValue);
System.out.println(unsingedValue); // prints 60769

Подобные методы существуют для Integer и Long:

Integer.toUnsignedLong

Long.toUnsignedString: В этом случае он попадает в String, потому что нет большего числового типа.

В Java нет беззнаковых типов. Для чего тебе это?

Однако в Java есть «байтовый» тип данных.

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

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

Простая программа, показывающая, зачем нужны беззнаковые числа:

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) сочла это ненужным, слишком плохо для нас из-за своей близорукости. Shift, And, Or и Exclusive Or - это ограниченные инструменты, когда все, что у вас есть, - это более длинные числа со знаком. Это особая проблема при взаимодействии с аппаратными устройствами, которые говорят «НАСТОЯЩИЕ» компьютерные биты, составляющие 16 или более бит. Работа "char" не гарантируется (теперь она имеет ширину два байта), но для некоторых восточных языков, основанных на gif, таких как китайский, корейский и японский, требуется как минимум 3 байта. Я не знаю, сколько языков требуется в стиле Sandscript. Количество байтов зависит не от программиста, а от комитета по стандартам JAVA. Таким образом, использование char в качестве 16 бит сопряжено с риском для нисходящего потока. Для безопасного внедрения неподписанных шорт JAVA, as special class - лучшее решение, основанное на вышеупомянутой неоднозначности. Обратной стороной класса является невозможность перегрузить математические операции для этого специального класса. Многие участники этой ветки точно указали на эти проблемы, но мой вклад - это рабочий пример кода и мой опыт работы с 3-байтовыми языками gif на C ++ под Linux.