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:
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)
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 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:
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.1k
- 7
- 55
- 85
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)
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 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:
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)
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 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:
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)
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 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:
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)
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 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 thatthe Object.equals method cannot be called on primitive types.
Some useful readings are:
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)
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 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 that Object.equals cannot be called on primitive types.
Some useful readings are:
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)
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 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: