Correspondencia en Python —>
String nombrecadena . En Java no existe un tipo de dato primitivo que pueda almacenar cadenas de caracteres. Para poder almacenar cadenas debemos de recurrir a la clase String, que nos permite crear objetos que en realidad serán las cadenas que necesitamos guardar.
Una característica de los objetos de la clase String, es que no se pueden modificar una vez definidos, aunque podremos obtener otros objetos String, a partir de los que ya tenemos.
public class Mi_cadena{
public static void main (String args[]){
String CADENA_1="Me llamo Eduardo";
String cadena_2="Tengo 60 años.";
System.out.println(CADENA_1+". "+cadena_2);
}
}Me llamo Eduardo. Tengo 60 años.En este código anterior hemos creado un objeto de tipo cadena que está configurado como una constante (de ahí que se hayan usado mayúsculas). El segundo objeto deseamos que crea una variable, y como tal la escribimos en minúsculas. En general, cualquier tipo de dato que esperamos que no tenga ninguna variación a lo largo del programa lo definimos como constante (en mayúsculas), y las que puedan variar (variables) en minúsculas.
Existen muchos métodos aplicables tanto a las variables como a las constantes, que nos permiten obtener determinados datos a partir del dato original.
El método .charAt(posición) devuelve el carácter que se encuentra en la posición pasada como parámetro.
public class Prueba2 {
public static void main(String[] args) {
String mi_cadena="Esta es mi cadena";
char mi_letra=mi_cadena.charAt(3);
mi_cadena=mi_cadena+mi_letra;
System.out.println(mi_letra);
System.out.println(mi_cadena);
}
}Resultado:
a
Esta es mi cadenaaString toUpperCase ( ) . Devuelve una cadena a partir de otra, convirtiendo todos los caracteres a letras mayúsculas.
String toLowerCase ( ) . Devuelve una cadena a partir de otra, convirtiendo todos los caracteres a letras minúsculas.
public class Mi_cadena{
public static void main (String args[]){
String CADENA_1="Me llamo Eduardo";
String cadena_2="Tengo 60 años.";
String mayusculas=CADENA_1.toUpperCase();
String minusculas=cadena_2.toLowerCase();
System.out.println(mayusculas+". "+minusculas);
}
}ME LLAMO EDUARDO. tengo 60 años.En java no existe un método como tal, que permita centrar una cadena dentro de un texto de la misma forma que el método cadena.center ( ) de Python. Sin embargo, podemos construir una rutina que realice la misma función.
public class CentrarCadena {
public static String centrar(String texto, int longitudFinal, String relleno ) {
if (texto == null || texto.length() >= longitudFinal) {
return texto; //Si es texto vacío o
} // su longitud es superior a la total, se devuelve tal cual.
int espaciosTotales = longitudFinal - texto.length();
int espaciosIzquierda = espaciosTotales / 2;
int espaciosDerecha = espaciosTotales - espaciosIzquierda;
// Construir la cadena centrada
String cadena_izquierda=relleno.repeat(espaciosIzquierda);
String cadena_derecha=relleno.repeat(espaciosDerecha);
String total="["+cadena_izquierda+texto+cadena_derecha+"]";
return total;
}
public static void main(String[] args) {
String resultado = centrar("Madrid", 20,"*");
System.out.println(resultado);
}
}[*******Madrid*******]Con el código anterior llamamos a la función centrar. A esta función le pasamos como primer parámetro el texto que queremos centrar. El segundo parámetro es la longitud que va a tener el nuevo texto, y el tercero el carácter que se va a utilizar como relleno. Los corchetes los añadimos al resultado final para darle mejor efecto.
En java podemos unir datos numéricos y datos tipo cadena (String) para poder formar nuevas cadenas.
public class CentrarCadena {
public static void main(String[] args) {
String nacido="Nací en Madrid.";
int edad=25;
String nueva_cadena=nacido+" Tengo "+edad+" años.";
System.out.println(nueva_cadena);
}
}Nací en Madrid. Tengo 25 años.String.format ( ) . Este método de String, nos va a permitir formar cadenas con un determinado formato. Según el tipo de dato, la instrucción recibe diferentes argumentos.
public class CentrarCadena {
public static void main(String[] args) {
String nacido="Madrid";
int edad=25;
String nueva_cadena=String.format("Nací en %s. Tengo %d años", nacido,edad);
System.out.println(nueva_cadena);
}
}Nací en Madrid. Tengo 25 añosEn este primer caso formateamos una cadena que va a contener un dato tipo String (%s) y un dato tipo entero (%d). A continuación debemos facilitar ambos datos para que se proceda a crear una nueva cadena.
public class CadenaIzquierda {
public static void main(String[] args) {
String nacido="Madrid";
String nueva_cadena=String.format("[%-20s]", nacido).replace(" ", "*");
System.out.println(nueva_cadena);
}
}[Madrid**************]Ahora hemos creado una cadena que va a contener 20 caracteres en total. Si el String pasado como parámetro tiene menos de 20 caracteres, se añadirán espacios en blanco. Esta cadena se alineará a la izquierda (luego los espacios en blanco). Como añadido, hemos decidido reemplazar los espacios en blanco con asteriscos. Los corchetes también los hemos añadido voluntariamente como adorno.
A continuación haremos lo mismo, pero alineando el texto a la derecha:
public class CadenaDerecha {
public static void main(String[] args) {
String nacido="Madrid";
String nueva_cadena=String.format("[%20s]", nacido).replace(" ", "*");
System.out.println(nueva_cadena);
}
}[**************Madrid]Es exactamente el mismo código, solo que hemos eliminado el guion que había antes del 20 (indicador de los espacios a ocupar por la nueva cadena).
Veamos ahora como formatear una cadena a partir de un dato numérico:
public class CentrarCadena {
public static void main(String[] args) {
int mi_numero=12;
String izquierda=String.format("[%-20d]", mi_numero);
String derecha=String.format("[%20d]", mi_numero);
System.out.println(izquierda+derecha);
}
}[12 ][ 12]En el código anterior creamos dos cadenas a partir de un dato numérico (un entero). La forma de identificarlo es con el modificador «d» (en lugar de «s»). Por lo demás la idea es la misma, hemos reservado un total de 20 espacios, primero alineamos a la izquierda y luego alineamos a la drecha.
public class CadenaInt {
public static void main(String[] args) {
int mi_numero=12;
String izquierda=String.format("[%-8d]", mi_numero);
String derecha=String.format("[%08d]", mi_numero);
System.out.println(izquierda+derecha);
}
}[12 ][00000012]Código muy parecido al anterior, pero hemos decidido que los espacios en blanco al alinear a la derecha, sean rellenados con «0».
public class CadenasDouble {
public static void main(String[] args) {
double mi_numero=12.3456;
String mi_cadena=String.format("[%020.2f]", mi_numero);
String izquierda=String.format("[%-20.2f]", mi_numero);
String derecha=String.format("[%20.2f]", mi_numero);
System.out.println(mi_cadena);
System.out.println(izquierda+derecha);
}
}[00000000000000012,35]
[12,35 ][ 12,35]El dato convertido ahora a cadena es de tipo double. La primera, la hemos rellenado con 0 a la izquierda (es posible porque la hemos alineado a la derecha). En todos los casos hemos decidido que el número resultante en la cadena, tenga solo dos decimales. Como el dato original tenía más decimales, se ha redondeado al decimal más cercano de dos dígitos.
La forma de indicar los decimales que deseamos, es la cifra indicada antes de «f» (indicativo de dato tipo double).
Caracteres especiales dentro de String. Para incluir caracteres especiales dentro de String, tenemos que escaparlos. Para ello debemos de anteponer la al carácter especial la barra «\». Los principales son:
- \t : Que incluye en la cadena un tabulador.
- \n: Determinará un santo de línea.
- \» : Para poder incluir comillas dobles.
- \\ : Nos permite incluir una contrabarra.
public class Cadenas {
public static void main(String[] args) {
String cadena_tabulada="Esta cadena\testá tabulada.";
String otra="Esta otra\ttambién";
System.out.println(cadena_tabulada);
System.out.println(otra);
}
}Esta cadena está tabulada.
Esta otra tambiénEn el código anterior hemos incluido dos cadenas tabuladas.
public class Cadenas {
public static void main(String[] args) {
String cadena_saltos="Esta es la línea 1,\nesta la 2,\ny la esta la 3.";
System.out.println(cadena_saltos);
}
}Esta es la línea 1,
esta la 2,
y la esta la 3.Veamos a continuación ejemplos de cómo insertar comillas y cómo insertar contrabarras en String:
public class Cadenas {
public static void main(String[] args) {
String cadena_comillas="Este número está \"gafado\".";
String cadena_path="El fichero está en C:\\Users\\eduar\\Desktop\\Eduardo";
System.out.println(cadena_comillas);
System.out.println(cadena_path);
}
}Este número está "gafado".
El fichero está en C:\Users\eduar\Desktop\Eduardocadena1.indexOf (cadena2) . Con este método, podemos comprobar si una cadena (cadena2), está incluida dentro de otra cadena (cadena1). En caso de que esté incluida, nos dará su posición en número entero y teniendo en cuenta que se empieza a contar desde la posición 0. Si no está incluida, nos dará como valor -1.
public class BuscarCadena {
public static void main(String[] args) {
String cadena="Hola, me llamo Eduardo.";
String nombre="Eduardo";
int encontrado=cadena.indexOf(nombre);
if (encontrado>0)
System.out.println("Mi nombre está en la cadena en el puesto "+encontrado);
else
System.out.println("Mi nombre no está en la cadena.");
}
}Mi nombre está en la cadena en el puesto 15También podemos indicar que se empiece a buscar desde una determinada posición. Esta posición se indica como segundo argumento del método.
public class CadenasDouble {
public static void main(String[] args) {
String cadena="Hola. La ola ya llegó al río.";
String subcadena="la";
int encontrado=cadena.indexOf(subcadena,4);
if (encontrado>0)
System.out.println("Si buscamos desde la posición 4, \"la\" está en la posición "+encontrado);
else
System.out.println("La subcadena \"la\" no se encuentra desde esa posición.");
}
}Si buscamos desde la posición 4, "la" está en la posición 10Podemos obtener una nueva cadena, a partir de la suma de dos cadenas existentes.
public class CadenasDouble {
public static void main(String[] args) {
String cadena1="Hola. La ola ya llegó al río.";
String cadena2=" Y los peces saltaron.";
String cadena3=cadena1+cadena2;
System.out.println(cadena3);
}
}Hola. La ola ya llegó al río. Y los peces saltaron.cadena.replace (cadena_origen, cadena_fin ). Si aplicamos el método .replace a un String, obtenemos una nueva cadena donde sustituimos las apariciones del primer argumento por el segundo.
public class SustituirCadena {
public static void main(String[] args) {
String cadena1="Hola. Me llamo Eduardo. Tengo 35 años.";
String cadena2=cadena1.replace("35","40");
System.out.println(cadena2);
}
}Hola. Me llamo Eduardo. Tengo 40 años.Si como segundo argumento ponemos una cadena vacía, el resultado es que elimina la cadena que se indique.
public class SustituirCadena {
public static void main(String[] args) {
String cadena1="Hola. Me llamo Eduardo. Tengo 35 años.";
String cadena2=cadena1.replace("Hola. ","");
System.out.println(cadena2);
}
}Me llamo Eduardo. Tengo 35 años.cadena.replaceFirst (cadena_origen, cadena_fin ). Este método, muy parecido al anterior, elimina solo la primera aparición de la cadena indicada como primer parámetro.
public class SustituirCadena {
public static void main(String[] args) {
String cadena1="Hola. Me llamo Eduardo. Tengo 35 años.";
String cadena2=cadena1.replaceFirst("o","-");
System.out.println(cadena2);
}
}H-la. Me llamo Eduardo. Tengo 35 años.Ayudándonos de un bucle for, podemos reemplazar un determinado número de apariciones sin que sean todas.
public class SustituirCadena {
public static void main(String[] args) {
String cadena1="Hola. Me llamo Eduardo. Tengo 35 años.";
for (int k=0;k<3;k=k+1){
cadena1=cadena1.replaceFirst("o", "-");
}
System.out.println(cadena1);
}
}H-la. Me llam- Eduard-. Tengo 35 años.cadena.length( ) . Este método nos facilita la longitud en caracteres que tiene un objeto String. Debemos de tener en cuenta que el caracter \n (salto de línea) o \t (tabulador), se cuentan como un carácter más.
public class SustituirCadena {
public static void main(String[] args) {
String cadena1="La playa\nestaba\tdesierta.";
int longitud=cadena1.length();
System.out.println(cadena1);
System.out.println("cadena1 tiene "+longitud+ " caracteres");
}
}La playa
estaba desierta.
cadena1 tiene 25 caracterescadena.substring ( ) . Si necesitamos obtener una porción de cadena a partir de otra, podemos utilizar este método. Si el método contiene dos argumentos, el primer indica la posición inicial de la subcadena y el segundo la posición final. Debemos de tener en cuenta que la primera posición de la cadena principal, es la posición 0. La última será la longitud de la cadena original -1. Si el método solo contiene un argumento, la subcadena se forma desde la posición que indica ese argumento hasta el final de la cadena.
public class TrozosCadena {
public static void main(String[] args) {
String mi_cadena="El gobierno central acaba de convocar elecciones.";
int longitud=mi_cadena.length();
String cadena_1=mi_cadena.substring(0,5);
String cadena_2=mi_cadena.substring(6,22);
String cadena_3=mi_cadena.substring(24,longitud-5);
String cadena_4=mi_cadena.substring(longitud-5);
System.out.println(cadena_1);
System.out.println(cadena_2);
System.out.println(cadena_3);
System.out.println(cadena_4);
}
}El go
ierno central ac
a de convocar elecci
ones.Como podemos observar, cadena_4 contiene los últimos 5 caracteres de la cadena principal. (longitud-5)
En java no existe una función explícita que nos facilite una lista con todos los caracteres que contiene un dato String. Sin embargo podemos crear una función que cree dicha lista.
public class ListaCaracteres {
public static void main(String[] args) {
String mi_cadena="Hoy está lloviendo.";
List<Character> lista_caracteres = new ArrayList<>();
for (char c : mi_cadena.toCharArray()) {
lista_caracteres.add(c);
}
System.out.println(lista_caracteres);
}
}[H, o, y, , e, s, t, á, , l, l, o, v, i, e, n, d, o, .]Si queremos contar las veces que aparece una cadena dentro de otra, deberemos recurrir a algún truco, ya que no tiene un método específico que nos lo facilite.
public class SustituirCadena {
public static int apariciones(String cadena, String subcadena){
int contador=0;
int longitud=cadena.length();
int incluido;
for (int k=0; k<longitud;k=k+1){
incluido=(cadena.indexOf(subcadena));
if (incluido>-1){
cadena=cadena.replaceFirst(subcadena, "-");
contador+=1;
}
}
return contador;
}
public static void main(String[] args) {
String cadena1="Hola. Me llamo Eduardo. Tengo 35 años.";
String cadena2="o";
int repeticiones=apariciones(cadena1, cadena2);
System.out.println("\""+cadena2+"\""+" aparece "+repeticiones+" veces en "+"\""+cadena1+"\"");
}
}"o" aparece 5 veces en "Hola. Me llamo Eduardo. Tengo 35 años."cadena1.compareTo(cadena2) Este método compara la cadena1 respecto cadena2, si es mayor la primera nos da un valor positivo (true), si la segunda es mayor nos da false. La forma de compararlo es como si estuviesen ambas cadenas relacionadas en un diccionario, la que esté antes sería menor. Debemos de tener en cuenta que en ASCII las mayúsculas tienen menor valor que las minísculas, por lo tanto una minúscula siempre será mayor que su mayúscula.
public class Prueba2 {
public static void main(String[] args) {
String cadena1="ESta es mi cadena.";
String cadena2="Esta es mi cadena.";
if (cadena1.compareTo(cadena2) > 0){
System.out.println("La primera cadena es mayor.");
}
else{
System.out.println("La segunda cadena es mayor.");
}
}
}Resultado:
La segunda cadena es mayor.cadena1.equals (cadena2) Este método nos permite comparar si dos cadenas son iguales. Para este fin, no debemos de utilizar nunca el comparador «==» ya que al ser String un objeto, nos compararía si dos String tienen la misma dirección de memoria (si los dos objetos son el mismo).
cadena1.equalsIgnoreCase (cadena2) Este método es muy parecido al anterior, pero en este caso trata las mayúsculas como el mismo valor que las minúsculas.
public class CompararCadenas {
public static void main(String[] args) {
String cadena1="San Sebastián";
String cadena2="San Sebastián";
String cadena3="SAN SEBASTIÁN";
String cadena4="También San Sebastián";
if (cadena1.equals(cadena2) && cadena2.equalsIgnoreCase(cadena3)){
System.out.println("Las tres cadenas son iguales");
}
if (cadena2.equals(cadena4) || cadena3.equalsIgnoreCase(cadena4)){
System.out.println("Las cuatro cadenas son iguales");
}
else{
System.out.println("Las cuatro cadenas NO son iguales");
}
}
}Las tres cadenas son iguales
Las cuatro cadenas NO son igualesOtros métodos son:
.trim( ) Que elimina los espacios en blanco que se encuentren al principio y/o al final del String.
.startsWith(«cadena») Indica si el String comienza con la cadena que se pasa como parámetro.
.endsWith(«cadena») Indica si el String finaliza con la cadena que se pasa como parámetro.