¡Descarga Introducción a la Programación en Java: Cadenas y Scanner y más Apuntes en PDF de Informática solo en Docsity!
String y Scanner
1 La clase java.lang.String
1.1 Cadenas vs. referencias a cadenas
Las cadenas de caracteres en Java no son tipos nativos (como char, boolean, int o float), sino que son
objetos de la clase String. Una variable de tipo String, por tanto, no almacena una cadena, sino que guarda
una referencia (una especie de puntero) a un objeto de la clase String, objeto que se ha creado en una zona de
la memoria en la que se crean y destruyen objetos dinámicamente (el heap o montón).
Ese objeto de la clase String almacena la cadena de caracteres propiamente dicha, y contiene una serie de
métodos que pueden ser llamados para realizar operaciones sobre la misma.
Hay dos formas de declarar una variable de tipo String:
- String s1 = new String(“Cadena de ejemplo 1 ”);
- String s2 = “Cadena de ejemplo 2 ”;
La segunda forma es la preferida por ser más eficiente, ya que la primera siempre crea un nuevo objeto String
para almacenar la cadena, mientras que la segunda no lo hará si ya existe una cadena igual en la memoria.
Por tanto, aunque el valor de la cadena sea el mismo, es posible que en realidad sean dos objetos distintos. Por
ejemplo:
- String s1 = “Hola”; // se crea un nuevo objeto String con referencia ref 1
- String s2 = new String(“Hola”); // se crea un nuevo objeto String con referencia ref 2
- String s3 = new String(“Hola”); // se crea un nuevo objeto String con referencia ref 3
- String s4 = “Hola”; // no se crea un nuevo objeto String, se asigna la referencia ref 1
Por tanto, como s1 y s2 almacenan referencias a objetos distintos, la comparación ‘s1==s2’ da como resultado
false. Es por ello que en Java no se utiliza el operador ‘==’, para comparar cadenas, sino que se emplea el
método ‘equals’ de la clase String. Es decir, la llamada ‘s1.equals(s2)’ da como resultado true, ya que lo
que el método ‘equals’ comprueba es si los objetos apuntados por ambas referencias tienen el mismo valor.
Lo mismo ocurre con s1, s2 y s3, que las tres son referencias a objetos distintos y, por tanto, ‘s1==s3’ y
‘s2==s3’ también dan ambas un resultado false, mientras que ‘s1.equals(s3)’ y ‘s2.equals(s3)’ dan
como resultado true.
Por el contrario, tanto ‘s 1 ==s4’ como ‘s 1 .equals(s4)’ dan como resultado true (una explicación detallada de
cómo funciona realmente se proporcionará más adelante, tras presentar algún concepto adicional en teoría).
En todo caso, para evitar errores, es recomendable comparar siempre las cadenas con el método ‘equals’.
s4= ref 1
s 3 = ref 3
s2= ref
s1= ref
:String
Hola
:String
Hola
:String
Hola
ref
ref
ref
Programación II
1.2 API de la clase String
En la clase String se definen un gran número de métodos para realizar las operaciones habituales que se suelen
hacer sobre las cadenas (averiguar la longitud de una cadena, convertirla a mayúsculas, obtener una subcadena
de la original…). Se puede consultar la sintaxis, parámetros y resultados de todas ellas en la documentación oficial
1
de la clase String (hay un enlace en MOOVI).
Los métodos que nos proporciona la clase String son métodos que se invocan sobre una instancia de una cadena
(una variable String o una cadena literal), por lo que la sintaxis de la llamada sería de una de estas formas:
variableCadena.metodo(parametros);
“cadena literal”.metodo(parametros);
A continuación, se presentan algunos de los métodos más útiles, que en ningún caso conforman una lista
exhaustiva, para lo cual se recomienda consultar la mencionada documentación oficial.
Métodos que obtienen información sobre la cadena:
§ length() à devuelve la longitud de la cadena
§ charAt(i) à devuelve el carácter que está en la posición i de la cadena
§ indexOf(c) à devuelve la posición en la cadena del primer carácter c
§ lastIndexOf(c) à devuelve la posición en la cadena del último carácter c
§ split(c) à divide la cadena en una secuencia de subcadenas (aquellas separadas por el carácter c)
Métodos que comparan la cadena:
§ equals(s) à devuelve true o false dependiendo de si la cadena es igual o no a la cadena s
§ contains(s) à devuelve true o false dependiendo de si la cadena contiene la cadena s
§ startsWith(s) à devuelve true o false dependiendo de si la cadena empieza por la cadena s
§ endsWith(s) à devuelve true o false dependiendo de si la cadena termina por la cadena s
§ compareTo(s) à devuelve 0, un número positivo, o uno negativo dependiendo de si la cadena es igual,
mayor o menor alfabéticamente que la cadena s
Métodos que transforman la cadena:
§ toUpperCase() à devuelve la cadena convertida a mayúsculas
§ toLowerCase() à devuelve la cadena convertida a minúsculas
§ substring(p1,p2) à devuelve la subcadena que va desde la posición p1 (incluida) de la cadena original
a la p2 (excluida)
§ trim() à elimina los espacios (tabuladores, fin de línea…) iniciales y finales de la cadena original
§ concat(s) à añade la cadena s a la cadena. Es equivalente al operador ‘+’ (s1+s2).
§ replaceAll(s1,s2) à devuelve la cadena habiendo reemplazado las ocurrencias de s1 por s
Destacar que estos últimos métodos (los que transforman la cadena), no transforman la cadena original, sino
que devuelven una nueva cadena con la transformación aplicada. Por tanto, se usarían de la siguiente forma:
s1 = s1.toUpperCase()
o asignando el resultado a otra variable si así se prefiere.
1
Para ello, basta con buscar en Internet algo como “javadoc Oracle String” y enseguida nos aparece un enlace a la página
de la documentación (mejor si es la correspondiente al JDK que estamos utilizando).
2 Lectura del teclado: la clase Scanner
Como recordamos, la clase System incluía un objeto llamado out para poder escribir en la consola (mediante su
método print ). De igual forma, la clase System tiene otro objeto llamado in que representa al teclado, y que
usaremos para leer la información introducida por el usuario.
Para poder leer del teclado, la API de Java incluye una clase sencilla para leer información de una fuente en
general, la clase Scanner, que se encuentra en el paquete java.util. Si esa fuente es el objeto System.in ,
estaremos leyendo del teclado.
El primer paso será crear un objeto de esa clase, un objeto que leerá del teclado:
java.util.Scanner input = new java.util.Scanner(System.in);
Aunque podemos usar el nombre completo de la clase (java.util.Scanner), lo más habitual será importar la
clase al comienzo del programa y luego usar su nombre abreviado
2
import java.util.Scanner;
Scanner input = new Scanner(System.in);
Entre los muchos métodos de los que dispone la clase Scanner (hay un enlace a la documentación en MOOVI),
se encuentra nextLine, que devuelve como una cadena todos los caracteres introducidos por el usuario hasta
el fin de línea (es decir, hasta el carácter de retorno de carro o tecla ENTER, que en Linux es ‘\n’).
String linea = input.nextLine();
El método nextLine se bloqueará a la espera de que el usuario teclee la línea y pulse luego ENTER. Tras ello, la
cadena tecleada se asignará a la variable linea. El carácter ‘\n’ es el delimitador que marca el final de la lectura,
es leído y retirado de la entrada, pero no es devuelto como último carácter de la cadena leída.
El programa completo sería, pues:
IMPORTANTE. Fíjate en el estilo de programación, que facilita la comprensión del código:
- Las variables tienen nombres significativos.
- Las variables están declaradas al comienzo del método.
- El código está adecuadamente sangrado.
2
Siempre y cuando no existan colisiones con otra clase llamada igual (Scanner) que pertenezca a otro paquete.
import java.util.Scanner;
public class LeeLinea {
public static void main (String[] args) {
String linea;
Scanner input;
input = new Scanner(System.in);
System.out.print("Introduce una línea: ");
linea = input.nextLine();
System.out.println("Has tecleado: '"+linea+"'");
3 Apéndice A (no publicar al principio)
Para entender adecuadamente cómo se gestionan y comparan las cadenas en Java, es necesario explicar que la
JVM intenta ahorrar espacio en memoria teniendo una única copia de cada cadena literal.
Para ello, la JVM tiene un área de memoria especial dentro del heap llamada String Constant Pool (SCP), donde
coloca cada cadena que se declara. En esta área nunca hay cadenas duplicadas, como veremos a continuación.
Cada vez que declaramos una cadena con el constructor String, se crea un objeto String en el heap , y se
devuelve una referencia al mismo (aunque dos variables parezcan tener el mismo, valor, en realidad son dos
objetos distintos, con distintas referencias). Pero, además, si se crea la cadena con el constructor String se crea
también otro objeto idéntico en el SCP (excepto si ya hay en el SCP otro objeto String con el mismo valor). A
esta segunda copia se la denomina interned.
String s1 = new String(“Cadena1”); // crea dos objetos: en el heap y en el SCP
String s2 = new String(“Cadena2”); // crea dos objetos: en el heap y en el SCP
Si ahora declaramos y creamos con el constructor String una nueva cadena con un valor ya existente en el SCP,
se crea un nuevo objeto String en el heap , pero no en el SCP, ya que la JVM comprueba antes si ya existe, y,
como dijimos, nunca duplica cadenas en el SCP. Por ejemplo, si ahora hacemos:
String s3 = new String(“Cadena1”); // crea un objeto en el heap , pero no en el SCP
heap
SCP
:String
Cadena 2
:String
Cadena 2
ref
iref
s2: ref
s 1 : ref
:String
Cadena
ref
:String
Cadena 1
iref
SCP
:String
Cadena 2
:String
Cadena 2
ref
iref
s3: ref
s2: ref
s1: ref
:String
Cadena
ref
:String
Cadena 1
iref
:String
Cadena 1
ref
stack
stack
heap
