How to compare 2 lists of different objects with similar properties

If I have 2 instances from 2 different classes as follows (with similar attributes), can I use Hamcrest's containsInAnyOrder to match their attributes?

class Something{

    int id;
    int name;
}

class GsonSomething{

    int id;
    int name;
}

Can I use containsInAnyOrder or any other method to compare 2 lists from the 2 classes?

List<Something> somethingList; //[ {id:1, name: "one"}, {id:1, name: "two"} ]


List<GsonSomething> gsonSomethingList; //[ {id:1, name: "one"}, {id:1, name: "two"} ]

The use case of this is to be used in a test method to compare the result vs the expected. And I used the following approach:

for(Something s : somethingList){
    GsonSomething gs = gsonSomethingList.stream().filter(p -> p.id.equals(s.id)).findFirst();
    assertEquals(s.name, gs.name);
    //assert other attributes

}

Create your own matcher by extending http://hamcrest.org/JavaHamcrest/javadoc/1.3/org/hamcrest/BaseMatcher.html and use it in the assertion.

Not directly, no.

Why not?

Java holds that the type namespace is holy, and everything else is only relative to the type it is in. In other words, in java, these two methods:

class Gun() { void shoot(Person p); }

class Camera() { void shoot(Person p); }

are considered to be utterly unrelated, and the same goes for fields that so happen to have the same name: Does not mean they are related, at all.

Okay, so how do I do this?

You're going to have to go out of your way to convert your inputs to something that can be compared.

Fortunately, that is relatively simple. Had it been a single property you want to compare (say, the int id value), then just convert both values to that and then run your comparison.

If you have 'compound keys' (you want both id and name to be equal) you need some type that can hold these keys. Presumably both GsonSomething and Something are themselves qualifying as types that can do the job, so you really just need to convert, say, your list of GsonSomething to a list of Something and then you can compare.

But what about my solution

Your solution has two problems.

The glaring one: It's not doing a proper job. If there is an element in gsonSomethingList that does not appear in somethingList at all, your test will still pass, which would be incorrect.

A slightly less problematic one: It is very slow; it's O(n^2) speed. If the inputs start hitting 5 digits (10k entries and up - in that ballpark), you're going to notice. Once they hit 7, this test starts taking extremely long.

So what is a better way?

To speed up the comparison, these need to be in a set, which requires proper equals and hashcode impls. So let's start there, and make Something are class of record:

@lombok.EqualsAndHashCode
class Something {
    int id;
    int name;
}

If lombok is not something you're using, perhaps:

class Something {
    int id;
    int name;

    @Override public boolean equals(Object other) {
        if (other == this) return true;
        if (other == null) return false;
        if (other.getClass() != Something.class) return false;
        Something o = (Something) other;
        return o.id == this.id && o.name == this.name;
        // NB: Use .equals() and add null checks if `name` is String!
    }

    @Override public int hashCode() {
        return (31 + id) * 31 + name;
    }
}

Now that we have that, we can convert one to the other, and use sets, which can do such a job much faster (algorithmically so, in fact):

Set<Something> a = ....;
List<GsonSomething> rawB = ...;

Set<Something> b = rawB.stream()
    .map(b -> new Something(b.getId(), b.getName())
    .collect(Collectors.asSet());

and now you can use e.g. containsInAnyOrder with a and b.

I would do some slight refactoring. I would first create a base class, make Something and GsonSomething class extend it. In the base class I would override the equals method.

abstract class BaseSomething {
    int id;
    String name; //This should definitely be a String type

   //getters and setters

    @Override
    public boolean equals(Object other) {
       if (other == this) return true;
       if (other == null) return false;
       if (!(other instanceof BaseSomething)) return false;
       BaseSomething o = (BaseSomething) other;

       return o.id == this.id && o.name.equals(this.name);
    }
}

class Something extends BaseSomething {
}

class GsonSomething extends BaseSomething {
}

Now, this are pretty easy. Your two List fields will be now:

List<BaseSomething> somethingList; //[ {id:1, name: "one"}, {id:1, name: "two"} ]


List<BaseSomething> gsonSomethingList; //[ {id:1, name: "one"}, {id:1, name: "two"} ]

And a simple call to Hamcrest method should do the job:

assertThat(gsonSomethingList, containsInAnyOrder(somethingList.toArray(new BaseSomething[0]));