Take this for example (excerpt from Java regex checker not working):
while(!checker) {
matcher = pattern.matcher(number);
if(matcher.find())
checker = true;
else
year++;
}
Would it matter if .equals(false)
was used to check for the value of the Boolean checker
?
I know that there is this which is rather similar. However, obviously the question deals with primitive boolean
and not the object wrapper, Boolean
; thus, .equals()
would not be applicable.
Also, should Boolean
be dealt differently than boolean
?
As long as checker
is not null
, you may use !checker
as posted. This is possible since Java 5, because this Boolean
variable will be autoboxed to the primivite boolean
value.
As object?
equals
public boolean equals(Object obj)
Returns true if and only if the argument is not null and is a Boolean object that represents the same boolean value as this object.
Overrides: equals in class Object
Parameters: obj - the object to compare with.
Returns: true if the Boolean objects represent the same value; false otherwise.
boolean a = true;
boolean b = false;
System.out.println("a.equals(b):" + ((Object)a).equals( ((Object)b) ));
Output: a.equals(b):false
Regarding the performance of the direct operations and the method .equals()
. The .equals()
methods seems to be roughly 4 times slower than ==
.
I ran the following tests..
For the performance of ==
:
public class BooleanPerfCheck {
public static void main(String[] args) {
long frameStart;
long elapsedTime;
boolean heyderr = false;
frameStart = System.currentTimeMillis();
for (int i = 0; i < 999999999; i++) {
if (heyderr == false) {
}
}
elapsedTime = System.currentTimeMillis() - frameStart;
System.out.println(elapsedTime);
}
}
and for the performance of .equals()
:
public class BooleanPerfCheck {
public static void main(String[] args) {
long frameStart;
long elapsedTime;
Boolean heyderr = false;
frameStart = System.currentTimeMillis();
for (int i = 0; i < 999999999; i++) {
if (heyderr.equals(false)) {
}
}
elapsedTime = System.currentTimeMillis() - frameStart;
System.out.println(elapsedTime);
}
}
Total system time for ==
was 1
Total system time for .equals()
varied from 3 - 5
Thus, it is safe to say that .equals()
hinders performance and that ==
is better to use in most cases to compare Boolean
.
.equals(false)
will be slower because you are calling a virtual method on an object rather than using faster syntax and rather unexpected by most of the programmers because code standards that are generally used don't really assume you should be doing that check via .equals(false)
method.
Using direct conditions (like ==, !=, !condition) will have a slight performance improvement over the .equals(condition) as in one case you are calling the method from an object whereas direct comparisons are performed directly.
Try this:
if (Boolean.TRUE.equals(yourValue)) { ... }
As additional benefit this is null-safe.
Source: Stackoverflow.com