"===" 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.

• luk2302: a.equals(b) with a properly written equals method.
• LiuXiMin: In JavaScript, === can not be used to test if both, the type and the value, are equivalent. var obj_a = {1: 2}; var obj_b = {1: 2}; console.log(obj_a === obj_b); // result is false
• JavaCakes: @LiuXiMin I think it only doesn’t work with objects, but it does with everything else
• LiuXiMin: @JavaCakes No. === means strictly equal in JavaScript. You can not use it for objects, arrays, functions. Look here for more details.
• M A: The below answer more or less gives an explanation, but I'd say don't compare apples to oranges :) In fact, the closest analogy I can think of === in Java is actually .equals() if you're comparing Strings or Numbers (Integer to Integer or Double to Double), but for primitives and other reference types, it is ==, but if comparing Integer to Double (different boxed types), then no equivalent. Bottom line, try to grasp how each operator works in the specific language you're using. Drawing analogies between the two differing languages will likely be more confusing than helping.

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?

• Nexevis: What about in Java 10 where you can now use var?
• Ivar: @lealceldeiro JavaScript doesn't have doubles or integers. Just "Numbers" which are essentially doubles. So 10 and 10.0 are both the same.
• Ivar: @JavaCakes They write the same thing for me (1, 2).
• M A: @Nexevis var in Java 10 is pure syntactic sugar to avoid writing the declaration type of the variable when it can be inferred from the created instance. The language is still strongly-typed.
• Cees Timmerman: TL;DR: === in Java is .equals()

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. :)

• JG7: This seems like it was a fun little project. +1 for going for it
• ChiliChonka: My advice is to use Objects.equals, Objects.deepEquals, Objects.hash, Objects.compare for stuff like that. The Objects class already contains a lot of your functionality you were coding by yourself. And it does null checks for you as well. One more benefit, it is tested and it does not happen that you insert a mistake.

Answer 3

=== 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 4

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

• JavaCakes: So !(false == 0) is true

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.