Java Arrays.equals () renvoie false pour les tableaux bidimensionnels

Question

J'étais juste curieux de savoir pourquoi les Tableaux.equals(double[][], double[][]) return false? alors qu'en fait, les matrices ont le même nombre d'éléments et de chaque élément est la même?

Par exemple, j'ai effectué le test suivant.

double[][] a,  b;
int size =5;

a=new double[size][size];
b=new double[size][size];

for( int i = 0; i < size; i++ )
    for( int j = 0; j < size; j++ ) {
        a[i][j]=1.0;
        b[i][j]=1.0;
    }

if(Arrays.equals(a, b))
    System.out.println("Equal");
else
    System.out.println("Not-equal");

Renvoie la valeur false et imprime "Pas équitable".

d'autre part, si j'ai quelque chose comme ceci:

double[] a,  b;
int size =5;

a=new double[size];
b=new double[size];

for( int i = 0; i < size; i++ ){
    a[i]=1.0;
    b[i]=1.0;
} 

if(Arrays.equals(a, b))
    System.out.println("Equal");
else
    System.out.println("Not-equal");

retourne true et imprime "l'Égalité". La méthode de travail uniquement avec des dimensions? si oui, est-il quelque chose de similaire pour les multi-dimensions des tableaux en Java?

Answer 1

Utiliser deepEquals(Object[], Object[]).

Les retours true si les deux valeurs des tableaux sont profondément égaux l'un à l'autre.

Depuis un int[] est instanceof Object, une int[][] est instanceof Object[].

---

Quant à pourquoi Arrays.equals n'a pas de "travail" pour les deux dimensions des tableaux, il peut être expliquée étape par étape, comme suit:

Pour les tableaux, equals est définie en termes d'identité de l'objet

System.out.println(
    (new int[] {1,2}).equals(new int[] {1,2})
); // prints "false"

C'est parce que les tableaux à hériter de leur equals de leur commune superclasse, Object.

Souvent nous voulons vraiment la valeur de l'égalité pour les tableaux, bien sûr, c'est pourquoi java.util.Arrays fournit l' static méthode utilitaire equals(int[], int[]).

System.out.println(
    java.util.Arrays.equals(
        new int[] {1,2},
        new int[] {1,2}
    )
); // prints "true"

Tableau de tableaux en Java

• Un int[] est instanceof Object
• Un int[][] est instanceof Object[]
• Un int[][] est PAS un instanceof int[]

Java n'a pas vraiment deux dimensions des tableaux. Il n'a même pas vraiment de tableaux multidimensionnels. Java a tableau de tableaux.

java.util.Arrays.equals est "superficielle"

Maintenant, considérons cet extrait:

System.out.println(
    java.util.Arrays.equals(
        new int[][] {
            { 1 },
            { 2, 3 },
        },
        new int[][] {
            { 1 },
            { 2, 3 },
        }
    )
); // prints "false"

Voici les faits:

• Chaque argument est un Object[]
  • L'élément à l'indice 0 est une int[] { 1 }
  • L'élément à l'indice 1 est une int[] { 2, 3 }.
• Il y a deux Object[] cas
• Il y a quatre int[] cas

Il devrait être clair à partir du point précédent que cela invoque Arrays.equals(Object[], Object[]) de surcharge. À partir de l'API:

Les retours true si les deux valeurs de tableaux de Objects sont égaux l'un à l'autre. Les deux tableaux sont considérées equal 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. Deux objets e1 et e2 sont considérées comme égales si (e1==null ? e2==null : e1.equals(e2)).

Maintenant, il devrait être clair pourquoi l'extrait ci-dessus imprime "false"; c'est parce que les éléments de l' Object[] tableaux ne sont pas égaux selon la définition ci-dessus (depuis un int[] a son equals défini par l'identité de l'objet).

java.util.Arrays.deepEquals est "profond"

En revanche, voici ce qu' Arrays.deepEquals(Object[], Object[]) n'est:

Les retours true si les deux valeurs des tableaux sont profondément égaux l'un à l'autre. Contrairement à l' equals(Object[],Object[]) méthode, cette méthode est appropriée pour une utilisation avec des tableaux imbriqués de profondeur arbitraire.

System.out.println(
    java.util.Arrays.deepEquals(
        new int[][] {
            { 1 },
            { 2, 3 },
        },
        new int[][] {
            { 1 },
            { 2, 3 },
        }
    )
); // prints "true"

---

Sur Arrays.toString et Arrays.deepToString

Il est intéressant de noter l'analogie entre ces deux méthodes et ce que nous avons discuté jusqu'à présent en ce qui concerne les tableaux imbriqués.

System.out.println(
    java.util.Arrays.toString(
        new int[][] {
            { 1 },
            { 2, 3 },
        }
    )
); // prints "[[I@187aeca, [I@e48e1b]"

System.out.println(
    java.util.Arrays.deepToString(
        new int[][] {
            { 1 },
            { 2, 3 },
        }
    )
); // prints "[[1], [2, 3]]"

Encore une fois, le raisonnement est similaire: Arrays.toString(Object[]) traite chaque élément comme un Object, et il suffit d'appeler son toString() méthode. Les tableaux héritent de son toString() de leur commune superclasse Object.

Si vous souhaitez java.util.Arrays à envisager de tableaux imbriqués, vous devez utiliser deepToString, tout comme vous avez besoin d'utiliser deepEquals.

Answer 2

java n'a pas réellement de tableaux multidimensionnels. Au lieu de cela, il n'a qu'un tableau unidimensionnel et les tableaux multi d seront des tableaux de ces tableaux 1d. String.equals () ne peut être exécuté que pour les tableaux de base à bloc unique et, par conséquent, il ne fonctionne pas pour les tableaux multidimensionnels.