CODEWITHSUNDEEP
java
reto
reto

Reputation: 16732

Comparing Class objects

I have to compare a Class object against a list of pre-defined classes.

Is it safe to use == or should I use equals? 

if        (klass == KlassA.class) {
} else if (klass == KlassB.class) {
} else if (klass == KlassC.class) {
} else {
}

Note: I cannot use instanceof, I don't have an object, I just have the Class object. I (mis)use it like an enum in this situation!

Upvotes: 29

Views: 40034

Answers (6)

MMKarami
MMKarami

Reputation: 1204

As mentioned in previous answers, to compare objects of Class type (or java.lang.Class objects) we should use == operator. However, It may be a bit confusing because always the result of comparison between objects through == operator can not cause right results (we usually use equal() method). For example, the result of this expression is false:

new String("book") == new String("book")//false

The reason is that,

The virtual machine manages a unique Class object for each type. Therefore, you can use the == operator to compare java.lang.Class objects. From Core Java for the Impatient - Page 153

Therefore:

new String("book").getClass() == new String("book").getClass()//true

or

Class.forName("java.lang.String") == Class.forName("java.lang.String")//true

result in true.

Upvotes: 3

polarfish
polarfish

Reputation: 105

I prefer to use == for comparison between class objects and enum constants because it results in compilation time errors in case of incompatible types.

For example:

Class<?> cls1 = Void.class;
String cls2 = "java.lang.String";

if (cls1 == cls2) doSomething();        // Won't compile

if (cls1.equals(cls2)) doSomething();   // Will compile

Upvotes: 0

robinst
robinst

Reputation: 31407

java.lang.Class does not override the equals method from java.lang.Object, which is implemented like this:

public boolean equals(Object obj) {
    return (this == obj);
}

So a == b is the same as a.equals(b) (except if a is null).

Upvotes: 35

jt.
jt.

Reputation: 7705

I am not sure if this will work for your specific situation, but you could try Class.isAssignableFrom(Class).

KlassA.class.isAssignableFrom(klass)

Upvotes: 5

Jonhnny Weslley
Jonhnny Weslley

Reputation: 1080

For the most of the Java applications this is correct. However, comparing Java classes using the operator == is safe just if both the classes are loaded by the same classloader.

Upvotes: 3

Paulo Santos
Paulo Santos

Reputation: 11567

It's probably safe.

If the object doesn't override the Equals method it will make a comparison between the references. And if two variables point to the same object, their references match.

Upvotes: 1

Related Questions