{"id":91,"date":"2026-10-01T17:53:02","date_gmt":"2026-10-01T17:53:02","guid":{"rendered":"https:\/\/java.nosoyia.es\/?page_id=91"},"modified":"2026-10-01T17:53:02","modified_gmt":"2026-10-01T17:53:02","slug":"cadenas-clase-string","status":"publish","type":"page","link":"https:\/\/java.nosoyia.es\/?page_id=91","title":{"rendered":"Cadenas (clase String)"},"content":{"rendered":"\n
\n
\n

Correspondencia en Python —><\/p>\n<\/div>\n\n\n\n

\n
\"\"<\/a><\/figure>\n<\/div>\n<\/div>\n\n\n\n

String nombrecadena<\/mark><\/em><\/strong> . 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\u00e1n las cadenas que necesitamos guardar.<\/p>\n\n\n\n

Una caracter\u00edstica 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.<\/p>\n\n\n\n

public class Mi_cadena{\n    public static void main (String args[]){\n        String CADENA_1="Me llamo Eduardo";\n        String cadena_2="Tengo 60 a\u00f1os.";\n        System.out.println(CADENA_1+". "+cadena_2);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
Me llamo Eduardo. Tengo 60 a\u00f1os.<\/code><\/pre><\/div>\n\n\n\n
En este c\u00f3digo anterior hemos creado un objeto de tipo cadena que est\u00e1 configurado como una constante<\/mark><\/em><\/strong> (de ah\u00ed que se hayan usado may\u00fasculas). El segundo objeto deseamos que crea una variable<\/mark><\/em><\/strong>, y como tal la escribimos en min\u00fasculas. En general, cualquier tipo de dato que esperamos que no tenga ninguna variaci\u00f3n a lo largo del programa lo definimos como constante (en may\u00fasculas), y las que puedan variar (variables) en min\u00fasculas.<\/p>\n\n\n\n
Existen muchos m\u00e9todos aplicables tanto a las variables como a las constantes, que nos permiten obtener determinados datos a partir del dato original.<\/p>\n\n\n\n
El m\u00e9todo .charAt(posici\u00f3n)<\/mark><\/em><\/strong> devuelve el car\u00e1cter que se encuentra en la posici\u00f3n pasada como par\u00e1metro.<\/p>\n\n\n\n
public class Prueba2 {\n    public static void main(String[] args) {\n        String mi_cadena="Esta es mi cadena";\n        char mi_letra=mi_cadena.charAt(3);\n        mi_cadena=mi_cadena+mi_letra;\n        System.out.println(mi_letra);\n        System.out.println(mi_cadena);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
Resultado:\n\na\nEsta es mi cadenaa<\/code><\/pre><\/div>\n\n\n\n
String toUpperCase ( )<\/mark><\/em><\/strong> . Devuelve una cadena a partir de otra, convirtiendo todos los caracteres a letras may\u00fasculas.<\/p>\n\n\n\n
String toLowerCase ( )<\/mark><\/em><\/strong> . Devuelve una cadena a partir de otra, convirtiendo todos los caracteres a letras min\u00fasculas.<\/p>\n\n\n\n
public class Mi_cadena{\n    public static void main (String args[]){\n        String CADENA_1="Me llamo Eduardo";\n        String cadena_2="Tengo 60 a\u00f1os.";\n        String mayusculas=CADENA_1.toUpperCase();\n        String minusculas=cadena_2.toLowerCase();\n        System.out.println(mayusculas+". "+minusculas);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
ME LLAMO EDUARDO. tengo 60 a\u00f1os.<\/code><\/pre><\/div>\n\n\n\n
En java no existe un m\u00e9todo como tal, que permita centrar una cadena dentro de un texto de la misma forma que el m\u00e9todo cadena.center ( ) de Python. Sin embargo, podemos construir una rutina que realice la misma funci\u00f3n.<\/p>\n\n\n\n
public class CentrarCadena {\n    public static String centrar(String texto, int longitudFinal, String relleno ) {\n        if (texto == null || texto.length() >= longitudFinal) {\n            return texto;  \/\/Si es texto vac\u00edo o \n        }                  \/\/ su longitud es superior a la total, se devuelve tal cual.\n        \n        int espaciosTotales = longitudFinal - texto.length();\n        int espaciosIzquierda = espaciosTotales \/ 2;\n        int espaciosDerecha = espaciosTotales - espaciosIzquierda;\n\n        \/\/ Construir la cadena centrada\n        String cadena_izquierda=relleno.repeat(espaciosIzquierda);\n        String cadena_derecha=relleno.repeat(espaciosDerecha);\n        String total="["+cadena_izquierda+texto+cadena_derecha+"]";\n        return total;\n    }    \n    public static void main(String[] args) {\n        String resultado = centrar("Madrid", 20,"*");\n        System.out.println(resultado);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
[*******Madrid*******]<\/code><\/pre><\/div>\n\n\n\n
Con el c\u00f3digo anterior llamamos a la funci\u00f3n centrar. A esta funci\u00f3n le pasamos como primer par\u00e1metro el texto que queremos centrar. El segundo par\u00e1metro es la longitud que va a tener el nuevo texto, y el tercero el car\u00e1cter que se va a utilizar como relleno. Los corchetes los a\u00f1adimos al resultado final para darle mejor efecto.<\/p>\n\n\n\n
En java podemos unir datos num\u00e9ricos y datos tipo cadena (String) para poder formar nuevas cadenas. <\/p>\n\n\n\n
public class CentrarCadena {\n    public static void main(String[] args) {\n        String nacido="Nac\u00ed en Madrid.";\n        int edad=25;\n        String nueva_cadena=nacido+" Tengo "+edad+" a\u00f1os.";\n        System.out.println(nueva_cadena);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
Nac\u00ed en Madrid. Tengo 25 a\u00f1os.<\/code><\/pre><\/div>\n\n\n\n
String.format ( )<\/mark><\/em><\/strong> . Este m\u00e9todo de String, nos va a permitir formar cadenas con un determinado formato. Seg\u00fan el tipo de dato, la instrucci\u00f3n recibe diferentes argumentos.<\/p>\n\n\n\n
public class CentrarCadena {\n    public static void main(String[] args) {\n        String nacido="Madrid";\n        int edad=25;\n        String nueva_cadena=String.format("Nac\u00ed en %s. Tengo %d a\u00f1os", nacido,edad);\n        System.out.println(nueva_cadena);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
Nac\u00ed en Madrid. Tengo 25 a\u00f1os<\/code><\/pre><\/div>\n\n\n\n
En este primer caso formateamos una cadena que va a contener un dato tipo String (%s) y un dato tipo entero (%d). A continuaci\u00f3n debemos facilitar ambos datos para que se proceda a crear una nueva cadena.<\/p>\n\n\n\n
public class CadenaIzquierda {\n    public static void main(String[] args) {\n        String nacido="Madrid";\n        String nueva_cadena=String.format("[%-20s]", nacido).replace(" ", "*");\n        System.out.println(nueva_cadena);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
[Madrid**************]<\/code><\/pre><\/div>\n\n\n\n
Ahora hemos creado una cadena que va a contener 20 caracteres en total. Si el String pasado como par\u00e1metro tiene menos de 20 caracteres, se a\u00f1adir\u00e1n espacios en blanco. Esta cadena se alinear\u00e1 a la  izquierda (luego los espacios en blanco). Como a\u00f1adido, hemos decidido reemplazar los espacios en blanco con asteriscos. Los corchetes tambi\u00e9n los hemos a\u00f1adido voluntariamente como adorno.<\/p>\n\n\n\n
A continuaci\u00f3n haremos lo mismo, pero alineando el texto a la derecha:<\/p>\n\n\n\n
public class CadenaDerecha {\n    public static void main(String[] args) {\n        String nacido="Madrid";\n        String nueva_cadena=String.format("[%20s]", nacido).replace(" ", "*");\n        System.out.println(nueva_cadena);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
[**************Madrid]<\/code><\/pre><\/div>\n\n\n\n
Es exactamente el mismo c\u00f3digo, solo que hemos eliminado el guion que hab\u00eda antes del 20 (indicador de los espacios a ocupar por la nueva cadena).<\/p>\n\n\n\n
Veamos ahora como formatear una cadena a partir de un dato num\u00e9rico:<\/p>\n\n\n\n
public class CentrarCadena {\n    public static void main(String[] args) {\n        int mi_numero=12;\n        String izquierda=String.format("[%-20d]", mi_numero);\n        String derecha=String.format("[%20d]", mi_numero);\n        System.out.println(izquierda+derecha);        \n    }\n}<\/code><\/pre><\/div>\n\n\n\n
[12                  ][                  12]<\/code><\/pre><\/div>\n\n\n\n
En el c\u00f3digo anterior creamos dos cadenas a partir de un dato num\u00e9rico (un entero). La forma de identificarlo es con el modificador \u00abd\u00bb (en lugar de \u00abs\u00bb).  Por lo dem\u00e1s la idea es la misma, hemos reservado un total de 20 espacios, primero alineamos a la izquierda y luego alineamos a la drecha.<\/p>\n\n\n\n
public class CadenaInt {\n    public static void main(String[] args) {\n        int mi_numero=12;\n        String izquierda=String.format("[%-8d]", mi_numero);\n        String derecha=String.format("[%08d]", mi_numero);\n        System.out.println(izquierda+derecha);        \n    }\n}<\/code><\/pre><\/div>\n\n\n\n
[12      ][00000012]<\/code><\/pre><\/div>\n\n\n\n
C\u00f3digo muy parecido al anterior, pero hemos decidido que los espacios en blanco al alinear a la derecha, sean rellenados con \u00ab0\u00bb.<\/p>\n\n\n\n
public class CadenasDouble {\n    public static void main(String[] args) {\n        double mi_numero=12.3456;\n        String mi_cadena=String.format("[%020.2f]", mi_numero);\n        String izquierda=String.format("[%-20.2f]", mi_numero);\n        String derecha=String.format("[%20.2f]", mi_numero);\n        System.out.println(mi_cadena);\n        System.out.println(izquierda+derecha);        \n    }\n}<\/code><\/pre><\/div>\n\n\n\n
[00000000000000012,35]\n[12,35               ][               12,35]<\/code><\/pre><\/div>\n\n\n\n
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\u00famero resultante en la cadena, tenga solo dos decimales. Como el dato original ten\u00eda m\u00e1s decimales, se ha redondeado al decimal m\u00e1s cercano de dos d\u00edgitos. <\/p>\n\n\n\n
La forma de indicar los decimales que deseamos, es la cifra indicada antes de \u00abf\u00bb (indicativo de dato tipo double).<\/p>\n\n\n\n
Caracteres especiales<\/mark><\/em><\/strong> dentro de String. Para incluir caracteres especiales dentro de String, tenemos que escaparlos. Para ello debemos de anteponer la  al car\u00e1cter especial la barra \u00ab\\\u00bb. Los principales son:<\/p>\n\n\n\n
    \n
  • \\t : Que incluye en la cadena un tabulador.<\/li>\n\n\n\n
  • \\n: Determinar\u00e1 un santo de l\u00ednea.<\/li>\n\n\n\n
  • \\\u00bb : Para poder incluir comillas dobles.<\/li>\n\n\n\n
  • \\\\ : Nos permite incluir una contrabarra.<\/li>\n<\/ul>\n\n\n\n
    public class Cadenas {\n    public static void main(String[] args) {\n        String cadena_tabulada="Esta cadena\\test\u00e1 tabulada.";\n        String otra="Esta otra\\ttambi\u00e9n";\n        System.out.println(cadena_tabulada);  \n        System.out.println(otra);      \n    }\n}<\/code><\/pre><\/div>\n\n\n\n
    Esta cadena     est\u00e1 tabulada.\nEsta otra       tambi\u00e9n<\/code><\/pre><\/div>\n\n\n\n
    En el c\u00f3digo anterior hemos incluido dos cadenas tabuladas.<\/p>\n\n\n\n
    public class Cadenas {\n    public static void main(String[] args) {\n        String cadena_saltos="Esta es la l\u00ednea 1,\\nesta la 2,\\ny la esta la 3.";\n        System.out.println(cadena_saltos);       \n    }\n}<\/code><\/pre><\/div>\n\n\n\n
    Esta es la l\u00ednea 1,\nesta la 2,\ny la esta la 3.<\/code><\/pre><\/div>\n\n\n\n
    Veamos a continuaci\u00f3n ejemplos de c\u00f3mo insertar comillas y c\u00f3mo insertar contrabarras en String:<\/p>\n\n\n\n
    public class Cadenas {\n    public static void main(String[] args) {\n        String cadena_comillas="Este n\u00famero est\u00e1 \\"gafado\\".";\n        String cadena_path="El fichero est\u00e1 en C:\\\\Users\\\\eduar\\\\Desktop\\\\Eduardo";\n        System.out.println(cadena_comillas); \n        System.out.println(cadena_path);    \n    }\n}<\/code><\/pre><\/div>\n\n\n\n
    Este n\u00famero est\u00e1 "gafado".\nEl fichero est\u00e1 en C:\\Users\\eduar\\Desktop\\Eduardo<\/code><\/pre><\/div>\n\n\n\n
    cadena1.indexOf (cadena2) <\/mark><\/em><\/strong>. Con este m\u00e9todo, podemos comprobar si una cadena (cadena2), est\u00e1 incluida dentro de otra cadena (cadena1). En caso de que est\u00e9 incluida, nos dar\u00e1 su posici\u00f3n en n\u00famero entero y teniendo en cuenta que se empieza a contar desde la posici\u00f3n 0. Si no est\u00e1 incluida, nos dar\u00e1 como valor -1.<\/p>\n\n\n\n
    public class BuscarCadena {\n    public static void main(String[] args) {\n        String cadena="Hola, me llamo Eduardo.";\n        String nombre="Eduardo";\n        int encontrado=cadena.indexOf(nombre);\n        if (encontrado>0)\n            System.out.println("Mi nombre est\u00e1 en la cadena en el puesto "+encontrado);\n        else\n            System.out.println("Mi nombre no est\u00e1 en la cadena.");\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
    Mi nombre est\u00e1 en la cadena en el puesto 15<\/code><\/pre><\/div>\n\n\n\n
    Tambi\u00e9n podemos indicar que se empiece a buscar desde una determinada posici\u00f3n. Esta posici\u00f3n se indica como segundo argumento del m\u00e9todo.<\/p>\n\n\n\n
    public class CadenasDouble {\n    public static void main(String[] args) {\n        String cadena="Hola. La ola ya lleg\u00f3 al r\u00edo.";\n        String subcadena="la";\n        int encontrado=cadena.indexOf(subcadena,4);\n        if (encontrado>0)\n            System.out.println("Si buscamos desde la posici\u00f3n 4, \\"la\\" est\u00e1 en la posici\u00f3n "+encontrado);\n        else\n            System.out.println("La subcadena \\"la\\" no se encuentra desde esa posici\u00f3n.");\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
    Si buscamos desde la posici\u00f3n 4, "la" est\u00e1 en la posici\u00f3n 10<\/code><\/pre><\/div>\n\n\n\n
    Podemos obtener una nueva cadena, a partir de la suma de dos cadenas existentes.<\/p>\n\n\n\n
    public class CadenasDouble {\n    public static void main(String[] args) {\n        String cadena1="Hola. La ola ya lleg\u00f3 al r\u00edo.";\n        String cadena2=" Y los peces saltaron.";\n        String cadena3=cadena1+cadena2;\n\n        System.out.println(cadena3);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
    Hola. La ola ya lleg\u00f3 al r\u00edo. Y los peces saltaron.<\/code><\/pre><\/div>\n\n\n\n
    cadena.replace (cadena_origen, cadena_fin )<\/mark><\/em><\/strong>. Si aplicamos el m\u00e9todo .replace a un String, obtenemos una nueva cadena donde sustituimos las apariciones del primer argumento por el segundo.<\/p>\n\n\n\n
    public class SustituirCadena {\n    public static void main(String[] args) {\n        String cadena1="Hola. Me llamo Eduardo. Tengo 35 a\u00f1os.";\n        String cadena2=cadena1.replace("35","40");\n\n        System.out.println(cadena2);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
    Hola. Me llamo Eduardo. Tengo 40 a\u00f1os.<\/code><\/pre><\/div>\n\n\n\n
    Si como segundo argumento ponemos una cadena vac\u00eda,  el resultado es que elimina la cadena que se indique.<\/p>\n\n\n\n
    public class SustituirCadena {\n    public static void main(String[] args) {\n        String cadena1="Hola. Me llamo Eduardo. Tengo 35 a\u00f1os.";\n        String cadena2=cadena1.replace("Hola. ","");\n\n        System.out.println(cadena2);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
    Me llamo Eduardo. Tengo 35 a\u00f1os.<\/code><\/pre><\/div>\n\n\n\n
    cadena.replaceFirst (cadena_origen, cadena_fin )<\/mark><\/em><\/strong>. Este m\u00e9todo, muy parecido al anterior, elimina solo la primera aparici\u00f3n de la cadena indicada como primer par\u00e1metro.<\/p>\n\n\n\n
    public class SustituirCadena {\n    public static void main(String[] args) {\n        String cadena1="Hola. Me llamo Eduardo. Tengo 35 a\u00f1os.";\n        String cadena2=cadena1.replaceFirst("o","-");\n        System.out.println(cadena2);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
    H-la. Me llamo Eduardo. Tengo 35 a\u00f1os.<\/code><\/pre><\/div>\n\n\n\n
    Ayud\u00e1ndonos de un bucle for, podemos reemplazar un determinado n\u00famero de apariciones sin que sean todas.<\/p>\n\n\n\n
    public class SustituirCadena {\n    public static void main(String[] args) {\n        String cadena1="Hola. Me llamo Eduardo. Tengo 35 a\u00f1os.";\n        for (int k=0;k<3;k=k+1){\n            cadena1=cadena1.replaceFirst("o", "-");\n        }\n        System.out.println(cadena1);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
    H-la. Me llam- Eduard-. Tengo 35 a\u00f1os.<\/code><\/pre><\/div>\n\n\n\n
    cadena.length( )<\/mark><\/em><\/strong> . Este m\u00e9todo nos facilita la longitud en caracteres que tiene un objeto String. Debemos de tener en cuenta que el caracter \\n (salto de l\u00ednea) o \\t (tabulador), se cuentan como un car\u00e1cter m\u00e1s.<\/p>\n\n\n\n
    public class SustituirCadena {\n    public static void main(String[] args) {\n        String cadena1="La playa\\nestaba\\tdesierta.";\n        int longitud=cadena1.length();\n        System.out.println(cadena1);\n        System.out.println("cadena1 tiene "+longitud+ " caracteres");\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
    La playa\nestaba  desierta.\ncadena1 tiene 25 caracteres<\/code><\/pre><\/div>\n\n\n\n
    cadena.substring ( )<\/mark><\/em><\/strong> . Si necesitamos obtener una porci\u00f3n de cadena a partir de otra, podemos utilizar este m\u00e9todo. Si el m\u00e9todo contiene dos argumentos, el primer indica la posici\u00f3n inicial de la subcadena y el segundo la posici\u00f3n final. Debemos de tener en cuenta que la primera posici\u00f3n de la cadena principal, es la posici\u00f3n 0. La \u00faltima ser\u00e1 la longitud de la cadena original -1. Si el m\u00e9todo solo contiene un argumento, la subcadena se forma desde la posici\u00f3n que indica ese argumento hasta el final de la cadena.<\/p>\n\n\n\n
    public class TrozosCadena {\n    public static void main(String[] args) {\n        String mi_cadena="El gobierno central acaba de convocar elecciones.";\n        int longitud=mi_cadena.length();\n        String cadena_1=mi_cadena.substring(0,5);\n        String cadena_2=mi_cadena.substring(6,22);\n        String cadena_3=mi_cadena.substring(24,longitud-5);\n        String cadena_4=mi_cadena.substring(longitud-5);\n        System.out.println(cadena_1);\n        System.out.println(cadena_2);\n        System.out.println(cadena_3);\n        System.out.println(cadena_4);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
    El go\nierno central ac\na de convocar elecci\nones.<\/code><\/pre><\/div>\n\n\n\n
    Como podemos observar, cadena_4 contiene los \u00faltimos 5 caracteres de la cadena principal. (longitud-5)<\/p>\n\n\n\n
    En java no existe una funci\u00f3n expl\u00edcita que nos facilite una lista con todos los caracteres que contiene un dato String. Sin embargo podemos crear una funci\u00f3n que cree dicha lista.<\/p>\n\n\n\n
    public class ListaCaracteres {\n    public static void main(String[] args) {\n        String mi_cadena="Hoy est\u00e1 lloviendo.";\n        List<Character> lista_caracteres = new ArrayList<>();\n        for (char c : mi_cadena.toCharArray()) {\n            lista_caracteres.add(c);\n        }\n\n        System.out.println(lista_caracteres);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
    [H, o, y,  , e, s, t, \u00e1,  , l, l, o, v, i, e, n, d, o, .]<\/code><\/pre><\/div>\n\n\n\n
    Si queremos contar las veces que aparece una cadena dentro de otra, deberemos recurrir a alg\u00fan truco, ya que no tiene un m\u00e9todo espec\u00edfico que nos lo facilite.<\/p>\n\n\n\n
    public class SustituirCadena {\n    \n    public static int apariciones(String cadena, String subcadena){\n        int contador=0;\n        int longitud=cadena.length();\n        int incluido;\n        for (int k=0; k<longitud;k=k+1){\n            incluido=(cadena.indexOf(subcadena));\n            if (incluido>-1){\n                cadena=cadena.replaceFirst(subcadena, "-");\n                contador+=1;\n            }\n        }\n        return contador;\n    }\n    public static void main(String[] args) {\n        String cadena1="Hola. Me llamo Eduardo. Tengo 35 a\u00f1os.";\n        String cadena2="o";\n        int repeticiones=apariciones(cadena1, cadena2);\n        System.out.println("\\""+cadena2+"\\""+" aparece "+repeticiones+" veces en "+"\\""+cadena1+"\\"");\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
    "o" aparece 5 veces en "Hola. Me llamo Eduardo. Tengo 35 a\u00f1os."<\/code><\/pre><\/div>\n\n\n\n
    cadena1.compareTo(cadena2)<\/mark><\/em><\/strong> Este m\u00e9todo 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\u00e9 antes ser\u00eda menor. Debemos de tener en cuenta que en ASCII las may\u00fasculas tienen menor valor que las min\u00edsculas, por lo tanto una min\u00fascula siempre ser\u00e1 mayor que su may\u00fascula.<\/p>\n\n\n\n
    public class Prueba2 {\n    public static void main(String[] args) {\n        String cadena1="ESta es mi cadena.";\n        String cadena2="Esta es mi cadena.";\n        if (cadena1.compareTo(cadena2) > 0){\n            System.out.println("La primera cadena es mayor.");\n        }\n        else{\n            System.out.println("La segunda cadena es mayor.");\n        }\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
    Resultado:\n\nLa segunda cadena es mayor.<\/code><\/pre><\/div>\n\n\n\n
    cadena1.equals (cadena2) <\/mark><\/em><\/strong> Este m\u00e9todo nos permite comparar si dos cadenas son iguales. Para este fin, no debemos de utilizar nunca el comparador \u00ab==\u00bb ya que al ser String un objeto, nos comparar\u00eda si dos String tienen la misma direcci\u00f3n de memoria (si los dos objetos son el mismo).<\/p>\n\n\n\n
    cadena1.equalsIgnoreCase (cadena2) <\/mark><\/em><\/strong>Este m\u00e9todo es muy parecido al anterior, pero en este caso trata las may\u00fasculas como el mismo valor que las min\u00fasculas.<\/p>\n\n\n\n
    public class CompararCadenas {\n    public static void main(String[] args) {\n        String cadena1="San Sebasti\u00e1n";\n        String cadena2="San Sebasti\u00e1n";\n        String cadena3="SAN SEBASTI\u00c1N";\n        String cadena4="Tambi\u00e9n San Sebasti\u00e1n";\n        if (cadena1.equals(cadena2) && cadena2.equalsIgnoreCase(cadena3)){\n            System.out.println("Las tres cadenas son iguales");\n        }\n        if (cadena2.equals(cadena4) || cadena3.equalsIgnoreCase(cadena4)){\n            System.out.println("Las cuatro cadenas son iguales");    \n        }\n        else{\n             System.out.println("Las cuatro cadenas NO son iguales");    \n        }\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
    Las tres cadenas son iguales\nLas cuatro cadenas NO son iguales<\/code><\/pre><\/div>\n\n\n\n
    Otros m\u00e9todos son:<\/p>\n\n\n\n
    .trim( )<\/mark><\/em><\/strong> Que elimina los espacios en blanco que se encuentren al principio y\/o al final del String.<\/p>\n\n\n\n
    .startsWith(\u00abcadena\u00bb)<\/mark><\/em><\/strong> Indica si el String comienza con la cadena que se pasa como par\u00e1metro.<\/p>\n\n\n\n
    .endsWith(\u00abcadena\u00bb) <\/mark><\/em><\/strong>Indica si el String finaliza con la cadena que se pasa como par\u00e1metro.<\/p>\n\n\n\n
    Inicio<\/a><\/td>Comandos Java<\/a><\/td>Bloques de c\u00f3digo.<\/a><\/td><\/tr>
    Comentar c\u00f3digo<\/a><\/td>System.out.print<\/a><\/td>Scanner (System.in)<\/a><\/td><\/tr>
    Captura de errores<\/a><\/td>String<\/a><\/td>Datos  Num\u00e9ricos<\/a><\/td><\/tr>
    Elementos aleatorios<\/a><\/td>Datos Fecha\/hora<\/a><\/td>Constantes<\/a><\/td><\/tr>
    Bucles for<\/a><\/td>Bucles while<\/a><\/td>Bloque if<\/a><\/td><\/tr>
    Arrays<\/a><\/td>ArrayList<\/a><\/td>switch case<\/a><\/td><\/tr>
    HashSet<\/a><\/td>HashMap<\/a><\/td>M\u00e9todos.<\/a><\/td><\/tr>
    Clases<\/a><\/td>Archivos<\/a><\/td>Entorno gr\u00e1fico Swing<\/a><\/td><\/tr>
    JFrame (Ventanas)<\/a><\/td>Componentes b\u00e1sicos.<\/a><\/td><\/td><\/tr><\/tbody><\/table><\/figure>\n","protected":false},"excerpt":{"rendered":"
    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\u00e1n las cadenas que necesitamos guardar. Una caracter\u00edstica de los objetos de la clase […]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":0,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"class_list":["post-91","page","type-page","status-publish","hentry"],"_links":{"self":[{"href":"https:\/\/java.nosoyia.es\/index.php?rest_route=\/wp\/v2\/pages\/91","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/java.nosoyia.es\/index.php?rest_route=\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/java.nosoyia.es\/index.php?rest_route=\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/java.nosoyia.es\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/java.nosoyia.es\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=91"}],"version-history":[{"count":19,"href":"https:\/\/java.nosoyia.es\/index.php?rest_route=\/wp\/v2\/pages\/91\/revisions"}],"predecessor-version":[{"id":224,"href":"https:\/\/java.nosoyia.es\/index.php?rest_route=\/wp\/v2\/pages\/91\/revisions\/224"}],"wp:attachment":[{"href":"https:\/\/java.nosoyia.es\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=91"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}