Java Language
литералы

Вступление

Шестнадцатеричные, восьмеричные и двоичные литералы

hexadecimal число - это значение в базе 16. Есть 16 цифр, 0-9 и буквы AF (случай не имеет значения). AF представляет 10-16 .

octal число - это значение в базе-8 и использует цифры 0-7 .

binary число - это значение в базе-2 и использует цифры 0 и 1 .

Все эти числа приводят к тому же значению, 110 :

int dec = 110;            // no prefix   --> decimal literal
int bin = 0b1101110;      // '0b' prefix --> binary literal
int oct = 0156;           // '0' prefix  --> octal literal
int hex = 0x6E;           // '0x' prefix --> hexadecimal literal

Обратите внимание, что бинарный литерал синтаксис был введен в Java 7.

Октальный литерал может быть легко ловушкой для семантических ошибок. Если вы определяете ведущее '0' для ваших десятичных литералов, вы получите неправильное значение:

int a = 0100;        // Instead of 100, a == 64

Использование подчеркивания для улучшения удобочитаемости

Начиная с Java 7, было возможно использовать один или несколько символов подчеркивания (_) для разделения групп цифр в литерале примитивного числа, чтобы улучшить их читаемость.

Например, эти два объявления эквивалентны:

int i1 = 123456;
int i2 = 123_456;
System.out.println(i1 == i2); // true

Это можно применить ко всем литералам примитивных чисел, как показано ниже:

byte color = 1_2_3;
short yearsAnnoDomini= 2_016;
int socialSecurtyNumber = 999_99_9999;
long creditCardNumber = 1234_5678_9012_3456L;
float piFourDecimals =  3.14_15F;
double piTenDecimals =  3.14_15_92_65_35;

Это также работает с использованием префиксов для двоичных, восьмеричных и шестнадцатеричных баз:

short binary= 0b0_1_0_1;
int octal = 07_7_7_7_7_7_7_7_0;
long hexBytes = 0xFF_EC_DE_5E;

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

• В начале или в конце ряда (например , _123 или 123_ не действительны)
• Рядом с десятичной точкой в плавающей точке буквальной (например , 1._23 или 1_.23 не действительны)
• Перед суффиксом F или L (например , 1.23_F или 9999999_L не действительны)
• В местах , где ожидается строка цифр (например , 0_xFFFF не действует)

Эквивалентные последовательности в литералах

Строковые и символьные литералы обеспечивают механизм эвакуации, который позволяет выразить коды символов, которые в противном случае не были бы разрешены в литерале. Эквивалентная последовательность состоит из символа обратной косой черты ( \ ), за которым следует одна или несколько других символов. В обоих символах одинаковые последовательности являются строковыми литералами.

Полный набор управляющих последовательностей выглядит следующим образом:

<octal> в приведенном выше состоит из одной, двух или трех восьмеричных цифр (от 0 до 7), которые представляют число от 0 до 255 (десятичное).

Обратите внимание, что обратная косая черта, сопровождаемая любым другим символом, является недопустимой управляющей последовательностью. Неверные escape-последовательности рассматриваются как ошибки компиляции JLS.

Ссылка:

• JLS 3.10.6. Последовательности выхода для символов и строк

Юникодные экраны

В дополнение к последовательностям escape-последовательности строк и символов, описанным выше, Java имеет более общий механизм экранирования Unicode, как определено в JLS 3.3. Unicode Escapes . Выделение Unicode имеет следующий синтаксис:

'\' 'u' <hex-digit> <hex-digit> <hex-digit> <hex-digit> 

где <hex-digit> является одним из '0' , '1' , '2' , '3' , '4' , '5' , '6' , '7' , '8' , '9' , 'a' , 'b' , 'c' , 'd' , 'e' , 'f' , 'A' , 'B' , 'C' , 'D' , 'E' , 'F' .

Выделение Unicode сопоставляется компилятором Java с символом (строго говоря, 16-разрядным блоком кода Unicode) и может использоваться в любом месте исходного кода, в котором действительный отображаемый символ действителен. Он обычно используется в символьных и строковых литералах, когда вам нужно представить символ не-ASCII в литерале.

Исключение в регулярных выражениях

TBD

Десятичные целые литеры

Целочисленные литералы предоставляют значения, которые могут использоваться там, где вам нужен byte , short , int , long или char . (В этом примере основное внимание уделяется простым десятичным формам. В других примерах объясняется, как литералы в восьмеричных, шестнадцатеричных и двоичных выражениях, а также использование подчеркиваний для повышения удобочитаемости.)

Обычные целые литералы

Простейшей и наиболее распространенной формой целочисленного литерала является десятичный целочисленный литерал. Например:

 0       // The decimal number zero       (type 'int')
 1       // The decimal number one        (type 'int')
 42      // The decimal number forty two  (type 'int')

Вы должны быть осторожны с ведущими нулями. Ведущий нуль приводит к тому, что целочисленный литерал интерпретируется как восьмеричный, а не десятичный.

 077    // This literal actually means 7 x 8 + 7 ... or 63 decimal!

Целочисленные литералы неподписанны. Если вы видите что - то вроде -10 или +10 , это на самом деле выражение , использующее одинарных - и унарных + операторов.

Диапазон целочисленных литералов этой формы имеет внутренний тип int и должен находиться в диапазоне от 0 до 2 ³¹ или 2 147 483 648.

Обратите внимание, что 2 ³¹ равно 1 больше Integer.MAX_VALUE . Литералы от 0 до до 2147483647 можно использовать в любом месте, но это ошибка компиляции использовать 2147483648 без предшествующего одноместной - оператора. (Другими словами, он зарезервирован для выражения значения Integer.MIN_VALUE .)

 int max = 2147483647;     // OK
 int min = -2147483648;    // OK
 int tooBig = 2147483648;  // ERROR

Длинные целые литералы

Литералы типа long выражаются добавлением суффикса L Например:

 0L          // The decimal number zero       (type 'long')
 1L          // The decimal number one        (type 'long')
 2147483648L // The value of Integer.MAX_VALUE + 1

 long big = 2147483648;    // ERROR
 long big2 = 2147483648L;  // OK

Обратите внимание, что различие между int и long литералами значимо в других местах. Например

 int i = 2147483647;
 long l = i + 1;           // Produces a negative value because the operation is
                           // performed using 32 bit arithmetic, and the 
                           // addition overflows
 long l2 = i + 1L;         // Produces the (intuitively) correct value.

Ссылка: JLS 3.10.1 - Целочисленные литералы

Булевы литералы

Булевы литералы являются простейшим из литералов на языке программирования Java. Два возможных boolean значения представлены литералами true и false . Они чувствительны к регистру. Например:

boolean flag = true;    // using the 'true' literal
flag = false;           // using the 'false' literal

Строковые литералы

Строковые литералы предоставляют наиболее удобный способ представления строковых значений в исходном коде Java. Строковый литерал состоит из:

• Открывающий символ двойной кавычки ( " ).
• Нулевой или более других символов, которые не являются ни двойным кавычкой, ни символом прерывания строки. (Символ обратной косой черты ( \ ) изменяет значение последующих символов, см. Последовательности Escape в литералах .)
• Закрывающий символ двойной кавычки.

Например:

"Hello world"   // A literal denoting an 11 character String
""              // A literal denoting an empty (zero length) String
"\""            // A literal denoting a String consisting of one 
                //     double quote character
"1\t2\t3\n"     // Another literal with escape sequences

Обратите внимание, что один строковый литерал может не охватывать несколько строк исходного кода. Это ошибка компиляции для разрыва строки (или конца исходного файла) перед закрывающей двойной кавычкой литерала. Например:

"Jello world    // Compilation error (at the end of the line!)

Длинные строки

Если вам нужна строка, которая слишком длинная, чтобы поместиться на линии, обычный способ выразить ее состоит в том, чтобы разбить ее на несколько литералов и использовать оператор конкатенации ( + ) для объединения фигур. Например

String typingPractice = "The quick brown fox " +
                        "jumped over " +
                        "the lazy dog"

Выражение, подобное выше, состоящее из строковых литералов и + удовлетворяет требованиям как константное выражение . Это означает, что выражение будет оцениваться компилятором и представлено во время выполнения одним объектом String .

Интернирование строковых литералов

Когда файл класса, содержащий строковые литералы, загружается JVM, соответствующие объекты String интернируются системой выполнения. Это означает, что строковый литерал, используемый в нескольких классах, занимает больше места, чем если бы он использовался в одном классе.

Дополнительные сведения о интернировании и пуле строк см. В примере String pool и кучи памяти в разделе «Строки».

Нулевой литерал

Нулевой литерал (записанный как null ) представляет одно и единственное значение нулевого типа. вот несколько примеров

    MyClass object = null;
    MyClass[] objects = new MyClass[]{new MyClass(), null, new MyClass()};

    myMethod(null);

    if (objects != null) {
         // Do something
    }

Нулевой тип довольно необычен. У него нет имени, поэтому вы не можете выразить его в исходном коде Java. (И у него нет представления во время выполнения).

Единственной целью нулевого типа является тип null . Это присвоение, совместимое со всеми ссылочными типами, и может быть введено для любого ссылочного типа. (В последнем случае приведение не требует проверки типа времени выполнения).

Наконец, null имеет свойство, что null instanceof <SomeReferenceType> будет оцениваться как false , независимо от типа.

Литералы с плавающей запятой

Литералы с плавающей запятой предоставляют значения, которые можно использовать там, где вам нужен float или double экземпляр. Существует три типа литералов с плавающей запятой.

• Простые десятичные формы
• Масштабированные десятичные формы
• Шестнадцатеричные формы

(Синтаксические правила JLS объединяют две десятичные формы в одну форму. Мы относимся к ним отдельно для удобства объяснения.)

Существуют разные литературные типы для float и double литералов, выраженные с использованием суффиксов. Различные формы используют буквы для выражения разных вещей. Эти буквы нечувствительны к регистру.

Простые десятичные формы

Простейшая форма литерала с плавающей запятой состоит из одной или нескольких десятичных цифр и десятичной точки ( . ) И необязательного суффикса ( f , F , d или D ). Необязательный суффикс позволяет указать, что литерал представляет собой значение float ( f или F ) или double ( d или D ). Значение по умолчанию (если суффикс не указан) является double .

Например

 0.0     // this denotes zero
 .0      // this also denotes zero
 0.      // this also denotes zero
 3.14159 // this denotes Pi, accurate to (approximately!) 5 decimal places.
 1.0F    // a `float` literal
 1.0D    // a `double` literal.  (`double` is the default if no suffix is given)

Фактически, десятичные цифры, за которыми следует суффикс, также являются литералами с плавающей запятой.

 1F      // means the same thing as 1.0F

Значение десятичного литерала - это число с плавающей запятой IEEE, которое ближе всего к математическому вещественному числу бесконечной точности, обозначенному десятичной формой с плавающей запятой. Это концептуальное значение преобразуется в двоичное представление с плавающей точкой IEEE с округлением до ближайшего . (Точная семантика десятичного преобразования указана в javadocs для Double.valueOf(String) и Float.valueOf(String) , имея в виду, что существуют различия в синтаксисе числа.)

Масштабированные десятичные формы

Масштабированные десятичные формы состоят из простой десятичной дроби с частью экспоненты, введенной E или e , и за ней следует целое число со знаком. Часть экспоненты представляет собой короткую руку для умножения десятичной формы на десять, как показано в приведенных ниже примерах. Существует также дополнительный суффикс, чтобы отличать float и double литералы. Вот некоторые примеры:

 1.0E1    // this means 1.0 x 10^1 ... or 10.0 (double)
 1E-1D    // this means 1.0 x 10^(-1) ... or 0.1 (double)
 1.0e10f  // this means 1.0 x 10^(10) ... or 10000000000.0 (float)

Размер литерала ограничен представлением ( float или double ). Это ошибка компиляции, если масштабный коэффициент приводит к слишком большому или слишком маленькому значению.

Шестнадцатеричные формы

Начиная с Java 6, можно выразить литералы с плавающей запятой в шестнадцатеричном формате. Шестнадцатеричная форма имеет аналогичный синтаксис для простых и масштабированных десятичных форм со следующими отличиями:

1. Каждый шестнадцатеричный литерал с плавающей запятой начинается с нуля ( 0 ), а затем x или X
2. Цифры номера (но не части экспоненты!) Также включают шестнадцатеричные цифры от a до f и их прописные эквиваленты.
3. Показатель является обязательным и вводится буквой p (или P ) вместо e или E Показатель представляет собой коэффициент масштабирования, который представляет собой мощность 2 вместо мощности 10.

Вот некоторые примеры:

0x0.0p0f    // this is zero expressed in hexadecimal form (`float`)
0xff.0p19   // this is 255.0 x 2^19 (`double`)

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

подчеркивания

Начиная с Java 7, символы подчеркивания допускаются в цифровых строках во всех трех формах литералов с плавающей запятой. Это относится и к «экспоненциальным» частям. См. Раздел Использование подчеркивания для повышения удобочитаемости .

Особые случаи

Это ошибка компиляции, если литерал с плавающей запятой обозначает число, которое слишком велико или слишком мало для представления в выбранном представлении; т.е. если число будет переполняться до + INF или -INF или underflow до 0.0. Тем не менее, для литерала законно представлять ненулевое денормализованное число.

Синтаксис букв с плавающей запятой не предоставляет буквенных представлений для специальных значений IEEE 754, таких как значения INF и NaN. Если вам нужно выразить их в исходном коде, рекомендуется использовать константы, определенные java.lang.Float и java.lang.Double ; например Float.NaN , Float.NEGATIVE_INFINITY и Float.POSITIVE_INFINITY .

Литералы символов

Литералы символов предоставляют наиболее удобный способ выражения значений char в исходном коде Java. Литеральный символ состоит из:

• Открывающий символ одной кавычки ( ' ).
• Представление символа. Это представление не может быть символом одиночной кавычки или строки, но это может быть escape-последовательность, введенная символом обратной косой черты ( \ ); см. последовательности Escape в литералах .
• Закрывающий символ одной кавычки ( ' ).

Например:

char a = 'a';
char doubleQuote = '"';
char singleQuote = '\'';

Разрыв строки в символьном литерале является ошибкой компиляции:

char newline = '
// Compilation error in previous line
char newLine = '\n';  // Correct