Еквивалент на “===” в 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 не може да се извика при примитивни типове.

Някои полезни четива са:

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

Успях да предам стойности от всякакъв тип данни (с изключение на масив) към тази функция, както и да получа 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, като използвате '=='. В този случай стойностите се сравняват. За сравнението на обекти това не е достатъчно, защото '==' се оценява само като 'true', ако идентичностите на сравняваните обекти са еднакви - 'identity' е адресът на паметта, където се съхранява обектът. Това се дължи на факта, че всички класове наследяват имплицитно всички методи, предоставени от класа „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 това ви дава грешка при компилиране, защото типът не е същият.