“===” equivalent in Java

Question

While comparing two values in Java, how do you test if both, the type and the value, are equivalent?

I know in JavaScript === can be used to accomplish this, so I tried that in Java, but it didn’t work.

I know this is a simple question, but I tried looking it up and I couldn’t find out what it was.

Answer 1

TL;DR

In Java there is not such a comparison operator: ===, but == or equals

A longer explanation

In weakly typed languages such as JavaScript you can use the strict comparison operator (===) because the language allows comparison between variables which have different types.

For example, in JavaScript, you won't get a compile error if you do this:

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

And it is useful, when you want to compare variables which may hold values that are "equals" but may be of different types.

For example

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

In strongly typed languages such as Java, you don't need to use a strict comparison operator because the language already "handles" the type comparison.

For example:

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

So, basically, in Java, there is no need for checking for strictness using === (a syntax error is reported).

In the first place, the compiler will complain when you compare values of different types using the == operator and conversion cannot be performed.

In the previous example of Java code, if you want to make a comparison between x and y you could use 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

As a side note, notice the equals method cannot be called on primitive types.

Some useful readings are:

• 15.21. Equality Operators
• What is the difference between a strongly typed language and a statically typed language?
• What issues should be considered when overriding equals and hashCode in Java?

Answer 2

I made a function which replicates the functionality of === of Javascript in 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));
    }
}

I was able to pass values of any data type (except array) to this function as well as get true only if the data type and the values match else it returns false. Derived data types like List and HashMap also work.

Call to this function looks like this:

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

and so on...

Update: I managed to compare arrays also, following is the code snippet, but, I haven't tested this code intensively but worked for every test case I performed.

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

Usage of the above snippet (Following initializations should be done prior to above code snippet,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

Where compareData() is the same function as stated prior in this answer.

Hope this proves useful to you. :)

Answer 3

There is no concept of truthy and falsy in Java, thus there is no strict comparison operator.

Answer 4

=== is useful in weak typed languages, such as Javascript, because it verifies that the objects being compared are of the same type and avoids implicit conversions.

=== has absolutely no use in a strongly typed language such as Java because you can't compare variables of different types without writing a specific method for doing this.

Answer 5

In Java you can compare primitive types like int, double, char, long, float by using '=='. In this case values are compared. For the comparison of objects this is not sufficient because '==' evaluates only to 'true' if the identities of the compared objects are the same - 'identity' is the memory address where the object is stored. This is due to the fact that all classes inherit implicitly all methods provided by the 'Object' class and where the 'equals()'-method contains only a basic implementation. Because of this any class whose objects are involved in comparisons, used in data structures or outside it's own package should contain a solid implementation of equals() and hashCode()-method to provide correct functionality.

Regard following implementation:

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

}

Also check out official Java API for further information https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html .

Answer 6

I can't see any benefit of writing my own comparator for this. especially if there is already a native implementation for this.

java.util.Objects is your friend.

It contains a lot of little helper, like

Objects.compare(object1, object2, comparator);
Objects.equals(object1, object2);
Objects.deepEquals(object1, object2);
Objects.hash(object1, object2, object3, ...);

I use Objects.equals in overwriting in equals and Objects.hash in hashCode methods. It also does null checks for you and in the end the code looks very clean and readable.

In example:

...

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

...

Answer 7

If two variables aren't of the same type you can't compare them, so in this case == will suffice. If they're not convertable it will throw a compiler error.

Answer 8

There is no === operator for comparison. When you want to compare two references, you should check - 1. If they are pointing to same object.

if(firstreference==secondreference) 

2. If condition 1 above did not meet then you should check for their type by instanceof operator :

if (secondreference instanctof classoffirstreference)

3. If condition 2 above meets then you should check for property comparisons by equals operator like

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

Answer 9

If we compare two variables in JS we can use "==" and "===" both. "==" compare values and "===" compare Types also.

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

and in Java this give you compile error because type is not same.