est égale à vs Tableaux.est égal à Java
Lorsque l'on compare les tableaux en Java, sont-il des différences entre les 2 états?
array1.equals(array2);
Arrays.equals(array1, array2);
Et si oui, quels sont-ils?
- Jetez un oeil aussi à java.util.Les tableaux de.deepEquals(Object[] a1, Object[] a2)
Vous devez vous connecter pour publier un commentaire.
array1.equals(array2)
est le même quearray1 == array2
, c'est à dire est-il le même tableau. Comme @alf points, c'est pas ce que 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 avez besoin d'utiliserArrays.toString(array)
.Arrays.equals()
ne fonctionne pas comme prévu pour les tableaux multidimensionnels, il compare uniquement les éléments de la 1ère dimension de référence de l'égalité. Apache commonsArrayUtils.isEquals
travaille avec des tableaux multidimensionnels.Arrays.deepEquals(Object[], Object[])
..equals
il ne se compare pas le contenu qui est pourquoi vous avez besoin de cette méthode.HashSet<int[]>
est inutile.int[]
C'est un infâme problème:
.equals()
pour les tableaux est sévèrement endommagé, ne l'utilisez pas, jamais.Cela dit, ce n'est pas "cassé" comme dans "quelqu'un a fait un très mauvais sens", c'est juste faire ce qui est défini et non pas ce qui est généralement attendu. Donc pour les puristes: il est parfaitement bien, et qui signifie aussi, ne l'utilisez pas, jamais.
Maintenant le comportement attendu pour
equals
est de comparer les données. Le comportement par défaut est de comparer l'identité, commeObject
ne dispose pas de données (pour les puristes: oui il a, mais il n'est pas le point); hypothèse est, si vous avez besoin d'equals
dans les sous-classes, vous allez la mettre en œuvre. Dans les tableaux, il n'y a pas de mise en œuvre pour vous, si vous n'êtes pas censé l'utiliser.Donc, la différence est,
Arrays.equals(array1, array2)
œuvres comme vous vous attendez (c'est à dire compare le contenu),array1.equals(array2)
revient àObject.equals
mise en œuvre, qui compare l'identité, et donc de mieux remplacé par==
(pour les puristes: oui, je sais à propos denull
).Problème est que, même
Arrays.equals(array1, array2)
va vous mordre dur si des éléments de la matrice de ne pas mettre en œuvreequals
correctement. C'est une très naïve déclaration, je sais, mais il y a une très importante moins-que-cas évident: considérons un tableau 2D.Tableau 2D en Java, un tableau de tableaux et matrices
equals
est cassé (ou rien si vous préférez), de sorteArrays.equals(array1, array2)
ne fonctionnera pas comme prévu sur 2D tableaux.Espère que ça aide.
equals()
? J'ai pensé que ce n'est pas remplacée à partir de l'Objet.Arrays.deepEquals
--- c'est ce quesomeArray.equals
doit avoir fait tout le long. (Connexe:Objects.deepEquals
.)Regarder à l'intérieur de la mise en œuvre des deux méthodes pour comprendre profondément:
tout:
Soupir. Retour dans les années 70, j'étais le "système programmeur" (sysadmin) pour un IBM 370 système, et mon employeur a été membre de la IBM groupe d'utilisateurs de PARTAGER. Il serait parfois se produire thatsomebody soumis un RAPPORT (rapport de bug) sur un comportement inattendu de certains CMS de commande, et IBM allait répondre NOTABUG: la commande fait ce qu'il a été conçu pour faire (et ce que dit la documentation).
PARTAGER venu avec un compteur à ceci: MAUVAIS, mal Conçue. Je pense que cela pourrait s'appliquer à cette mise en œuvre d'égal à égal pour les tableaux.
Il n'y a rien de mal avec la mise en œuvre de l'Objet.d'égal à égal. L'objet n'a pas de membres de données, donc il n'y a rien à comparer. Deux "Objet"s sont égaux si et seulement si elles le sont, en fait, le même Objet (en interne, à la même adresse et la longueur).
Mais cette logique ne s'applique pas aux tableaux. Matrices de données, et vous vous attendez à de la comparaison (via égale) pour comparer les données. Idéalement, la manière dont les Tableaux.deepEquals fait, mais au moins la manière dont les Tableaux.est égal à t (peu de la comparaison des éléments).
Donc, le problème est que array (comme un objet intégré) ne pas remplacer l'Objet.d'égal à égal. Chaîne de caractères (comme un nom de classe) ne remplacer l'Objet.d'égal à égal et donner le résultat que vous attendez.
D'autres réponses données sont correctes: [...].est égal à([....]) compare simplement les pointeurs et non le contenu. Peut-être un jour quelqu'un va corriger cela. Ou peut-être pas: combien de programmes existants serait briser si [...].est égal à fait contre les éléments? Pas beaucoup, je le soupçonne, mais plus que zéro.
Tableaux hériter
equals()
deObject
et donc de comparer uniquement retourne true si la comparaison d'un tableau à l'encontre de lui-même.D'autre part,
Arrays.equals
compare les éléments des tableaux.Cet extrait met en lumière la différence:
Voir aussi
Tableaux.equals()
. Une autre méthode statique, il peut également être d'intérêt:Tableaux.deepEquals()
.La
Arrays.equals(array1, array2)
:vérifier si les deux tableaux contiennent le même nombre d'éléments, et toutes les paires correspondantes des éléments dans les deux matrices sont égales.
La
array1.equals(array2)
:comparer l'objet à un autre objet et renvoie true uniquement si la référence de l'objet de deux sont égaux comme dans le
Object.equals()
La
equals()
de tableaux est hérité deObject
, de sorte qu'il ne regarde pas le contenu de la arrrays, il ne considère que chaque tableau égale à elle-même.La
Arrays.equals()
méthodes ne comparer les tableaux de contenu. Il y a des surcharges pour tous les types primitifs, et l'un pour les objets utilise les objets propresequals()
méthodes.Voici le résultat:
De voir ce genre de problème, je serais personnellement aller pour
Arrays.equals(array1, array2)
que par votre question pour éviter toute confusion.