Find a value of a map with the inverse key

I currently have a map with the following values:

private static final Map<Entrie, somePOJO> MAP = new ConcurrentHashMap<>();

static {
    MAP.put(Object.of(A.class, B.class), new someOtherClass());
}

That Object class is a class that I create to simulate a key, value relation.

What I want to do is to get the instance of the someOtherClass but by searching for the reverse key.

Example:
MAP.get(Object.of(B.getClass, A.getCall)) should return the instance of new someOtherClass, but it returns null as expected because there is no key like the one I was searching.

Any tips on how to workarround the problem?

Consider making the key type unordered. E.g. use a hash set. Then the pairs of A>B and B>A become equal, and will be considered as same key for the map.

MAP.put(Set.of(A.class, B.class), new someOtherClass());
MAP.get(Set.of(B.class, A.class)); // will return the new someOtherClass()

It sounds like you want both Object.of("A", "B") as well as Object.of("B", "A") to be treated as if they are the exact same key - only one object can be associated with either of these, and using either as argument to map's get call returns the object you associated with them.

You have two options:

Fix the equals and hashCode implementations

A map implementation uses a certain 'equality function' to determine if keys are considered equal.

Most use equals and hashCode, which I'll get to. The 2 major alternatives are TreeMap which uses the comparator you provided in the constructor (and if you don't provide one, the Key type must be Comparable, and its compareTo method will be used). It completely ignores equals and hashCode. The other is WeakHashMap which uses object identity and is completely useless here.

Pretty much everything else (such as java.util.HashMap) determines equality by invoking the key object's equals and hashCode methods. The rules are:

1. The result of a.equals(b) must be the same as b.equals(a)
2. a.equals(a) must return true.
3. invoking equals must not throw any exceptions.
4. if a.equals(b), then a.hashCode() must equal b.hashCode(), but the reverse need not be true: If a.hashCode() is the same as b.hashCode(), then they need not be a.equals(b), and in that case (same hashcode, but not equal), they.. just aren't equal. But if they ARE equal, they must have the same hashcode or map just doesn't work. Yes, return 1; is a technically legal impl of hashCode()
5. If the hashcodes are 'badly distributed', as in, lots of non-equal objects have the same hashcode, the map impl's ordinary performance characteristics (such as fast lookup even if there are millions of entries) is no longer valid (they become slow).

Given all that, what you need to invent is an impl of hashCode() and equals(Object) methods such that Object.of("A", "B") and Object.of("B", "A") are equal. For hashcodes, you can hash up every individual value and xor them together, because the xor relation is commutative: a^b^c is the same result as c^a^b - order doesn't matter. For equality, well, you're a programmer, program an algorithm. A simple and fast way is to toss all elements into a TreeSet, i.e. to store all elements in a self-sorting data structure, thus guaranteeing any version of that structure with the same elements necessarily has them in the same order, thus making equality trivial.

I can't mess with the equals and hashCode impl though

Then the other option is to use TreeMap (but note, this means the map's contents will be sorted according to the comparator), using one of the constructors that takes a Comparator<YourObj>. The rules then become:

1. comparator.compare(a, a) must return 0
2. The comparator needs to be consistent: comparator.compare(a, b) needs to match comparator.compare(b, a): If one returns 0, the other must too. If one returns a positive number the other must return a negative number.
3. No NPEs allowed unless one of the two params is null.
4. If comparator.compare(a, b) is 0, then the 2 objects are considered equal.

So, the job then becomes to ensure that comparing Object.of("A", "B") and Object.of("B", "A") returns 0. There's no hashCode function in this arrangement, so all you need to do, is to make that happen, but you can't just arbitrarily return -1 or +1 if they aren't equal, it has to be consistent.