在运行时创建Composite Comparator进行排序

Question

My sample request

 {
  "requestModel":{
      "CUSTID": "100"
     },
  "returnParameters":[
    {
     "name":"NETWORK/NETID",
     "datatype":"String",
     "order":"asc",
     "sequence":1
    },
    {
     "name":"INFODATA/NAME",
     "datatype":"String",
     "order":"asc",
     "sequence":1
    },
    {
     "name":"SOURCE/SYSTEM",
     "datatype":"int",
     "order":"asc",
     "sequence":2
    },
   ]
 }

Sample Response

Below is my dynamically generated Map format of json response[Response parameters will be different each time based on the request params],

"responseModel":{
  "documents": [
{
 "NETWORK":[
    {"NETID":"1234"},
    {"ACT":"300"}
   ],
   "SOURCE": {
      "SYSTEM":"50"
     },
   "INFODATA":{
     "NAME":"PHIL"
     }
 },
 {
  "NETWORK":[
    {"NETID":"1234"},
    {"ACT":"300"}
   ],
   "SOURCE": {
      "SYSTEM":"100"
     },
   "INFODATA":{
     "NAME":"PHIL"
     }
  }
 ]
}

Problem Statement

I need to do multi level sorting based on the "returnParameters" in the request which is dynamic ... "order" indicates ascending (or) descending and sequence indicates the the priority for ordering like (group by in sql query)

Code

Map<String,Object> documentList = new HashMap<String,Object>();
JSONObject jsonObject= new JSONObject(response.getContent());

response.getContent() -> is nothing but it contains the above json response in Map format.

Now I converting the map to list of json object

JSONArray jsonArray= (JSONArray)jsonObject.get("documents");
ArrayList<JSONObject> list = new ArrayList<>();
for(int i=0;i<jsonArray.length();i++){
 list.add((JSONObject) jsonArray.get(i));
 }
 Collections.sort(list, new ResponseSorter());
 public class ResponseSorter implements Comparator<JSONObject> {
  @Override
  public int compare(JSONObject o1,JSONObject o2){
  String s1= (String)((JSONObject) o1.get("NETWORK")).get("NETID");
  String s2= (String)((JSONObject) o2.get("NETWORK")).get("NETID");
  int i1=Integer.parseInt(s1);
  int i2=Integer.parseInt(s2);
  return i1-i2;
  }
 }

I'm stuck here to proceed further. Created one for Integer comparator, .Should I create for each dataType? also I need to dynamically construct the composite comparator by parsing the "retunrParameters" , below sample is hard coded, how to create dynamically??

(String)((JSONObject) o1.get("NETWORK")).get("NETID"); -> this should be dynamically framed , since "returnParameters" are also dynamic in nature.[NETWORK & NETID may not be come in another request],so my comparator should be capable enough to frame the keys in runtime

Would anyone able to assist me to create composite comparator in runtime for sorting?

NOTE:- Java Pojo cannot be created as the response is dynamic nature

Answer 1

EDITED after additional questions in comments and additional info in description

---

You have a couple of steps you need to do here to get to the solution:

1. You want to have the sorting be dynamic based on the value of the property sequence in the request. So you need to parse the names of those returnParameters and put them in order. Below I map them to a List where each String[] has the name and order (asc/desc). The list will be ordered using the value of sequence :

    List<String[]> sortParams = params.stream() // params is a List<JSONObject> .filter(json -> json.containsKey("sequence")) // filter those that have "sequence" attribute .sorted( sequence ) // sorting using Comparator called sequence .map(jsonObj -> new String[]{jsonObj.get("name").toString(), jsonObj.get("order").toString()} ) .collect(Collectors.toList()); 

Before this you'll map the objects in the returnParameters array in the request to a List first.Then the stream is processed by 1. filtering the JSONObjects to only keep those that have prop sequence , 2. sorting the JSONObjects using comparator below. 3. from each JSONObject get "name" & "order" and put them in a String[], 4. generate a list with those Arrays. This list will be ordered in the order of attributes with priority 1 first, then priority 2, etc, so it will be ordered in the same way you want the JSONObjects ordered in the end.

    Comparator<JSONObject> sequence = Comparator.comparingInt(
        jsonObj -> Integer.valueOf( jsonObj.get("sequence").toString() ) 
    );

So for your example, sortParams would look like: List( String[]{"NETWORK/NETID", "asc"}, String[]{""INFODATA/NAME", "asc"}, String[]{"SOURCE/SYSTEM", "asc"} )

2. Then you need to write a method that takes two params: a JSONObject and a String (the path to the property) and returns the value of that property. Originally I advised you to use JSONAware interface and then figure out the sub-class, but let's forget about that for now.

   I am not going to write this method for you. Just keep in mind that .get(key) method of JSON.Simple always yields an Object . Write a method with this signature:

    public String findSortValue(JSONObject doc, String path){ // split the path // find the parent // cast it (parent was returned as an Object of type Object) // find the child return value; } 

3. Write a generic individual comparator (that compares values of just one sort attribute at a time) and figures out if it's an Int, Date or regular String. I would write this as a regular method so it'll be easier to combine everything later on. Since you had so many questions about this I've made an example:

    int individualComparator(String s1, String s2){ int compResult = 0; try{ int numeric1 = Integer.parseInt(s1); int numeric2 = Integer.parseInt(s2); compResult = numeric1 - numeric2; // if this point was reached both values could be parsed } catch (NumberFormatException nfe){ // if the catch block is reached they weren't numeric try{ DateTime date1 = DateTime.parse(s1); DateTime date2 = DateTime.parse(s2); compResult = date1.compareTo(date2); // compareTo method of joda.time, the library I'm using } catch (IllegalArgumentException iae){ //if this catch block is reached they weren't dates either compResult = s1.compareTo(s2); } } return compResult; 

   };

   4. Write an overall Comparator that combines everything

       Comparator<JSONObject> overAllComparator = (jsonObj1, jsonObj2) -> { List<String[]> sortValuesList = sortParams.stream() .map(path -> new String[]{ findValueByName(jsonObj1, path), findValueByName(jsonObj2, path) } ) .collect(Collectors.toList()); //assuming we always have 3 attributes to sort on int comp1 = individualComparator(sortValuesList.get(0)[0], sortValuesList.get(0)[1]); int comp2 = individualComparator(sortValuesList.get(1)[0], sortValuesList.get(1)[1]); int comp3 = individualComparator(sortValuesList.get(2)[0], sortValuesList.get(2)[1]); int result = 0; if (comp1 != 0){ result = comp1; } else if (comp2 != 0){ result = comp2; } else{ result = comp3; } return result; }; 

This Comparator is written lambda-style, for more info https://www.mkyong.com/java8/java-8-lambda-comparator-example/ .

First it takes the ordered list of sortParams we made in step 1 and for each returns an array where position 0 has the value for jsonObj1 , and position 1 has the value for jsonObj2 and collects it in sortValuesList . Then for each attribute to sort on, it get the result of the individualComparator method. Then it goes down the line and returns as result of the overall comparison the first one that doesn't result in 0 (when a comparator results in 0 both values are equal).

The only thing that's missing now is the asc/desc value from the request. You can add that by chaining int comp1 = individualComparator(sortValuesList.get(0)[0], sortValuesList.get(0)[1]); with a simple method that takes an int & a String and multiplies the int by -1 if the String equals "desc". (Remember that in sortParams we added the value for order on position 1 of the array).

Because the first list we made, sortParams was ordered based on the priority indicated in the request, and we always did evertything in the order of this list, the result is a multi-sort in this order. It is generic & will be determined dynamically by the contents of returnParams in the request. You can apply it to your list of JSONObjects by using Collections.sort()

Answer 2

In your case a simple comparator that's provided with the sort parameters might be easier to understand than a bunch of nested comparators.

Basically you'd do something like this:

class ReturnParameterComparator implements Comparator<JSONObject> {
   private List<ReturnParameter> params; //set via constructor

   public int compare( JSONObject left, JSONObject right) {
     int result = 0;
     for( ReturnParameter p : params ) {
       //how exactly you get those values depends on the actual structure of your data and parameters
       String leftValueStr = left.get( p ); 
       String rightValueStr = right.get( p ); 

       switch( p.datatype ) {
         case "String": 
           result = String.compare( leftValueStr, rightValueStr );
           break;
         case "int": 
           //convert and then compare - I'll leave the rest for you 
       }

       //invert the result if the order is descending
       if( "desc".equals(p.order ) {
         result += -1;
       }

       //the values are not equal so return the order, otherwise continue with the next parameter
       if( result != 0 ) {
         return result;
       }
     }

     //at this point all values are to be considered equal, otherwise we'd have returned already (from the loop body)
     return 0;
   }
}

Note that this is just a stub to get you started. You'll need to add quite a few things:

• how to correctly use the parameters to extract the values from the json objects
• how to convert the data based on the type
• how to handle nulls, missing or incompatible data (eg if a value should be sorted as "int" but it can't be parsed)

Adding all those would be way too much for the scope of this question and depends on your data and requirements anyway.

Answer 3

My suggestion: learn about:

• Comparator.comparing which allows you to build your comparator by specifying the key extractor
• Comparator.thanComparing which allows you to chain multiple comparators. The comparators later in the chain are called only if predecessors say the objects are equal

A tutorial if you need one: https://www.baeldung.com/java-8-comparator-comparing