При сравнении массивов в Java, есть ли различия между следующими 2 операторами?
Object[] array1, array2;
array1.equals(array2);
Arrays.equals(array1, array2);
И если да, то что они?
При сравнении массивов в Java, есть ли различия между следующими 2 операторами?
Object[] array1, array2;
array1.equals(array2);
Arrays.equals(array1, array2);
И если да, то что они?
Ответы:
array1.equals(array2)
это то же самое array1 == array2
, что и тот же массив. Как отмечает @alf, это не то, чего ожидает большинство людей.
Arrays.equals(array1, array2)
сравнивает содержимое массивов.
Точно так же array.toString()
может быть не очень полезно и вам нужно использовать Arrays.toString(array)
.
Arrays.equals()
не работает должным образом для многомерных массивов, он сравнивает только элементы 1-го измерения на предмет равенства ссылок. Apache commons ArrayUtils.isEquals
работает с многомерными массивами.
Arrays.deepEquals(Object[], Object[])
.
.equals
он не сравнивает содержание, поэтому вам нужен этот метод.
Это печально известная проблема: .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-массивов.
Надеюсь, это поможет.
equals()
? Я думал, что это не переопределено от объекта.
Arrays.deepEquals
- это то, что someArray.equals
должно было быть сделано все время. (Связанный:. Objects.deepEquals
)
Загляните внутрь реализации двух методов, чтобы глубже понять их:
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
и , следовательно , сравнивать только возвращает истину , если сравнивать массив против себя.
С другой стороны, 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()
.
The Arrays.equals(array1, array2)
:
проверьте, содержат ли оба массива одинаковое количество элементов, и равны ли все соответствующие пары элементов в двух массивах.
The array1.equals(array2)
:
сравнить объект с другим объектом и вернуть true, только если ссылка на два объекта равна, как в Object.equals()
equals()
Массивов наследуется от Object
, так что не обращает внимания на содержание в arrrays, он только считает каждый массив равен самому себе.
Эти Arrays.equals()
методы действительно сравнить содержимое массивов. Есть перегрузки для всех примитивных типов, а для объектов используются собственные equals()
методы объектов .
import java.util.Arrays;
public class ArrayDemo {
public static void main(String[] args) {
// initializing three object arrays
Object[] array1 = new Object[] { 1, 123 };
Object[] array2 = new Object[] { 1, 123, 22, 4 };
Object[] array3 = new Object[] { 1, 123 };
// comparing array1 and array2
boolean retval=Arrays.equals(array1, array2);
System.out.println("array1 and array2 equal: " + retval);
System.out.println("array1 and array2 equal: " + array1.equals(array2));
// comparing array1 and array3
boolean retval2=Arrays.equals(array1, array3);
System.out.println("array1 and array3 equal: " + retval2);
System.out.println("array1 and array3 equal: " + array1.equals(array3));
}
}
Вот вывод:
array1 and array2 equal: false
array1 and array2 equal: false
array1 and array3 equal: true
array1 and array3 equal: false
Увидев такую проблему, я бы лично пошел по Arrays.equals(array1, array2)
вашему вопросу, чтобы избежать путаницы.