How to remove duplicate and sort objects from JSONArray using Java

Question

My JSON is:

[
   {
      \"distance\":32,
      \"stationCode\":\"MIG\",
      \"name\":\"Midghat\",
      \"platforms\":\"2\"
   },
   {
      \"distance\":         


        

Answer 1

I wrote this utility a while ago, it sorts a JSONArray of JSONObjects Only condition is that your JSONobjects must contain the keys you want to sort based on (it also accept a set of keys if you want to sort based on several keys)

import java.util.Collections;
import java.util.Comparator;
import java.util.Random;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
public class JSONArraySort {
    @SuppressWarnings("unchecked")
    public static void sortASCE(JSONArray array, Object key) {
        Object[] keys = { key };
        Collections.sort(array, new JSONArrayComparator(false, keys));
    }
    @SuppressWarnings("unchecked")
    public static void sortDESC(JSONArray array, Object key) {
        Object[] keys = { key };
        Collections.sort(array, new JSONArrayComparator(true, keys));
    }
    @SuppressWarnings("unchecked")
    public static void sortASCE(JSONArray array, Object[] key) {
        Collections.sort(array, new JSONArrayComparator(false, key));
    }
    @SuppressWarnings("unchecked")
    public static void sortDESC(JSONArray array, Object[] key) {
        Collections.sort(array, new JSONArrayComparator(true, key));
    }
    private static class JSONArrayComparator implements Comparator<JSONObject> {
        private final Object[] KEYS;
        private final boolean DESC;
        public JSONArrayComparator(boolean DESC, Object[] KEYS) {
            this.KEYS = KEYS;
            this.DESC = DESC;
        }
        @Override
        public int compare(JSONObject object1, JSONObject object2) {
            int length = KEYS.length;
            for(int i = 0 ; i < length ; i++){
                String KEY = KEYS[i].toString();
                Object one = object1.get(KEY);
                Object two = object2.get(KEY);
                if(Number.class.isAssignableFrom(one.getClass()) && Number.class.isAssignableFrom(two.getClass())){
                    Double numOne = Number.class.cast(one).doubleValue();
                    Double numTwo = Number.class.cast(two).doubleValue();
                    int compared = 0;
                    if(DESC){
                        compared = numTwo.compareTo(numOne);
                    }else{
                        compared = numOne.compareTo(numTwo);
                    }
                    if(i == KEYS.length - 1 || compared != 0){
                        return compared;
                    }
                }else{
                    int compared = 0;
                    if(DESC){
                        compared = two.toString().compareTo(one.toString());
                    }else{
                        compared = one.toString().compareTo(two.toString());
                    }
                    if(i == KEYS.length - 1 || compared != 0){
                        return compared;
                    }
                }
            }
            // this shouldn't happen.
            return 0;
        }
    }
        //testing...
    public static void main(String... args) {
        JSONArray array1 = new JSONArray();
        for(int i = 0 ; i < 100 ; i++){
            Random random = new Random();
            int num1 = random.nextInt(10);
            int num2 = random.nextInt(10);
            JSONObject object = new JSONObject();
            object.put("num1", num1);
            object.put("num2", num2);
            array1.add(object);
        }
        String[] keys = { "num1", "num2" };
        sortASCE(array1, keys);
        System.out.println(array1.toString());
    }
}

now if you want to remove duplicates you can iterate through them

Set<String> stationCodes=new HashSet<String>();
JSONArray tempArray=new JSONArray();
for(int i=0;i<yourJSONArray.size();i++){
   String  stationCode=yourJSONArray.getJSONObject(i).getString("stationCode");
   if(stationsCodes.contains(stationCode){
     continue;
   }
   else{
      stationsCodes.add(stationCode);
      tempArray.add(yourJSONArray.getJSONObject(i));
   }

}


yourJSONArray= tempArray; //assign temp to original

//here how you can sort it using utility above:
JSONArraySort.sortASCE(yourJSONArray,"distance");

Answer 2

There is no direct way to that but you can follow the way mentioned bellow:

1. Transform JsonObject to Java Object list using org.codehaus.jackson.map.ObjectMapper

2. Use a Java Map to make unique (put key = stationCode, javaObject as object)

3. Sort the map data based on distance.

Answer 3

Here is the code for joining '2' JSONArrays and removing duplicates from the joined JSONArray, using ArrayList<String>..contains() method:

    import java.util.ArrayList;
    import java.util.List;

    import org.json.JSONArray;
    import org.json.JSONException;
    import org.json.JSONObject;

    /**
     * @author RAM K K
     * @gmail kkram523@gmail.com
     * 
     */

public class JSONOperations {

    public static void main(String[] args) {

        String s3;

        String s1 = "[{\"name\": \"Bob\", \"car\": \"Ford\"},{\"name\": \"Steve\", \"car\": \"Mercedes Benz\"},{\"name\": \"Bob\", \"car\": \"Ford\"},{\"name\": \"Bob\", \"car\": \"Ford\"},{\"name\": \"Bob\", \"car\": \"Ford\"},{\"name\": \"Bob\", \"car\": \"Ford\"},{\"name\": \"Mary\", \"car\": \"Fiat\"}]";
        String s2 = "[{\"name\": \"Mack\", \"car\": \"VW\"},{\"name\": \"Steve\", \"car\": \"Mercedes Benz\"},{\"name\": \"Bob\", \"car\": \"Ford\"}]";
        try {
            JSONArray sourceArray = new JSONArray(s2);
            JSONArray destinationArray = new JSONArray(s1);

            System.out.println(sourceArray);
            System.out.println(destinationArray);

            for (int i = 0; i < sourceArray.length(); i++) {
                destinationArray.put(sourceArray.getJSONObject(i));
            }

            System.out.println(destinationArray);
            System.out.println("JSONArray Size is: " + destinationArray.length());
            List<String> list = new ArrayList<String>();
            for (int i = 0; i < destinationArray.length(); i++) {
                if (!list.contains(destinationArray.get(i).toString())) {
                    list.add(destinationArray.get(i).toString());
                }
            }

            System.out.println("LIST: " + list);
            System.out.println("LIST Size: " + list.size());

            JSONArray distinctJSONArray = new JSONArray(list.toString());
            System.out.println(distinctJSONArray.length());
            for (int i = 0; i < distinctJSONArray.length(); i++) {
                JSONObject JSON = (JSONObject) distinctJSONArray.getJSONObject(i);
                System.out.println(JSON);
            }

            s1 = s1.substring(s1.indexOf("[") + 1, s1.lastIndexOf("]"));
            s2 = s2.substring(s2.indexOf("[") + 1, s2.lastIndexOf("]"));

            s3 = "[" + s1 + "," + s2 + "]";
            System.out.println(new JSONArray(s3));

        } catch (JSONException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

}