classe - java sort array object




est égal à vs Arrays.equals en Java (6)

C'est un problème infâme: .equals() pour les tableaux est très endommagé, mais ne l'utilisez jamais.

Cela dit, ce n'est pas "cassé" comme dans "quelqu'un l'a fait d'une manière vraiment mauvaise" - c'est juste de faire ce qui est défini et non ce qui est habituellement attendu. Donc pour les puristes: c'est parfaitement bien, et ça veut dire aussi, ne l'utilisez pas, jamais.

Maintenant, le comportement attendu pour les equals est de comparer les données. Le comportement par défaut est de comparer l'identité, car l' Object n'a aucune donnée (pour les puristes: oui c'est le cas, mais ce n'est pas le point); l'hypothèse est, si vous avez besoin d' equals dans les sous-classes, vous l'implémenterez. Dans les tableaux, il n'y a pas de mise en œuvre pour vous, vous n'êtes donc pas censé l'utiliser.

Donc, la différence est, Arrays.equals(array1, array2) fonctionne comme prévu (ie compare le contenu), array1.equals(array2) revient à l'implémentation Object.equals , qui à son tour compare l'identité, et donc mieux remplacé par == (pour les puristes: oui je sais à propos de null ).

Le problème est que même Arrays.equals(array1, array2) vous mordra si les éléments du tableau Arrays.equals(array1, array2) pas correctement. C'est une affirmation très naïve, je sais, mais il y a un cas très peu important: envisager un tableau 2D.

Le tableau 2D en Java est un tableau de tableaux, et les équivalents des tableaux sont brisés (ou inutiles si vous préférez), donc Arrays.equals(array1, array2) ne fonctionnera pas comme vous le souhaitez sur les tableaux 2D.

J'espère que cela pourra aider.

Lorsque vous comparez des tableaux dans Java, existe-t-il des différences entre les deux instructions suivantes?

array1.equals(array2);
Arrays.equals(array1, array2);

Et si oui, que sont-ils?


L' equals() des tableaux est hérité de Object , donc il ne regarde pas le contenu des arrrays, il considère seulement chaque tableau comme égal à lui-même.

Les méthodes Arrays.equals() comparent le contenu des tableaux. Il y a des surcharges pour tous les types primitifs, et celle pour les objets utilise les propres méthodes equals() des objets.


Les tableaux héritent de equals() de Object et donc compare seulement renvoie true si l'on compare un tableau par rapport à lui-même.

D'autre part, Arrays.equals compare les éléments des tableaux.

Cet extrait élucide la différence:

Object o1 = new Object();
Object o2 = new Object();
Object[] a1 = { o1, o2 };
Object[] a2 = { o1, o2 };
System.out.println(a1.equals(a2)); // prints false
System.out.println(Arrays.equals(a1, a2)); // prints true

Voir aussi Arrays.equals() . Une autre méthode statique peut également être intéressante: Arrays.deepEquals() .


Regardez à l'intérieur de la mise en œuvre des deux méthodes pour les comprendre profondément:

array1.equals(array2);
/**
 * Indicates whether some other object is "equal to" this one.
 * <p>
 * The {@code equals} method implements an equivalence relation
 * on non-null object references:
 * <ul>
 * <li>It is <i>reflexive</i>: for any non-null reference value
 *     {@code x}, {@code x.equals(x)} should return
 *     {@code true}.
 * <li>It is <i>symmetric</i>: for any non-null reference values
 *     {@code x} and {@code y}, {@code x.equals(y)}
 *     should return {@code true} if and only if
 *     {@code y.equals(x)} returns {@code true}.
 * <li>It is <i>transitive</i>: for any non-null reference values
 *     {@code x}, {@code y}, and {@code z}, if
 *     {@code x.equals(y)} returns {@code true} and
 *     {@code y.equals(z)} returns {@code true}, then
 *     {@code x.equals(z)} should return {@code true}.
 * <li>It is <i>consistent</i>: for any non-null reference values
 *     {@code x} and {@code y}, multiple invocations of
 *     {@code x.equals(y)} consistently return {@code true}
 *     or consistently return {@code false}, provided no
 *     information used in {@code equals} comparisons on the
 *     objects is modified.
 * <li>For any non-null reference value {@code x},
 *     {@code x.equals(null)} should return {@code false}.
 * </ul>
 * <p>
 * The {@code equals} method for class {@code Object} implements
 * the most discriminating possible equivalence relation on objects;
 * that is, for any non-null reference values {@code x} and
 * {@code y}, this method returns {@code true} if and only
 * if {@code x} and {@code y} refer to the same object
 * ({@code x == y} has the value {@code true}).
 * <p>
 * Note that it is generally necessary to override the {@code hashCode}
 * method whenever this method is overridden, so as to maintain the
 * general contract for the {@code hashCode} method, which states
 * that equal objects must have equal hash codes.
 *
 * @param   obj   the reference object with which to compare.
 * @return  {@code true} if this object is the same as the obj
 *          argument; {@code false} otherwise.
 * @see     #hashCode()
 * @see     java.util.HashMap
 */
public boolean equals(Object obj) {
    return (this == obj);
}

tandis que:

Arrays.equals(array1, array2);
/**
 * Returns <tt>true</tt> if the two specified arrays of Objects are
 * <i>equal</i> to one another.  The two arrays are considered equal if
 * both arrays contain the same number of elements, and all corresponding
 * pairs of elements in the two arrays are equal.  Two objects <tt>e1</tt>
 * and <tt>e2</tt> are considered <i>equal</i> if <tt>(e1==null ? e2==null
 * : e1.equals(e2))</tt>.  In other words, the two arrays are equal if
 * they contain the same elements in the same order.  Also, two array
 * references are considered equal if both are <tt>null</tt>.<p>
 *
 * @param a one array to be tested for equality
 * @param a2 the other array to be tested for equality
 * @return <tt>true</tt> if the two arrays are equal
 */
public static boolean equals(Object[] a, Object[] a2) {
    if (a==a2)
        return true;
    if (a==null || a2==null)
        return false;

    int length = a.length;
    if (a2.length != length)
        return false;

    for (int i=0; i<length; i++) {
        Object o1 = a[i];
        Object o2 = a2[i];
        if (!(o1==null ? o2==null : o1.equals(o2)))
            return false;
    }

    return true;
}

array1.equals(array2) est le même que array1 == array2 , c'est-à-dire est-ce le même tableau. Comme le souligne @alf, ce n'est pas ce à quoi la plupart des gens s'attendent.

Arrays.equals(array1, array2) compare le contenu des tableaux.

De même array.toString() peut ne pas être très utile et vous devez utiliser Arrays.toString(array) .


import java.util.Arrays;
public class ArrayDemo {
   public static void main(String[] args) {
   // initiliazing three object arrays
   Object[] arr1 = new Object[] { 1, 123 };
   Object[] arr2 = new Object[] { 1, 123, 22, 4 };
   Object[] arr3 = new Object[] { 1, 123 };

   // comparing arr1 and arr2
   boolean retval=Arrays.equals(arr1, arr2);
   System.out.println("arr1 and arr2 equal: " + retval);
   System.out.println("arr1 and arr2 equal: " + arr1.equals(arr2));

   // comparing arr1 and arr3
   boolean retval2=Arrays.equals(arr1, arr3);
   System.out.println("arr1 and arr3 equal: " + retval2);
   System.out.println("arr1 and arr2 equal: " + arr1.equals(arr3));

   }
}

Voici la sortie:

    arr1 and arr2 equal: false
    arr1 and arr2 equal: false

    arr1 and arr3 equal: true
    arr1 and arr3 equal: false

Voyant ce genre de problème je voudrais personnellement aller pour Arrays.equals(array1, array2) selon votre question pour éviter toute confusion.





equality