---
title: 'Arrays mit Arrays.equals(…) und Arrays.deepEquals(…) vergleichen'
url: 'https://www.tutego.de/blog/javainsel/2017/02/arrays-mit-arrays-equals-und-arrays-deepequals-vergleichen'
markdown: 'https://www.tutego.de/blog/javainsel/2017/02/arrays-mit-arrays-equals-und-arrays-deepequals-vergleichen.md'
date: '2017-02-24'
description: 'Die statischen Methoden Arrays.equals(…) vergleichen, ob zwei Arrays die gleichen Inhalte besitzen; dazu ist die überladene Methode für alle wichtigen Typen definiert. Wenn zwei Arrays tatsächlich die gleichen Inhalte besitzen, ist die Rückgabe der Methode true, sonst false. Natürlich müssen beide …'
taxonomy:
  category:
    - Allgemein
---

# Arrays mit Arrays.equals(…) und Arrays.deepEquals(…) vergleichen

![Illustration einer tropischen Insel mit Palmen und einem hohen Berg](https://www.tutego.de/blog/javainsel/user/themes/tutego/images/insel-cover.jpg)# Java Blog für Programmierer

[Java Blog für Programmierer](https://www.tutego.de/blog/javainsel/)

## Arrays mit Arrays.equals(…) und Arrays.deepEquals(…) vergleichen

24.02.2017 · [Christian Ullenboom](https://www.tutego.de/blog/javainsel/author/admin/)

Die statischen Methoden `Arrays.equals(…)` vergleichen, ob zwei `Arrays` die gleichen Inhalte besitzen; dazu ist die überladene Methode für alle wichtigen Typen definiert. Wenn zwei `Arrays` tatsächlich die gleichen Inhalte besitzen, ist die Rückgabe der Methode `true`, sonst `false`. Natürlich müssen beide `Arrays` schon die gleiche Anzahl von Elementen besitzen, sonst ist der Test sofort vorbei und das Ergebnis `false`. Im Fall von Objekt-`Arrays` nutzt `Arrays.equals(…)` nicht die Identitätsprüfung per ==, sondern die Gleichheit per `equals(…)`.

Beispiel

Vergleiche drei `Arrays`:

```java
int[] array1 = { 1, 2, 3, 4 };

int[] array2 = { 1, 2, 3, 4 };

int[] array3 = { 9, 9, 2, 3, 9 };

System.out.println( Arrays.equals( array1, array2 ) );              // true

System.out.println( Arrays.equals( array2, 1, 3, array3, 2, 4 ) );  // true
```

Ein Vergleich von Teil-`Arrays` ist erst in Java 9 hinzugekommen.

Bei unterreferenzierten `Arrays` betrachtet `Arrays.equals(…)` das innere Array als einen Objektverweis und vergleicht es auch mit `equals(…)` – was jedoch bedeutet, dass nicht identische, aber mit gleichen Elementen referenzierte innere `Arrays` als ungleich betrachtet werden. Die statische Methode `deepEquals(…)` bezieht auch unterreferenzierte `Arrays` in den Vergleich ein.

Beispiel

Unterschied zwischen `equals(…)` und `deepEquals(…)`:

```java
int[][] a1 = { { 0, 1 }, { 1, 0 } };
 int[][] a2 = { { 0, 1 }, { 1, 0 } };
 System.out.println( Arrays.equals( a1, a2 ) );     // false
 System.out.println( Arrays.deepEquals( a1, a2 ) ); // true
 System.out.println( a1[0] );                       // zum Beispiel [I@10b62c9
 System.out.println( a2[0] );                       // zum Beispiel [I@82ba41
```

Dass die Methoden unterschiedlich arbeiten, zeigen die beiden letzten Konsolenausgaben: Die von a1 und a2 unterreferenzierten `Arrays` enthalten die gleichen Elemente, sind aber zwei unterschiedliche Objekte, also nicht identisch.

Hinweis

`deepEquals(…)` vergleicht auch eindimensionale `Arrays`:

```java
Object[] b1 = { "1", "2", "3" };
 Object[] b2 = { "1", "2", "3" };
 System.out.println( Arrays.deepEquals( b1, b2 ) ); // true
```

class `java.util.Arrays`

- staticbooleanequals(XXX\[\]a,XXX\[\]a2) Vergleicht zwei Arrays gleichen Typs und liefert true, wenn die Arrays gleich groß und Elemente paarweise gleich sind. XXX steht stellvertretend für boolean, byte, char, int, short, long, double, float.
- staticbooleanequals(**XXX**\[\] a, int `aFromIndex`, int `aToIndex`, **XXX**\[\] b, int `bFromIndex`, int `bToIndex`) Vergleicht zwei Arrays, bleibt jedoch in den gewählten Ausschnitten. Neue Methoden in Java 9.
- staticbooleanequals(`Object`\[\]a,`Object`\[\]a2) Vergleicht zwei Arrays mit Objektverweisen. Ein Objekt-Array darf null enthalten; dann gilt für die Gleichheit e1null ? e2null : equals(e2).
- `staticbooleandeepEquals`(`Object`\[\]a1,`Object`\[\]a2) Liefert true, wenn die beiden Arrays ebenso wie alle Unter-Arrays – rekursiv im Fall von Unter-Objekt-Arrays – gleich sind.

Kategorien: [Allgemein](https://www.tutego.de/blog/javainsel/category/allgemein/)

[← Alle Beiträge](https://www.tutego.de/blog/javainsel/)

---

## Navigation

- Previous: [Die Schnittstelle Checksum](https://www.tutego.de/blog/javainsel/2017/02/die-schnittstelle-checksum.md)
- Next: [Objekt-Arrays mit Arrays.equals(…) und Arrays.deepEquals(…) vergleichen](https://www.tutego.de/blog/javainsel/2017/02/objekt-arrays-mit-arrays-equals-und-arrays-deepequals-vergleichen.md)