Сравнивая два значения в Java, как вы проверяете, эквивалентны ли оба, тип и значение?
Я знаю, что в JavaScript === может быть использовано для этого, поэтому я попробовал это на Java, но это не сработало.
Я знаю, что это простой вопрос, но я попытался найти его и не смог выяснить, что это было.
TL; DR
В Java нет такого оператора сравнения: ===, но == или equals
Более длинное объяснение
В слабо типизированных языках, таких как JavaScript, вы можете использовать оператор строгого сравнения (===), потому что язык позволяет сравнивать переменные разных типов.
Например, в JavaScript вы не получите ошибку компиляции, если сделаете это:
var x = 10;
var y = 'foo';
console.log(x == y); // false
И это полезно, когда вы хотите сравнить переменные, которые могут содержать значения, которые "равны", но могут быть разных типов.
Например
var x = 10;
var y = '10';
console.log(x == y) // true
console.log(x === y) // false
В строго типизированных языках, таких как Java, вам не нужно использовать оператор строгого сравнения, потому что язык уже "обрабатывает" сравнение типов.
Например:
int x = 10;
String y = "10";
System.out.println("10" == y); // true
System.out.println(x == y); // compile error : Incompatible operand types int and String
Так что, в основном, в Java нет необходимости проверять строгость с помощью === (сообщается об синтаксической ошибке).
Во-первых, компилятор будет жаловаться, когда вы сравниваете значения разных типов с помощью оператора == и преобразование не может быть выполнено.
В предыдущем примере кода Java, если вы хотите сравнить x и y вы можете использовать equals:
int x = 10;
String y = "10";
System.out.println(y.equals(x)); // compile warning: Unlikely argument type for equals(): int seems to be unrelated to String
Обратите внимание, что метод equals нельзя вызывать для примитивных типов.
Некоторые полезные чтения:
Я сделал функцию, которая отражает функциональность === JavaScript в Java
static boolean compareData(Object v1, Object v2)
{
if(v1 != null && v2 != null)
return (v1.getClass() == v2.getClass() && (v1.toString().equals(v2.toString())));
else
{
return (v1 == null ? v2 == null : v1.equals(v2));
}
}
Мне удалось передать значения любого типа данных (кроме массива) в эту функцию, а также получить значение true, только если тип данных и значения совпадают, в противном случае он возвращает значение false. Производные типы данных, такие как List и HashMap, также работают.
Вызов этой функции выглядит следующим образом:
float s1 = 0.f;
float s2 = 0.1f;
System.out.println(compareData(s1, s2)); //Returns false
float s1 = 0.0f;
float s2 = 0.0f;
System.out.println(compareData(s1, s2)); //Returns true
float s1 = 0.1f;
String s2 = "0.1f";
System.out.println(compareData(s1, s2)); //Returns false
String s1 = "sdf";
String s2 = null;
System.out.println(compareData(s1, s2)); //Returns false
String s1 = null;
String s2 = null;
System.out.println(compareData(s1, s2)); //Returns true
и так далее...
Обновление: мне удалось также сравнить массивы, ниже приведен фрагмент кода, но я не тестировал этот код интенсивно, но работал для каждого выполненного теста.
if(s1 != null && s2 != null)
if(s1.getClass().isArray() && s2.getClass().isArray())
compareDatab = s1.getClass().equals(s2.getClass()) && (Arrays.toString(s1).equals(Arrays.toString(s2)));
else
compareDatab = compareData(s1, s2);
else
compareDatab = compareData(s1, s2);
Использование вышеупомянутого фрагмента (следующие инициализации должны быть выполнены до вышеупомянутого фрагмента кода, smh: P):
//s1 and s2 can be anything including Arrays and non-Array...
int[] s1 = {1,2,3};
int[] s2 = {1,2,3};
//compareDatab gives true
int[] s1 = {1,2,4};
int[] s2 = {1,2,3};
//compareDatab gives false
float[] s1 = {1,2,3};
int[] s2 = {1,2,3};
//compareDatab gives false
Где CompareData() - это та же функция, что и в предыдущем ответе.
Надеюсь, что это окажется полезным для вас. :)
В Java нет понятия правдивости и ложности, поэтому нет оператора строгого сравнения.
=== полезно в языках со слабой типизацией, таких как Javascript, потому что он проверяет, что сравниваемые объекты имеют один и тот же тип, и избегает неявных преобразований.
=== абсолютно не используется в строго типизированном языке, таком как Java, потому что вы не можете сравнивать переменные разных типов без написания специального метода для этого.
В Java вы можете сравнивать примитивные типы, такие как int, double, char, long, float, используя '=='. В этом случае значения сравниваются. Для сравнения объектов этого недостаточно, поскольку "==" оценивается только как "истина", если идентичности сравниваемых объектов одинаковы - "идентичность" - это адрес памяти, где хранится объект. Это связано с тем, что все классы неявно наследуют все методы, предоставляемые классом 'Object', и где метод equals() -method содержит только базовую реализацию. Из-за этого любой класс, чьи объекты участвуют в сравнениях, используемых в структурах данных или вне его собственного пакета, должен содержать надежную реализацию equals() и hashCode() -method для обеспечения правильной функциональности.
Рассмотрим следующую реализацию:
public class MyClass {
private final int val;
private final String name;
public MyClass(int val, String name) {
this.val = val;
this.name = name;
}
public int getVal() { return val; }
public String getName() { return name; }
public boolean equals(Object o) {
if(o == null) return false;
if(this == o) return true;
if(!this.getClass().getSimpleName().equals(o.getClass().getSimpleName()) return false;
MyClass other = (MyClass) o;
return this.getVal() == other.getVal() && this.getName().equals(other.getName());
}
public int hashCode() { ... }
}
Также ознакомьтесь с официальным API Java для получения дополнительной информации https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html.
Если две переменные не одного типа, вы не можете их сравнивать, поэтому в этом случае == будет достаточно. Если они не конвертируемы, это вызовет ошибку компилятора.
Оператор === для сравнения отсутствует. Если вы хотите сравнить две ссылки, вы должны проверить - 1. Если они указывают на один и тот же объект.
if(firstreference==secondreference)
if (secondreference instanctof classoffirstreference)
firstreference.property1.equals(secondreference.property1)
//do this for all properties.
У Java нет идеи === это действительно не нужно. В Java == работает одним из двух способов; если значения являются примитивными типами, то значение проверяемых переменных будет проверено для определения результата.
Второй способ заключается в том, как сравниваются классы (типы), и == сравнивает ссылку (ячейку памяти) двух типов, не имеет значения, что это за два типа, когда мы проверяем ссылки.
Теперь все становится немного сложнее, так как каждый класс имеет метод equals который наследуется от Object его реализация по умолчанию также проверяет только ссылки на объекты и, таким образом, тип снова не является проблемой.
Если вы корректно переопределяете equals тогда вы можете "значение" объектов, и покупать value, я имею в виду поля рассматриваемых объектов, опять же, если вы переопределяете правильно, type не является проблемой, так как контракт equals принимает Object и не вызывает любые исключения., так что сравнение String и Long с использованием equals приведет к false не к исключению.
Единственный раз, когда я не могу сравнить разные "типы", это когда один из типов является boolean, это вызывает проблему компиляции, а не исключение.
О том, как создавать хорошие методы equals см. В статье "Эффективная Java" Джоша Блоха
(извините за длину примера) GitHub
public class Main {
public static void main(String[] args) {
// Primitive "type" equality
final int a = 1;
final long b = 1;
final short c = 1;
final byte d = 1;
final float e = 1.0f;
final double f = 1.0;
final char g = 'a';
// When comparing primitives the value of the variable is used
System.out.println("a == b " + (a == b));
System.out.println("b == c " + (b == c));
System.out.println("c == d " + (c == d));
System.out.println("d == e " + (d == e));
System.out.println("e == f " + (e == f));
System.out.println("f == g " + (f == g));
System.out.println("g == a " + (g == a));
// Object equality
final Integer h = Integer.valueOf(1);
final Integer i = Integer.valueOf(1);
// When comparing objects the "address" of the object is used
System.out.println("a == h " + (a == h));
System.out.println("h == i " + (h == i));
final SimpleA j = SimpleA.from(1);
final SimpleB k = SimpleB.from(1);
// When comparing objects with equals with the default implementation the "address" of the
System.out.println("j.equals(k)" + (j.equals(k)));
final A m = A.from(1);
final A n = A.from(1);
// When equals is overridden then we get a different result
System.out.println("m.equals(n) " + (m.equals(n)));
final B p = B.from(1);
// Again when equals is correctly overridden we can still use equals
System.out.println("n.equals(p) " + (n.equals(p)));
}
private static class SimpleA {
private final int value;
public static SimpleA from(int value) {
return new SimpleA(value);
}
private SimpleA(int value) {
this.value = value;
}
}
private static class SimpleB {
private final int value;
public static SimpleB from(int value) {
return new SimpleB(value);
}
private SimpleB(int value) {
this.value = value;
}
}
private static class A {
private final int value;
public static A from(int value) {
return new A(value);
}
private A(int value) {
this.value = value;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
A a = (A) o;
return value == a.value;
}
@Override
public int hashCode() {
return value;
}
}
private static class B {
private final int value;
public static B from(int value) {
return new B(value);
}
private B(int value) {
this.value = value;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
B b = (B) o;
return value == b.value;
}
@Override
public int hashCode() {
return value;
}
}
}
Если мы сравниваем две переменные в JS, мы можем использовать "==" и "===" обе. "==" сравнить значения и "===" сравнить типы также.
var x = 10;
var y = '10';
console.log(x == y) // true
console.log(x === y) // false
и в Java это дает вам ошибку компиляции, потому что тип не совпадает.
Я не вижу никакой пользы от написания собственного компаратора для этого. особенно если для этого уже есть нативная реализация.
java.util.Objects - твой друг.
Он содержит много маленьких помощников, как
Objects.compare(object1, object2, comparator);
Objects.equals(object1, object2);
Objects.deepEquals(object1, object2);
Objects.hash(object1, object2, object3, ...);
Я использую Objects.equals при перезаписи в equals и Objects.hash в методах hashCode. Он также выполняет нулевые проверки для вас, и в конце код выглядит очень чистым и читаемым.
В примере:
...
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (!(o instanceof Customer)) {
return false;
}
Customer that = (Customer) o;
return Objects.equals(firstName, that.firstName)
&& Objects.equals(lastName, that.lastName)
&& Objects.equals(street, that.street)
&& Objects.equals(houseNumber, that.houseNumber)
&& Objects.equals(postalCode, that.postalCode)
&& Objects.equals(city, that.city)
&& Objects.equals(emailAddress, that.emailAddress);
}
@Override
public int hashCode() {
return Objects.hash(firstName,
lastName,
street,
houseNumber,
postalCode,
city,
emailAddress);
}
...
В JavaScript === не может использоваться для проверки, если и тип, и значение эквивалентны. Например:
var obj_a = {1: 2}
var obj_b = {1: 2}
console.log(obj_a === obj_b)Итак, я могу сделать что-то вроде этого для сравнения вещей, которые обязательно одного типа:
String a = "1";
int b = 1;
try {
if (a == b) {
System.out.println("true");
}
else {
System.out.println("false");
}
}
catch (Exception e) {
System.out.println("false");
}
Таким образом, он печатает false, если они неравны, а также, если они не одного типа, вызывая ошибку.
В Java мы называем это операторами. Существует 5 типов операторов Java. Это - арифметические операторы - реляционные операторы - побитовые операторы - логические операторы - операторы присваивания - разные операторы. Этот оператор равен оператору "равно" и равен "==", а не "===". Он проверяет, равны ли значения двух операндов или нет, если да, то условие становится истинным. ex- int A=10; int B=12; bool C=(A==B); int A=10; int B=12; bool C=(A==B); Тогда переменная C = false;