Спецификация числа L Java (длинная)

Похоже, что когда вы вводите число в Java, компилятор автоматически считывает его как целое число, поэтому, когда вы вводите (long) 6000000000(не в целочисленном диапазоне), он будет жаловаться, что 6000000000это не целое число. Чтобы исправить это, мне пришлось уточнить 6000000000L. Я только что узнал об этой спецификации.

Существуют ли другие спецификации чисел, такие как short, byte, float, double? Похоже, их было бы хорошо иметь, потому что (я полагаю), если бы вы могли указать номер, который вы вводите, короткий, тогда java не пришлось бы его приводить - это предположение, поправьте меня, если я ошибаюсь . Обычно я сам ищу этот вопрос, но я не знаю, как вообще называется такая спецификация числа.

Существуют специальные суффиксы для long(например 39832L), float(например 2.4f) и double(например -7.832d).

Если суффикса нет и это целочисленный тип (например, 5623), предполагается, что это int. Если это не интегральный тип (например 3.14159), предполагается, что это double.

Во всех остальных случаях ( byte, short, char), вам нужно бросание , поскольку нет никакого определенного суффикса.

Спецификация Java допускает суффиксы как в верхнем, так и в нижнем регистре, но для longs предпочтительнее использовать верхний регистр, так как верхний регистр Lлегче спутать с цифрой, 1чем нижний регистр l.

См. Подробности в разделе 3.10 JLS (см. Определение IntegerTypeSuffix).

Я надеюсь, вы не будете возражать против небольшого касания, но подумайте, что вам может быть интересно узнать, что помимо F(для float), D(для double) и L(для длительного) было сделано предложение добавить суффиксы для byteи short- Yи Sсоответственно . Это устранит необходимость преобразования в байты при использовании буквального синтаксиса для байтовых (или коротких) массивов. Цитируя пример из предложения:

ОСНОВНАЯ ПРЕИМУЩЕСТВА: Почему платформа лучше, если предложение принято?

грубый код вроде

 byte[] stuff = { 0x00, 0x7F, (byte)0x80,  (byte)0xFF};

можно перекодировать как

 byte[] ufum7 = { 0x00y, 0x7Fy, 0x80y, 0xFFy };

Джо Дарси наблюдает за Project Coin для Java 7, и его блог был простым способом отслеживать эти предложения.

По умолчанию любой интегральный примитивный тип данных (byte, short, int, long) будет рассматриваться компилятором java как тип int . Для byte и short , пока присвоенное им значение находится в их диапазоне, проблем нет и суффикс не требуется. Если значение, присвоенное byte и short, превышает их диапазон, требуется явное приведение типа.

Пример:

byte b = 130; // CE: range is exceeding.

чтобы преодолеть это, выполните приведение типов.

byte b = (byte)130; //valid, but chances of losing data is there.

В случае длинного типа данных он может принимать целочисленное значение без каких-либо проблем. Предположим, мы назначаем как

Long l = 2147483647; //which is max value of int

в этом случае суффикс типа L / l не требуется. По умолчанию значение 2147483647 считается компилятором java как тип int. Приведение внутреннего типа выполняется компилятором, а int автоматически повышается до типа Long.

Long l = 2147483648; //CE: value is treated as int but out of range 

Здесь нам нужно указать суффикс L, чтобы компилятор java рассматривал литерал 2147483648 как длинный тип.

так что наконец

Long l = 2147483648L;// works fine.

Это литералы, которые описаны в разделе 3.10 спецификации языка Java.

Похоже, это было бы хорошо, потому что (я предполагаю), если бы вы могли указать номер, который вы вводите, короткий, тогда java не пришлось бы его приводить

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

Чтобы понять , почему это необходимо различать intи longлитералы, рассмотреть следующие вопросы:

long l = -1 >>> 1;

против

int a = -1;
long l = a >>> 1;

Теперь, как и следовало ожидать, оба фрагмента кода присваивают переменной одинаковое значение l. Не умея различать intи longбуквальные, каково толкование -1 >>> 1?

-1L >>> 1 // ?

или

(int)-1 >>> 1 // ?

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

Этого не происходит byte, shortи charпотому что они всегда продвигаются перед выполнением арифметических и побитовых операций. Возможно, они должны быть суффиксами целочисленного типа для использования, скажем, в выражениях инициализации массива, но это не так. floatиспользует суффикс fи double d. Остальные литералы имеют однозначные типы, в том числе специальный тип для null.