Comparando cadenas con Java

    Introducción

    En este tutorial, nos sumergiremos en la comparación de cadenas en Java.

    La comparación de cadenas es una operación común en todos los idiomas. La capacidad de comprobar si una cadena es igual a otra nos permite realizar comprobaciones fundamentales y alterar el flujo del código.

    El operador ‘==’

    los == El operador es uno de los primeros operadores aprendidos al sumergirse en un nuevo idioma, generalmente para comparar tipos de datos primitivos como ints.

    Echemos un vistazo a cómo podemos comparar dos String objetos con el == operador:

    String s1 = "Hello";
    String s2 = "Hello";
    String s3 = "World";
    
    System.out.println(s1 == s2);
    System.out.println(s2 == s3);
    

    Esto volvería:

    true
    false
    

    Se espera esto – s1 == s2 y s2 != s3. Sin embargo, reescribamos esto un poco en:

    String s1 = "Hello";
    String s2 = new String("Hello");
    
    System.out.println(s1 == s2);
    

    Esto devuelve:

    false
    

    Esto es porque el == El operador no comprueba la igualdad. Comprueba la identidad.

    En otras palabras, no compara Strings valor: compara referencias de objetos.

    los s1 es una variable de referencia al mismo objeto en la memoria que s2 referencias. Esto se debe a que String Pool no crea nuevos objetos si intentamos instanciar un String con un valor ya existente.

    Sin embargo, cuando instanciamos s2 con el new palabra clave, le decimos explícitamente a la JVM que queremos un nuevo objeto. Entonces, aunque tienen el mismo valor de cadena, el s1 y s2 las variables de referencia se refieren a diferentes objetos y, == el operador regresa false.

    método equals ()

    los equals() El método es típicamente el camino a seguir cuando se compara el contenido de Strings. Es sensible a mayúsculas y minúsculas y compara cada carácter de la Cadena con cada carácter de la otra Cadena:

    String s1 = "Hello";
    String s2 = new String("Hello");
    
    System.out.println(s1.equals(s2));
    

    Esto siempre volverá:

    true
    

    Si escribimos s1.equals(s2) o s2.equals(s1), el resultado sería el mismo.

    equals() es seguro para nulos, lo que significa que busca null valores para ti. Si comparamos un nonull valor a un null valor, lógicamente, el resultado es false:

    String s1 = "Hello";
    String s2 = null;
    
    System.out.println(s1.equals(s2));
    
    false
    

    Método equalsIgnoreCase ()

    Ya que equals() distingue entre mayúsculas y minúsculas, en casos como Hello y hello, volverá false. Estos realmente no son iguales si el caso es importante. Sin embargo, en algunas situaciones, el caso realmente no es importante. Solo desea verificar si los personajes en sí son los mismos, independientemente del caso.

    Para eso, usamos el equalsIgnoreCase() método:

    String s1 = "Hello";
    String s2 = "hello";
    
    System.out.println(s1.equals(s2));
    System.out.println(s1.equalsIgnoreCase(s2));
    

    Esto resulta en:

    false
    true
    

    CompareTo () Método

    los compareTo() El método funciona de una manera diferente al equals() método. los compareTo() El método comprueba el valor lexigográfico del String.

    Si comparamos s1 a s2 – Si s1El valor lexigográfico es mayor que s2, el método devolverá un valor positivo. Si es menor, el método devolverá un valor negativo. Si son iguales, el método volverá 0.

    Este método es muy útil si desea ordenar palabras en un orden lexicográfico:

    String s1 = "a";
    String s2 = "b";
    
    System.out.println(s1.compareTo(s2));
    

    Esto devuelve:

    -1
    

    Dado que la diferencia en los valores Unicode para a y b es solo 1. Echemos un vistazo a otro ejemplo:

    String s1 = "Hello World";
    String s2 = "hello world";
    
    System.out.println(s1.compareTo(s2));
    

    Esto resulta en:

    -32
    

    CompareToIgnoreCase () Método

    Del mismo modo, hay una versión de este método que no se preocupa por el caso de los personajes. Por ejemplo, las dos cadenas anteriores:

    String s1 = "Hello World";
    String s2 = "hello world";
    
    System.out.println(s1.compareToIgnoreCase(s2));
    

    Ahora volvería:

    0
    

    Método contentEquals ()

    los contentEquals() es un método relativamente poco utilizado, ya que parece que es el mismo que el equals() método.

    A saber, el equals() El método compara objetos por igualdad. La clase String anula el comportamiento predeterminado para comparar el contenido.

    los contentEquals() el método compara CharSequencesy StringBuffers. Con él, no tiene que convertir un StringBuffer en una String para comparar, el método se encargará de eso en sí mismo:

    String s1 = "aaaa";
    StringBuffer s2 = new StringBuffer("");
    
    for (int i = 0; i < 4; i++) {
        s2.append('a');
    }
    
    System.out.println(s1.contentEquals(s2));
    

    Con el método de antes, no puedes comparar un String a un StringBuffer. De esta manera puedes.

    Este código devuelve:

    true
    

    StringUtils – Apache Commons

    los Apache Commons library es una biblioteca robusta llena de innumerables métodos y clases de conveniencia.

    StringUtils es una clase auxiliar con un montón de operaciones relacionadas con String, incluidas las que se utilizan para comprobar la igualdad.

    StringUtils.equals ()

    los equals() método del StringUtils la clase funciona de la misma manera que esperaríamos que lo hiciera en función de nuestra familiaridad con el Object.equals() método:

    String s1 = "Hello";
    String s2 = new String("Hello");
    
    System.out.println(StringUtils.equals(s1, s2));
    System.out.println(StringUtils.equals(s1, null));
    System.out.println(StringUtils.equals(null, null));
    

    Esto volvería:

    true
    false
    true
    

    También cuenta con seguridad nula y verificaciones null valores. Comparando dos null los valores regresarán true.

    StringUtils.equalsIgnoreCase ()

    los equalsIgnoreCase() El método funciona de la misma manera:

    String s1 = "Hello";
    String s2 = new String("hello");
    
    System.out.println(StringUtils.equalsIgnoreCase(s1, s2));
    System.out.println(StringUtils.equalsIgnoreCase(s1, null));
    System.out.println(StringUtils.equalsIgnoreCase(null, null));
    

    Esto devuelve:

    true
    false
    true
    

    StringUtils.equalsAny ()

    los equalsAny() es el primer método que hace algo completamente nuevo. Acepta un String y un CharSequence vararg. Si alguno de los varargs se puede encontrar en el String, devuelve verdadero:

    System.out.println(StringUtils.equalsAny("Hello World", "Hello", "World"));
    System.out.println(StringUtils.equalsAny("Java is great!", "Java", "great!"));
    

    Esto volvería:

    true
    true
    

    Nota: El método distingue entre mayúsculas y minúsculas.

    StringUtils.equalsAnyIgnoreCase ()

    Por supuesto, también tenemos una variante del método que no distingue entre mayúsculas y minúsculas:

    System.out.println(StringUtils.equalsAnyIgnoreCase("Hello World", "HELLO", "world"));
    System.out.println(StringUtils.equalsAnyIgnoreCase("Java is great!", "JavA", "GrEat!"));
    

    Estos también regresarían:

    true
    true
    

    StringUtils.compare ()

    los compare() método del StringUtils la clase funciona de la misma manera que la compareTo() método del String clase. Sin embargo, este método de conveniencia es seguro para nulos a diferencia de la implementación oficial.

    Sigue la idea de un null valor lexicográficamente menor que un valor nonull valor, lo cual tiene mucho sentido.

    String s1 = "a";
    String s2 = "b";
    
    System.out.println(StringUtils.compare(s1, s2));
    

    Esto devuelve:

    -1
    

    StringUtils.compareIgnoreCase ()

    Finalmente, la versión que no distingue entre mayúsculas y minúsculas del método anterior: compareIgnoreCase(). Compara el valor lexicográfico de Strings, sin tener en cuenta el caso:

    String s1 = "A";
    String s2 = "a";
    
    System.out.println(StringUtils.compareIgnoreCase(s1, s2));
    

    Esto normalmente volvería -32 ya que las letras minúsculas están separadas de sus contrapartes en mayúsculas por 32 lugares. Sin embargo, esto regresa:

    0
    

    Conclusión

    La comparación de cadenas en Java, como en otros lenguajes, es una tarea común. Hay varias formas de hacerlo, tanto utilizando métodos integrados como la biblioteca Apache Commons.

    .

    Etiquetas:

    Deja una respuesta

    Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *