Эквивалент «===» в 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

В качестве побочного примечания обратите внимание на _ 14_ нельзя вызывать для примитивных типов.

Некоторые полезные чтения:

• 15.21. Операторы равенства
• В чем разница между язык со строгой типизацией и язык со статической типизацией?
• Какие проблемы следует учитывать при переопределении equals и hashCode в Java?

Я сделал функцию, которая r воплощает функциональность === 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));
    }
}

Мне удалось передать значения любого типа данных (кроме массива) в эту функцию, а также получить истину, только если тип данных и значения совпадают, иначе она вернет ложь. Производные типы данных, такие как 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 () содержит только базовую реализацию. По этой причине любой класс, чьи объекты участвуют в сравнении, используются в структурах данных или вне его собственного пакета, должен содержать надежную реализацию equals () и hashCode () - метода для обеспечения правильной функциональности.

Что касается следующей реализации:

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() { ... }

}

Также ознакомьтесь с официальным Java API для получения дополнительной информации https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html.

Я не вижу никакой пользы от написания собственного компаратора для этого. особенно если для этого уже есть нативная реализация.

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);
}

...

Если две переменные не одного типа, вы не можете их сравнивать, поэтому в этом случае будет достаточно ==. Если они не могут быть преобразованы, компилятор выдаст ошибку.

Для сравнения нет оператора ===. Если вы хотите сравнить две ссылки, вы должны проверить - 1. Если они указывают на один и тот же объект.

if(firstreference==secondreference) 

2. Если условие 1 выше не выполнено, вам следует проверить их тип с помощью оператора instanceof:

if (secondreference instanctof classoffirstreference)

3. Если выполняется условие 2, указанное выше, вы должны проверить сравнение свойств с помощью оператора равенства, например

firstreference.property1.equals(secondreference.property1)
//do this for all properties.

Если мы сравним две переменные в JS, мы можем использовать обе «==» и «===». «==» сравнивает значения и «===» также сравнивает типы.

var x = 10;
var y = '10';
console.log(x == y)  // true
console.log(x === y) // false

а в Java это дает ошибку компиляции, потому что тип не тот.