Java - 如何比较不同对象类型的列表

Question

I hope I'm going to be clear enough to explain my problem.

I'm developing an API gateway to compare a JSON payload to an external API (Okta) to know which HTTP action to do for every object of the payload.

Usually I would simply make a GET request on the external API and compare both JSON, which would be way easier. But for this one I'm using the Okta's API SDK ( https://github.com/okta/okta-sdk-java ) to make those requests and especially to not have to define all objects by POJOs that I'll need in my project.

So I'm taking my JSON payload and put it inside a List composed of the element Group (which is an element from the SDK that I want to use). I'm then using the SDK to get the elements inside Okta through the API and put it inside a List also of element Group . Here is the code :

List<Group> groupListBody = mapper.readValue(body, List.class);
List<Group> groupListOkta = okta.listGroups().stream().collect(Collectors.toList());

The thing is that the List are in fact composed of differents types of Objects :

• JSON Payload list is a List of LinkedHashMap Objects
• Okta list is a List of DefaultGroup Objects

But if we take an element of groupListBody and groupListOkta as they were defined by the object Group , we can cleary see that they are identical except for their type.

So my question is, what can I do to change either their type or something else to properly compare the elements of those two lists?

UPDATE :

I've noticed that jackson create a list of LinkedHashMap because it does not have enough information to deserialize my payload into a list of Group objects.

Here is what happend if I cast a element of the list with

Group test = (Group) groupListBody.get(0);

ERROR::class java.util.LinkedHashMap cannot be cast to class com.okta.sdk.resource.group.Group (java.util.LinkedHashMap is in module java.base of loader 'bootstrap'; com.okta.sdk.resource.group.Group is in unnamed module of loader 'app')

I think it's coming from the SDK model of the Group object but I don't know what to do to properly deserialze it without recreating a POJO model.

Here is the model class :

public interface Group extends ExtensibleResource, Deletable {

    Map<String, Object> getEmbedded();

    Map<String, Object> getLinks();

    Date getCreated();

    String getId();

    Date getLastMembershipUpdated();

    Date getLastUpdated();

    List<String> getObjectClass();

    GroupProfile getProfile();

    Group setProfile(GroupProfile profile);

    GroupType getType();

    Role assignRole(AssignRoleRequest assignRoleRequest, String disableNotifications);

    Role assignRole(AssignRoleRequest assignRoleRequest);

    UserList listUsers();

    Group update();

    void removeUser(String userId);

    ApplicationList listApplications();

    void delete();
}

Answer 1

EDIT: I've read the update on your post. If you really must compare these two objecttypes without copying them into a new list, you might find this approach useful:

In Java, we have the Collector interface, which is a generic interface, that is defined as following:

    Public interface collector <T,A,R>{
    Supplier<A> supplier();
    BiConsumer<A,T> accumulator()
    BinaryOperator<A> combiner()
    Function<A,R> finisher();
    Set<characteristics> characteristics();
    }
    

Now, we can make a custom collector implementing this interface, by defining a new class that implements all the methods that I provided above. But first, what does all of this mean anyway?

1. The elements <T,A,R>: -T is objecttype of the elements provided by the stream -A Type of object that the accumulator will call when collecting elements -R Type of object returned by the collect method

2. The methods: -Supplier() provides the container that holds the results of the accumulation operation. Supplier is a factory function, that returns a reference to a method. -accumulator() consumes elements for accumulating them -combiner() unifies the accumulated results -finisher() transforms the container holding the accumulated result into desired type -characteristics() defines behaviour when stream is ran in parallel or sequential computing (for example: Concurrent or Unordered).

If this approach doesn't work for you, we can gain more control over the output of our input data with some helpful methods.

    List<Group> groupListOkta = 
    okta.listGroups().stream().collectAndThen(Collector<T,A,R> 
    downstream, Function<R,RR> modifier()) //Passes the collector 
    //to a finisher function, in which you can return the desired type.

If you would like to read more about the topic, here are some helpful links:

https://docs.oracle.com/javase/8/docs/api/java/util/stream/Collectors.html#toCollection-java.util.function.Supplier- https://docs.oracle.com/javase/8/docs/api/java/util/stream/Collectors.html https://www.technetexperts.com/web/how-to-use-custom-collectors-in-java/ https://docs.oracle.com/javase/8/docs/api/java/util/stream/Collectors.html#collectingAndThen-java.util.stream.Collector-java.util.function.Function-

Good day,

although it is a bit tedious, you can write a function that loops over all the elements of your objects, then creates a new arraylist of booleans. This list will give you all the matches at their indexes.

    public static List<Boolean> checkMatches( List<Group> l1, List<Group> l2 ) {

    //Optionally, you can check here which list is shortest and store 
    //this somewhere, enabling you to preset matches.length

    List<Boolean> matches = new ArrayList<>();
    int count = 0;
    for ( Object o1 : l2 ) {
    count++
    for ( Object o2 : l1 ) {
    if (o1.equals(o2){
    matches.add(true)
    };
    };
    if (matches.length < count){
    matches.add(false)
    };
    };
    return matches;
    };

I coded this a bit hastily. The idea is that you add true if you find a match in your other object, then check if you added true by comparing length, and when u have not added true, u add false. You can make this more pretty and more efficient I trust. I hope that the solution works for you!