Java Player - ¿Como comparar cadenas? - ¿Como comparar dos String? - Diferencias entre equals() y == - ¿Como usar el compareTo()? - ¿Como usar el compareToIgnoreCase?

Bueno hace unas horas un compañero me hizo esta pregunta, generalmente doy por asentado que todo el mundo sabe las diferencias pero debido a que hay diferentes maneras voy aclararlas para todos los lectores.

Comparar Cadenas con ==

En java es muy común que se utilice el == comparar cadenas, pero el  == compara instancias, no cadenas.

Al hacer una comparación como la siguiente dará verdadero.

Pero al hacer:

El resultado es que las cadenas son desiguales.

Explicación:

Al hacer String cadena1 = "Prueba", el compilador ya conserva en memoria "Prueba" y al setearle a cadena2 = "Prueba", el compilador utiliza la misma instancia.

Pero en el caso de abajo que hacemos String cadena1 = new String("Prueba") y  String cadena2 = new String("Prueba") , el gran y santo NEW hace una nueva instancia del string "Prueba", por lo cual son instancias diferentes.

Comparar con .equals()

El método equals() lo poseen todos las clases ya que se heredan de la clase base Object, sirve especialmente para comprar una cadena de un objecto especifico, devolviendo un dato booleano.

Javadoc  Oficial de  J2SE

    /**

     * Compares this string to the specified object.  The result is {@code

     * true} if and only if the argument is not {@code null} and is a {@code

     * String} object that represents the same sequence of characters as this

     * object.

     *

     * @param  anObject

     *         The object to compare this {@code String} against

     *

     * @return  {@code true} if the given object represents a {@code String}

     *          equivalent to this string, {@code false} otherwise

     *

     * @see  #compareTo(String)

     * @see  #equalsIgnoreCase(String)

     */

El método equals() permite comparar cadenas.

El método equals() permite comparar cadenas literales.

Tengamos en cuenta que si hacemos esto: 

La cadena2 puede llegar a ser nula lo que provocaría un nullpointer excepción.

Comparar con el .equalsIgnoreCase()

Funciona igual que el equals(), pero ignora las mayúsculas.

Comparar con el .compareTo()

Este método sirve para comparar dos cadenas, devolviendo 0, positivo o negativo.

Javadoc

    /**

     * Compares two strings lexicographically.

     * The comparison is based on the Unicode value of each character in

     * the strings. The character sequence represented by this

     * <code>String</code> object is compared lexicographically to the

     * character sequence represented by the argument string. The result is

     * a negative integer if this <code>String</code> object

     * lexicographically precedes the argument string. The result is a

     * positive integer if this <code>String</code> object lexicographically

     * follows the argument string. The result is zero if the strings

     * are equal; <code>compareTo</code> returns <code>0</code> exactly when

     * the {@link #equals(Object)} method would return <code>true</code>.

     * <p>

     * This is the definition of lexicographic ordering. If two strings are

     * different, then either they have different characters at some index

     * that is a valid index for both strings, or their lengths are different,

     * or both. If they have different characters at one or more index

     * positions, let <i>k</i> be the smallest such index; then the string

     * whose character at position <i>k</i> has the smaller value, as

     * determined by using the &lt; operator, lexicographically precedes the

     * other string. In this case, <code>compareTo</code> returns the

     * difference of the two character values at position <code>k</code> in

     * the two string -- that is, the value:

     * <blockquote><pre>

     * this.charAt(k)-anotherString.charAt(k)

     * </pre></blockquote>

     * If there is no index position at which they differ, then the shorter

     * string lexicographically precedes the longer string. In this case,

     * <code>compareTo</code> returns the difference of the lengths of the

     * strings -- that is, the value:

     * <blockquote><pre>

     * this.length()-anotherString.length()

     * </pre></blockquote>

     *

     * @param   anotherString   the <code>String</code> to be compared.

     * @return  the value <code>0</code> if the argument string is equal to

     *          this string; a value less than <code>0</code> if this string

     *          is lexicographically less than the string argument; and a

     *          value greater than <code>0</code> if this string is

     *          lexicographically greater than the string argument.

     */

Devuelve cero (0) cuando las dos cadenas son iguales.

Devuelve positivo si la cadena pasada por parámetro se ordena antes.

Devuelve negativo si la cadena pasada por parámetro se ordena después.

Hay que tener en cuenta que el compareTo() compra según estén ordenados los caracteres en la tabla de caracteres que usemos ya que una  A mayúscula va antes que una minúscula y esta va antes que una á (a con acento).

La cadena2 puede llegar a ser nula lo que provocaría un nullpointer excepción.

Comparar con compareToIgnoreCase().

Este método sirve para comparar dos cadenas, devolviendo 0, positivo o negativo.

Funciona casi igual que el compareTo() pero se diferencia que ignora las mayúsculas y minúsculas.

Bueno gente espero que les allá resultado útil cualquier cosa me avisan.