Una secuencia de escape es una combinación de caracteres que permiten incluir símbolos dentro de una cadena de texto que no se pueden escribir de forma directa.

Todas las secuencias de escape en Java comienzan con una barra invertida \

Una secuencia de escape está formada por una barra invertida seguida de una letra, un carácter o de una combinación de dígitos.

Las secuencias de escape en Java sirven para insertar en un texto saltos de línea, tabulaciones, comillas o incluso la propia barra invertida, evitando errores y permitiendo crear textos más flexibles.

Algunas secuencias de escape definidas en Java son las que se muestran en esta tabla:

Representa un salto de línea. Es una de las secuencias de escape en Java más utilizadas cuando se trabaja con texto, especialmente al mostrar mensajes por consola.

Cuando se incluye la secuencia \n dentro una cadena de texto estamos indicando que en ese punto queremos que se produzca un salto de línea.

Ejemplos de uso de \n para entender cómo funciona:

System.out.println("Hola\nMundo");

En esta instrucción queremos mostrar por consola el mensaje «Hola Mundo» pero hemos incluido la secuencia de escape \n entre ambas palabras. Esto provocará que se muestre por consola la palabra Hola, a continuación se produce un salto de línea y la palabra Mundo se mostrará en la la línea de abajo:

Salida por pantalla:

Hola
Mundo

El resultado es el mismo que si hubiésemos escrito las instrucciones:

System.out.println("Hola");
System.out.println("Mundo");

Utilizando la secuencia de escape \n nos ha permitido simplificar el código, escribiendo menos instrucciones para obtener el mismo resultado.

Utilizar la secuencia de escape \n para partir mensajes largos y mostrarlos en varias líneas.

Es un ejemplo similar al anterior pero creando varias líneas a partir de un único mensaje. Además veremos que se pueden incluir varias secuencias de escape \n consecutivas para provocar varios saltos de línea seguidos:

int x = 2, y = 3;
System.out.println("Valores de las variables:\n\nx = " + x + "\ny = " + y);

Salida por pantalla:

Valores de las variables:

x = 2
y = 3

Cada \n introducido en la cadena de texto provoca un salto de línea. En este ejemplo se han introducido dos secuencias \n después de Valores de las variables lo que ha provocado dos saltos de línea antes de mostrar x = 2

La secuencia de escape \n también se puede utilizar como contenido de una variable de tipo String. Por ejemplo:

String menu = "1 -> Suma\n2 -> Resta\n3 -> Multiplicación\n4 -> División";
System.out.println(menu);

Salida por pantalla:

1 -> Suma
2 -> Resta
3 -> Multiplicación
4 -> División

La secuencia de escape \r representa un retorno de carro (carriage return). Su función es desplazar el cursor al principio de la línea actual sin producir un salto de línea.

Diferencia entre las secuencias de escape \n y \r

Hoy en día se usa menos que \n pero sigue siendo de utilidad en :

Ejemplos de uso de la secuencia de escape \r

Sobreescribir texto en la misma línea:

System.out.print("Cargando...");
System.out.print("\rCompletado!");

Al ejecutar estas dos instrucciones se mostrará por consola Cargando... y a continuación el cursor se coloca al principio de la línea y muestra el mensaje Completado!

En la práctica no veremos el primer mensaje ya que se sobreescribe de manera inmediata por el segundo.

Lo que pretendemos es que se vean ambos mensajes, primero la palabra Cargando… y después sustituirlo en la misma línea con Completado!

Lo más adecuado es introducir una pausa en la ejecución del programa entre una instrucción y otra utilizando el método Thread.sleep(). Este método pausa la ejecución en la cantidad de milisegundos que se le indique.

Las instrucciones para sobreescribir texto en la misma línea con \r quedarían así:

System.out.print("Cargando...");
Thread.sleep(3000);
System.out.print("\rCompletado!");

Se muestra el mensaje Cargando... y el programa se pausa durante 3000 milisegundos (3 segundos). A continuación se desplaza el cursor al principio de la línea actual y se muestra Completado!

Mostrar el progreso de un proceso, por ejemplo el % realizado en la instalación de un software.

for (int i = 0; i <= 100; i += 10) {
      System.out.print("\rInstalando: " + i + "%");
      Thread.sleep(2000);
}
System.out.println("\nInstalación finalizada");

En cada iteración del bucle for se muestra por pantalla el mensaje y se pausa el programa 2 segundos. El mensaje que se muestra en la instrucción System.out.println() contiene la secuencia de escape \r al principio por lo que antes de mostrar el mensaje el cursor se sitúa al principio de la línea actual.

Lo que veremos por pantalla serán los siguientes mensajes, todos en la misma línea:

Instalando: 0%
Instalando: 10%
Instalando: 20%
. . . . . . . .
Instalando: 100%

Cuando finaliza el bucle for se muestra el mensaje:

Instalación finalizada

La secuencia de escape \t representa un tabulador horizontal. Hace que el cursor avance una serie de espacios en blanco hasta el siguiente punto de tabulación.

Su función principal es alinear texto, crear columnas o dar un formato más limpio a la salida por consola.

Los puntos de tabulación suelen estar formados por 4 u 8 espacios en blanco dependiendo del entorno. Por eso \t es muy útil para:

Ejemplos de uso de la secuencia de escape \t

Mostrar la salida por consola en tres columnas.

System.out.println("Curso\tAlumnos\tAprobados");
System.out.println("1DAW\t24\t16");
System.out.println("2DAW\t18\t10");
System.out.println("1DAM\t20\t16");
System.out.println("2DAM\t15\t12");

Al ejecutar las instrucciones, los mensajes se muestran por pantalla formando tres columnas:

Curso	Alumnos	Aprobados
1DAW	24      16
2DAW	18      10
1DAM	20      16
2DAM	15      12

Es una forma simple de mostrar la información en columnas sin necesidad de realizar código más complejo.

Mostrar datos alineados.

String nombre = "Antonio Moreno Valero";
String curso = "1DAW";
int edad = 20;
System.out.println("Nombre:\t" + nombre);
System.out.println("Edad:\t" + edad);
System.out.println("Curso:\t" + curso);

En este caso tenemos 3 variables que contienen los datos a mostrar. Para mostrarlos se ha usado \t después de cada una de las etiquetas por lo que los datos a mostrar aparecerán alineados. La salida por pantalla es esta:

Nombre:	Antonio Moreno Valero
Edad:	20
Curso:	1DAW

Ejemplo de uso combinado de las secuencias de escape en Java. En este ejemplo se combinan las secuencias \n y \t para dar un formato más visual a los datos que me muestran por consola.

System.out.println("Lista de tareas:\n\t1. Estudiar el tema 3\n\t2. Realizar el ejercicio 4\n\t3. Realizar la práctica 1");
System.out.println("Plazos de entrega:\n\tEjercicio 4\tLunes 15\n\tPráctica 1\tJueves 18");

Los mensajes que se van a mostrar por pantalla contienen las secuencias de escape \n y \t. El resultado de ejecutar estas instrucciones es el siguiente:

Lista de tareas:
        1. Estudiar el tema 3
        2. Realizar el ejercicio 4
        3. Realizar la práctica 1
Plazos de entrega:
        Ejercicio 4     Lunes 15
        Práctica 1      Jueves 18

La secuencia de escape \b representa un retroceso (backspace) dentro de una cadena de texto. Su función es mover el cursor un carácter hacia atrás.

Un detalle importante a tener en cuenta sobre esta secuencia de escape es que en muchos entornos de desarrollo como IntelliJ, Eclipse, VS Code e incluso algunas consolas del sistema, \b no elimina el carácter anterior sino que mueve el cursor sin eliminar nada. En algunos casos puede incluso no hacer nada visible.

Por todo esto \b se considera:

Ejemplo de uso de la secuencia de escape \b

System.out.println("Lunes\bMartes");

Salida por pantalla:

LuneMartes

Después del carácter s de Lunes el cursor retrocede un carácter hacia atrás por lo que la M de martes sobreescribe el carácter s.

La secuencia \" permite incluir las comillas dobles dentro de una cadena de texto. En Java las cadenas de texto se escriben entre comillas dobles. Si queremos que la comilla doble forme parte del texto tenemos que escaparla mediante la secuencia de escape \".

Ejemplos de uso de la secuencia de escape \"

Si queremos mostrar por pantalla el mensaje:

Como dijo Sócrates: "solo sé que no sé nada"

NO podemos escribir:

System.out.println("Como dijo Sócrates: "solo sé que no sé nada"");

Esta instrucción produce un error de compilación. Las cadenas de texto en Java comienzan y finalizan con comillas dobles. Al incluir en el texto comillas dobles se provoca el error ya que Java considera las comillas antes de la palabra solo como las comillas que finalizan el String quedando el resto del texto fuera del String lo que produce el error.

Para que Java entienda que las comillas interiores forman parte del texto debemos usar la secuencia de escape \"

System.out.println("Como dijo Sócrates: \"solo sé que no sé nada\"");

Mostrar código java dentro de Java.

System.out.println("Ejemplo de código Java");
System.out.println("Para mostrar \"Hola Mundo\" se escribe la instrucción:");
System.out.println("System.out.println(\"Hola mundo\");");

Salida por pantalla:

Ejemplo de código Java:
Para mostrar "Hola Mundo" se escribe la instrucción:
System.out.println("Hola mundo");

Mostrar por consola el contenido de una variable de tipo String entre comillas.

String titulo = "Programación Java";
System.out.println("Título: \"" + titulo + "\"");

Salida por pantalla:

Título: "Programación Java"

Representa una comilla simple.

Se utiliza para incluir el carácter comilla simple dentro de una cadena de texto. Aunque en Java no es necesario utilizar la secuencia de escape \’ para incluir la comilla simple dentro de un String, es posible usarla.

Por ejemplo, para mostrar por pantalla el mensaje

Como dijo Sócrates: 'solo sé que no sé nada'

Podemos escribir la instrucción utilizando la secuencia de escape \' o directamente utilizando el carácter '

System.out.println("Como dijo Sócrates: 'solo sé que no sé nada'");
System.out.println("Como dijo Sócrates: \'solo sé que no sé nada\'");

En Java no es necesario escapar la comilla simple dentro de un String por lo tanto ambas instrucciones son válidas.

Esto es así porque:

¿Cuándo es obligatorio utilizar la secuencia de escape \’ ?

Solo cuando trabajamos con variables de tipo char. Los valores tipo char se escriben entre comillas simples y aquí si será necesario escapar el carácter ' para que no se confunda con el delimitador del carácter.

Por ejemplo, en la asignación

char c = '\'';

es necesario utilizar la secuencia de escape ya que de otro modo la comilla sin escapar provocaría un error.

Hoy en día, salvo en algunas situaciones en las que se trabaja con variables de tipo char, en el trabajo con Strings la mayoría de programadores no la utiliza, ya que no aporta nada salvo en situaciones muy específicas. Sin embargo, conocerla forma parte del aprendizaje completo de las secuencias de escape en Java.

La secuencia de escape \\ representa una barra invertida \

Permite incluir la barra invertida dentro de un String. La barra invertida es necesario escaparla porque:

Se trata de una de las secuencias de escape en Java más utilizadas ya que podemos usarla para:

Ejemplos de uso de la secuencia de escape \\

Mostrar un String que contiene la ruta de un archivo.

String ruta = "C:\\Users\\Alumno\\Documents\\archivo.txt";
System.out.println(ruta);

Salida por pantalla:

C:\Users\Alumno\Documents\archivo.txt

Mostrar un mensaje que contiene la ruta de un archivo.

System.out.println("Archivo guardado en C:\\temp\\datos.txt");

Salida por pantalla:

Archivo guardado en C:\temp\datos.txt

Uso de \\ en expresiones regulares. En este ejemplo se muestran por pantalla tres patrones de expresiones regulares relacionados con dígitos.

System.out.println("Patrones de expresiones regulares para dígitos");
System.out.println("Un solo dígito: \\d");
System.out.println("Cero o más dígitos: \\d*");
System.out.println("Uno o más dígitos: \\d+");

Salida por pantalla:

Patrones de expresiones regulares para dígitos
Un solo dígito: \d
Cero o más dígitos: \d*
Uno o más dígitos: \d+

Mostrar una tabla con las secuencias de escape en java más importantes.

System.out.println("Secuencias de escape en java más importantes");
System.out.println("\\n\tSalto de línea");
System.out.println("\\\"\tComillas dobles");
System.out.println("\\\\\tBarra inversa");

Salida por pantalla:

Secuencias de escape en java más importantes
\n      Salto de línea
\"      Comillas dobles
\\      Barra inversa

Esta secuencia de escape representa un carácter Unicode usando su valor hexadecimal de 4 dígitos.

La forma de utilizarla es \udddd donde dddd son los 4 dígitos hexadecimales del carácter Unicode.

Por ejemplo:

System.out.println("\u00A9 2026");

El valor hexadecimal 00A9 corresponde al carácter Unicode ©

Se muestra por pantalla:

© 2026

Limitación importante: mediante la secuencia de escape \udddd solo podemos representar caracteres Unicode entre U+0000 y U+FFFF

Unicode contiene muchos más caracteres fuera de este rango pero mediante esta secuencia de escape podremos representar solamente los comprendidos entre los códigos 0000 y FFFF. Este rango de códigos corresponde a lo que se llama el Plano Multilingüe Básico (PMB) de Unicode.

Los emojis no caben en \udddd porque su valor está fuera del PMB. Por ejemplo:

😀 U+1F600
🔥 U+1F525
🚀 U+1F680

Hasta no hace mucho, la forma de superar esta limitación era utilizando los llamados surrogate pairs o pares sustitutos. Consiste en transformar el valor Unicode del emoji, o de cualquier otro carácter fuera del rango 0000 – FFFF, en dos pares de valores equivalentes dentro del rango 0000 – FFFF.

Esta transformación del valor Unicode en el surrogate pair equivalente se puede hacer en sitios como SurrogatePairCalculator.

Por ejemplo, para el emoji 🔥 su código Unicode 1F525 equivale al par D83D+DD25

Para mostrarlo por consola escribiremos la instrucción con los dos códigos del par uno a continuación del otro:

System.out.println("\uD83D\uDD25");

Esto funciona porque internamente Java usa la codificación UTF-16 almacenando cada carácter en 2 bytes.

En la actualidad ya no es necesario utilizar esta técnica. Podemos copiar y pegar el emoji en el código y mostrarlo sin necesidad de utilizar la secuencia de escape \u

System.out.println("Comenzamos!!!!  🚀");

Esto funcionará siempre que el sistema de codificación utilizado sea UTF-8 y la consola soporte los caracteres Unicode.

En conclusión, la secuencia de escape \udddd fue esencial en los inicios de Java, pero hoy en día su uso es excepcional. Gracias a la codificación UTF-8 y al soporte completo Unicode podemos escribir caracteres como letras acentuadas, símbolos internacionales, caracteres especiales, emojis, etc. directamente en el código, de forma clara y legible.