Равно против Arrays.equals в Java
При сравнении массивов в Java, есть ли различия между следующими 2 операторами?
array1.equals(array2);
Arrays.equals(array1, array2);
И если да, то что они?
9 ответов
array1.equals(array2) такой же как array1 == array2т.е. это один и тот же массив. Как отмечает @alf, это не то, чего ожидает большинство людей.
Arrays.equals(array1, array2) сравнивает содержимое массивов.
так же array.toString() может быть не очень полезно и вам нужно использовать Arrays.toString(array),
Это печально известная проблема: .equals() потому что массивы сильно разбиты, просто не используйте их, никогда.
Тем не менее, он не "сломан", как в "кто-то сделал это действительно неправильно" - он просто делает то, что определено, а не то, что обычно ожидается. Так что для пуристов: это совершенно нормально, а это также означает, что не используйте его никогда.
Теперь ожидаемое поведение для equals это сравнить данные. Поведение по умолчанию - сравнивать идентичность, так как Object не имеет данных (для пуристов: да, есть, но не в этом суть); Предположение есть, если вам нужно equals в подклассах вы будете реализовывать это. В массивах для вас нет реализации, поэтому вы не должны ее использовать.
Так что разница в том, Arrays.equals(array1, array2) работает так, как вы ожидаете (т.е. сравнивает контент), array1.equals(array2) возвращается к Object.equals реализация, которая в свою очередь сравнивает идентичность, и, следовательно, лучше заменить == (для пуристов: да, я знаю о null).
Проблема даже Arrays.equals(array1, array2) будет сильно кусаться, если элементы массива не реализуются equals должным образом. Это очень наивное утверждение, я знаю, но есть очень важный, менее очевидный случай: рассмотрим двумерный массив.
2D массив в Java представляет собой массив массивов и массивов equals сломан (или бесполезен, если вы предпочитаете), поэтому Arrays.equals(array1, array2) не будет работать, как вы ожидаете, на 2D-массивах.
Надеюсь, это поможет.
Посмотрите на реализацию двух методов, чтобы глубже понять их:
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);
}
в то время как:
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;
}
Вздох. Еще в 70-х годах я был "системным программистом" (sysadmin) для системы IBM 370, а мой работодатель был членом группы пользователей IBM SHARE. Иногда может случиться так, что кто-то представит APAR (отчет об ошибке) о непредвиденном поведении какой-либо команды CMS, и IBM ответит NOTABUG: команда выполняет то, для чего она предназначена (и что говорится в документации).
ПОДЕЛИТЬСЯ придумала счетчик к этому: ПЛОХОЙ - Сломанный как Разработано. Я думаю, что это может относиться к этой реализации равных для массивов.
В реализации Object.equals нет ничего плохого. Объект не имеет элементов данных, поэтому сравнивать не с чем. Два "Объекта" равны тогда и только тогда, когда они фактически являются одним и тем же Объектом (внутренне, с одинаковым адресом и длиной).
Но эта логика не относится к массивам. Массивы имеют данные, и вы ожидаете, что сравнение (через равно) сравнит данные. В идеале, способ Arrays.deepEquals, но, по крайней мере, способ Arrays.equals (поверхностное сравнение элементов).
Таким образом, проблема в том, что массив (как встроенный объект) не переопределяет Object.equals. String (как именованный класс) переопределяет Object.equals и дает ожидаемый результат.
Другие ответы правильны: [...]. Equals([....]) просто сравнивает указатели, а не содержимое. Может быть, когда-нибудь кто-нибудь исправит это. А может и нет: сколько существующих программ сломалось бы, если бы [...]. Фактически сравнивали элементы? Не много, я подозреваю, но больше нуля.
Массивы наследуют equals() от Object и, следовательно, сравнение возвращает только true, если сравнивать массив с самим собой.
С другой стороны, Arrays.equals сравнивает элементы массивов.
Этот фрагмент объясняет разницу:
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
Смотрите также Arrays.equals(), Другой статический метод также может представлять интерес: Arrays.deepEquals(),
Arrays.equals(array1, array2):
проверьте, содержат ли оба массива одинаковое количество элементов, и равны ли все соответствующие пары элементов в двух массивах.
array1.equals(array2):
сравнивать объект с другим объектом и возвращать true только в том случае, если ссылка на два объекта равна, как в Object.equals()
equals() массивов наследуется от Object, поэтому он не смотрит на содержимое массивов, он только считает каждый массив равным самому себе.
Arrays.equals() методы сравнивают содержимое массивов. Существуют перегрузки для всех примитивных типов, а для объектов используются собственные объекты. equals() методы.
Я думаю, что Objects.deepEquals(Obj1,Obj2) является лучшим унифицированным решением здесь, если Obj1 и Obj2 являются двумя массивами int, он вызовет для вас метод Arrays.deepEquals0(a, b). Если вы не сравниваете строки, будет использоваться традиционный метод ".equals"("=="), поэтому он также очень полезен при сравнении строк.
Он будет охватывать такие обычные случаи использования, как масло, не нужно помнить, когда использовать ().equals(), Arrays.equals, (String a).equals((String b)) или что-то еще.
Временная сложность этой операции Objects.deepEquals будет O(n).
public static boolean deepEquals(Object a, Object b) {
if (a == b)
return true;
else if (a == null || b == null)
return false;
else
return Arrays.deepEquals0(a, b);
}
Общие способы использования: Сравните массив int, whooo:
int[] num1 = { 1, 2, 3, 4 };
int[] num2 = { 1, 2, 3, 4 };
System.out.println(Objects.deepEquals(num1, num2));
Также можно сравнивать 2D-массивы, так что хорошо:
int[][] nums1 = { { 1, 2 }, { 2, 3 }, { 3, 4 } };
int[][] nums2 = { { 1, 2 }, { 2, 3 }, { 3, 4 } };
System.out.println(Objects.deepEquals(nums1, nums2));
Сравните строки, даже больше:
String s1 = "sasfd!";
String s2 = "sasfd" + "!";
System.out.println(Objects.deepEquals(s1, s2));
Я ЛЮБЛЮ УНИВЕРСАЛЬНО ПРИМЕНИМЫЕ ПОДХОДЫ
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));
}
}
Вот вывод:
arr1 and arr2 equal: false
arr1 and arr2 equal: false
arr1 and arr3 equal: true
arr1 and arr3 equal: false
Видя такую проблему, я бы лично пошел на Arrays.equals(array1, array2) согласно вашему вопросу, чтобы избежать путаницы.