Java Language
Literales

algorithm Android HTML javafx JavaScript MySQL Regular Expressions spring spring-boot SQL
Buscar..


Introducción

Un literal de Java es un elemento sintáctico (es decir, algo que se encuentra en el código fuente de un programa Java) que representa un valor. Los ejemplos son 1 , 0.333F , false , 'X' y "Hello world\n" .

Literales hexadecimales, octales y binarios.

Un número hexadecimal es un valor en base-16. Hay 16 dígitos, 0-9 y las letras AF (el caso no importa). AF representan 10-16 .

Un número octal es un valor en base-8, y usa los dígitos 0-7 .

Un número binary es un valor en base-2, y usa los dígitos 0 y 1 .

Todos estos números resultan en el mismo valor, 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

Tenga en cuenta que la sintaxis literal binaria se introdujo en Java 7.

El literal octal puede ser fácilmente una trampa para los errores semánticos. Si define un '0' inicial en sus literales decimales, obtendrá el valor incorrecto: 

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

Usando el guión bajo para mejorar la legibilidad

Desde Java 7 ha sido posible usar uno o más guiones bajos (_) para separar grupos de dígitos en un número literal primitivo para mejorar su legibilidad.

Por ejemplo, estas dos declaraciones son equivalentes:

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

Esto se puede aplicar a todos los literales de números primitivos como se muestra a continuación:

Java SE 7 
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;

Esto también funciona usando prefijos para bases binarias, octales y hexadecimales:

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

Hay algunas reglas sobre los guiones bajos que prohíben su colocación en los siguientes lugares:

  • Al principio o al final de un número (por ejemplo, _123 o 123_ no son válidos)
  • Adyacente a un punto decimal en un literal de punto flotante (por ejemplo, 1._23 o 1_.23 no son válidos)
  • Antes de un sufijo F o L (por ejemplo, 1.23_F o 9999999_L no son válidos)
  • En posiciones donde se espera una cadena de dígitos (por ejemplo, 0_xFFFF no es válido)

Secuencias de escape en literales.

Los literales de cadenas y caracteres proporcionan un mecanismo de escape que permite expresar códigos de caracteres que de otro modo no se permitirían en el literal. Una secuencia de escape consiste en un carácter de barra invertida ( \ ) seguido de uno o más caracteres adicionales. Las mismas secuencias son válidas tanto en caracteres como en literales de cadena.

El conjunto completo de secuencias de escape es el siguiente:

Secuencia de escape Sentido
\\ Denota un carácter de barra invertida ( \ )
\' Indica un carácter de comilla simple ( ' )
\" Indica un carácter de comillas dobles ( " )
\n Indica un carácter de salto de línea ( LF )
\r Denota un carácter de retorno de carro ( CR )
\t Indica un carácter de tabulación horizontal ( HT )
\f Indica un carácter de alimentación de formulario ( FF )
\b Denota un carácter de retroceso ( BS )
\<octal> Indica un código de carácter en el rango de 0 a 255.

El <octal> de lo anterior consta de uno, dos o tres dígitos octales ('0' a '7') que representan un número entre 0 y 255 (decimal).

Tenga en cuenta que una barra invertida seguida de cualquier otro carácter es una secuencia de escape no válida. Las secuencias de escape no válidas se tratan como errores de compilación por el JLS.

Referencia:

Unicode se escapa

Además de las secuencias de escape de caracteres y cadenas descritas anteriormente, Java tiene un mecanismo de escape Unicode más general, como se define en JLS 3.3. Unicode Escapes . Un escape Unicode tiene la siguiente sintaxis: 

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

donde <hex-digit> es uno de '0' , '1' , '2' , '3' , '4' , '5' , '6' , '7' , '8' , '9' , 'a' , 'b' , 'c' , 'd' , 'e' , 'f' , 'A' , 'B' , 'C' , 'D' , 'E' , 'F' .

El compilador de Java asigna un escape de Unicode a un carácter (estrictamente hablando, una unidad de código Unicode de 16 bits), y se puede utilizar en cualquier parte del código fuente donde el carácter asignado sea válido. Se usa comúnmente en literales de caracteres y cadenas cuando necesita representar un carácter no ASCII en un literal.

Escapar en expresiones regulares

TBD

Decimales enteros literales

Los literales enteros proporcionan valores que se pueden usar donde se necesita una instancia de byte , short , int , long o char . (Este ejemplo se centra en las formas decimales simples. Otros ejemplos explican cómo los literales en octal, hexadecimal y binario, y el uso de guiones bajos para mejorar la legibilidad).

Literales enteros ordinarios

La forma más simple y común de literal entero es un literal entero decimal. Por ejemplo: 

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

Tienes que tener cuidado con los ceros iniciales. Un cero inicial hace que un literal entero se interprete como octal no decimal. 

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

Los literales enteros están sin firmar. Si ve algo como -10 o +10 , estas son en realidad expresiones que usan los operadores unarios - y unarios + .

El rango de literales enteros de esta forma tiene un tipo intrínseco de int , y debe estar en el rango de cero a 2 31 o 2,147,483,648.

Tenga en cuenta que 2 31 es 1 mayor que Integer.MAX_VALUE . Los literales desde 0 hasta 2147483647 se pueden utilizar en cualquier lugar, pero es un error de compilación de usar 2147483648 sin precedentes unario - operador. (En otras palabras, está reservado para expresar el valor de Integer.MIN_VALUE ). 

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

Literales enteros largos

Los literales de tipo long se expresan agregando un sufijo L Por ejemplo: 

 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

Tenga en cuenta que la distinción entre literales int y long es significativa en otros lugares. Por ejemplo 

 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.

Referencia: JLS 3.10.1 - Literales enteros

Literales booleanos

Los literales booleanos son los más simples de los literales en el lenguaje de programación Java. Los dos valores boolean posibles están representados por los literales true y false . Estos son sensibles a las mayúsculas y minúsculas. Por ejemplo: 

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

Literales de cuerda

Los literales de cadena proporcionan la forma más conveniente de representar valores de cadena en el código fuente de Java. Un literal de cadena consiste en:

  • Un carácter de comillas dobles de apertura ( " ).
  • Cero o más caracteres que no sean ni comillas dobles ni caracteres de salto de línea. (Un carácter de barra diagonal inversa ( \ ) altera el significado de los caracteres subsiguientes; consulte Secuencias de escape en literales ).
  • Un personaje de cierre de doble cita.

Por ejemplo: 

"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

Tenga en cuenta que un único literal de cadena no puede abarcar varias líneas de código fuente. Es un error de compilación para que se produzca un salto de línea (o el final del archivo de origen) antes de la comilla doble de cierre de un literal. Por ejemplo: 

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

Cuerdas largas

Si necesita una cadena que sea demasiado larga para que quepa en una línea, la forma convencional de expresarla es dividirla en varios literales y usar el operador de concatenación ( + ) para unir las piezas. Por ejemplo 

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

Una expresión como la anterior que consta de cadenas literales y + satisface los requisitos para ser una expresión constante . Eso significa que la expresión será evaluada por el compilador y representada en tiempo de ejecución por un solo objeto String .

Interning de literales de cuerda.

Cuando la JVM carga el archivo de clase que contiene literales de cadena, el sistema de tiempo de ejecución introduce internamente los objetos de String correspondientes. Esto significa que un literal de cadena utilizado en varias clases no ocupa más espacio que si se usara en una clase.

Para obtener más información sobre interning y el conjunto de cadenas, consulte el ejemplo de String pool y heap storage en el tema Strings.

El literal nulo

El literal nulo (escrito como null ) representa el único valor del tipo nulo. Aquí hay unos ejemplos 

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

    myMethod(null);

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

El tipo nulo es bastante inusual. No tiene nombre, por lo que no puede expresarlo en el código fuente de Java. (Y tampoco tiene representación en tiempo de ejecución.)

El único propósito del tipo nulo es ser el tipo de null . Es compatible con la asignación de todos los tipos de referencia, y se puede convertir a cualquier tipo de referencia. (En este último caso, la conversión no implica una verificación de tipo de tiempo de ejecución).

Finalmente, null tiene la propiedad de que null instanceof <SomeReferenceType> evaluará como false , sin importar cuál sea el tipo.

Literales de punto flotante

Los literales de punto flotante proporcionan valores que se pueden usar cuando se necesita una instancia float o double . Hay tres tipos de literal de punto flotante.

  • Formas decimales simples
  • Formas decimales escaladas
  • Formas hexadecimales

(Las reglas de sintaxis de JLS combinan las dos formas decimales en una sola forma. Las tratamos por separado para facilitar la explicación).

Hay tipos literales distintos para literales float y double , expresados ​​con sufijos. Las diversas formas usan letras para expresar diferentes cosas. Estas letras son mayúsculas y minúsculas.

Formas decimales simples

La forma más simple de literal de punto flotante consiste en uno o más dígitos decimales y un punto decimal ( . ) Y un sufijo opcional ( f , F , d o D ). El sufijo opcional le permite especificar que el literal es un valor float ( f o F ) o double ( d o D ). El valor predeterminado (cuando no se especifica ningún sufijo) es double .

Por ejemplo 

 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)

De hecho, los dígitos decimales seguidos de un sufijo también son un literal de coma flotante. 

 1F      // means the same thing as 1.0F

El significado de un literal decimal es el número de punto flotante de IEEE más cercano al número real matemático de precisión infinita indicado por la forma de punto flotante decimal. Este valor conceptual se convierte a la representación de punto flotante binario IEEE utilizando la ronda al más cercano . (La semántica precisa de la conversión decimal se especifica en los javadocs para Double.valueOf(String) y Float.valueOf(String) , teniendo en cuenta que existen diferencias en las sintaxis numéricas).

Formas decimales escaladas

Las formas decimales escaladas consisten en un decimal simple con una parte de exponente introducida por una E o e , y seguidas de un entero con signo. La parte del exponente es una mano corta para multiplicar la forma decimal por una potencia de diez, como se muestra en los ejemplos a continuación. También hay un sufijo opcional para distinguir los literales float y double . Aquí hay unos ejemplos: 

 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)

El tamaño de un literal está limitado por la representación ( float o double ). Es un error de compilación si el factor de escala da como resultado un valor demasiado grande o demasiado pequeño.

Formas hexadecimales

A partir de Java 6, es posible expresar literales de punto flotante en hexadecimal. La forma hexadecimal tiene una sintaxis análoga a las formas decimales simples y escaladas con las siguientes diferencias:

  1. Cada hexadecimal comienza literales de punto flotante con un cero ( 0 ) y luego un x o X .
  2. Los dígitos del número (pero no la parte del exponente!) También incluyen los dígitos hexadecimales a medio de f y sus equivalentes en mayúsculas.
  3. El exponente es obligatorio y se introduce mediante la letra p (o P ) en lugar de una e o una E El exponente representa un factor de escala que es una potencia de 2 en lugar de una potencia de 10.

Aquí hay unos ejemplos: 

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

Consejo: dado que las formas hexadecimales de punto flotante no son familiares para la mayoría de los programadores de Java, es aconsejable usarlas con moderación.

Guiones bajos

Comenzando con Java 7, se permiten guiones bajos dentro de las cadenas de dígitos en las tres formas de literal de coma flotante. Esto se aplica también a las partes del "exponente". Consulte Uso de guiones bajos para mejorar la legibilidad .

Casos especiales

Es un error de compilación si un literal de punto flotante denota un número que es demasiado grande o demasiado pequeño para representarlo en la representación seleccionada; es decir, si el número se desbordaría a + INF o -INF, o subbordaría a 0.0. Sin embargo, es legal que un literal represente un número desnormalizado distinto de cero.

La sintaxis literal de punto flotante no proporciona representaciones literales para los valores especiales IEEE 754, como los valores INF y NaN. Si necesita expresarlos en código fuente, la forma recomendada es usar las constantes definidas por java.lang.Float y java.lang.Double ; por ejemplo, Float.NaN , Float.NEGATIVE_INFINITY y Float.POSITIVE_INFINITY .

Literales de personajes

Literales de caracteres proporcionan la forma más conveniente de expresar char valores en el código fuente de Java. Un carácter literal consiste en:

  • Un carácter de comillas simples ( ' ) de apertura.
  • Una representación de un personaje. Esta representación no puede ser una comilla simple o un carácter de salto de línea, pero puede ser una secuencia de escape introducida por un carácter de barra invertida ( \ ); Ver secuencias de escape en literales .
  • Un carácter de comillas simples ( ' ) de cierre.

Por ejemplo: 

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

Un salto de línea en un literal de carácter es un error de compilación: 

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


Modified text is an extract of the original Stack Overflow Documentation
Licenciado bajo CC BY-SA 3.0
No afiliado a Stack Overflow