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

You need to provide your own implementation of equals() in MyClass.

@Override
public boolean equals(Object other) {
    if (!(other instanceof MyClass)) {
        return false;
    }

    MyClass that = (MyClass) other;

    // Custom equality check here.
    return this.field1.equals(that.field1)
        && this.field2.equals(that.field2);
}

You should also override hashCode() if there's any chance of your objects being used in a hash table. A reasonable implementation would be to combine the hash codes of the object's fields with something like:

@Override
public int hashCode() {
    int hashCode = 1;

    hashCode = hashCode * 37 + this.field1.hashCode();
    hashCode = hashCode * 37 + this.field2.hashCode();

    return hashCode;
}

See this question for more details on implementing a hash function.

The “different member variables” is irrelevant. It’s an implementation detail. What you need is a set of rules which of two people comes first.

You could for example sort by family name, then given name, then date of birth, and if these are all three equal, take the name of the school, university or company (which will be different member variables) and compare them as strings. If that is equal, you might have student and employee ids, and the student ids might be unique, and the employee ids might be unique, but student and employee ids might be the same. So you could sort then students first ordered by id, followed by employees sorted by id, if you might sort by if first if student and employee ids are comparable.

(University or school and employer might be the same, because universities are also employers).

The generally-accepted idiom for such methods in Java is based on the Java Object equals() method, which accepts a different object for comparison:

public boolean equals(Object obj)

Indicates whether some other object is "equal to" this one.

Ergo:

public bool IsSameColorAs(car other) {
    return this.color == other.color;
}

Usage:

bool IsSameColor = car1.IsSameColorAs(car2);

Use class.equals():

if (nextMonster.getClass().equals(monster.getClass()))

or, because each class is like a singleton - there's only one instance of each Class per class loader, and most JVMs only have the one class loader - you can even use an identity comparison:

if (nextMonster.getClass() == monster.getClass())

If they're from the exact same class:

boolean result = object1.getClass().equals( object2.getClass());

Now if they are compatible classes (if one is of a descendent class to the other):

HashMap<String,Object> hashMap = new HashMap<String,Object>();
LinkedHashMap<String,Object> linkedHashMap = new LinkedHashMap<String,Object>();
boolean result = hashMap.getClass().isAssignableFrom( linkedHashMap.getClass() );

As LinkedHashMap is a subclass of HashMap this result variable will be true, so this might probably be better for you as it's going to find exact and subclass matches.

Also, you should avoid using ".class" on variables, as it might not give you the correct result, example:

Object someText = "text value";
System.out.println( someText.class.getName() ); //this will print java.lang.Object and not java.lang.String

When you're using ".class" you're acessing the variable static property and not the class of the object itself.