How to Remove Duplicate and Sort Objects from Jsonarray Using Java

HOW to remove duplicate JSON Objects from JSON Array

Create an object representing your Others. It will have a name and quantity property and it will also override the equals method, wherein, two Other objects are considered to be equal if they have the same name and quantity properties.

Once you have that, iterate over your JSON, create a new Other object and place it in a HashSet<Other>. The .equals will ensure that the HashSet will contain unique items, as per your definition of unique.

Remove duplicates from JSONArray java

Im not sure exactly lib you are using JSONArray but it should be relatively straightforward to collect unique values from it.

This example shows using Jackson to read the JSON into a JsonNode, if you simply want to check equality based on the toString of each line you can create a HashSet of the values to filter the duplicates out.

final String json
        = "[{\"_index\":\"sales_csv\",\"_source\":{\"Order Date\":\"2016-01-28T18:37:00.000Z\"},\"sort\":[1576653361740],\"_score\":null},{\"_index\":\"sales_csv\",\"_source\":{\"Order Date\":\"2016-01-29T18:35:00.000Z\"},\"sort\":[1576653361740],\"_score\":null},{\"_index\":\"sales_csv\",\"_source\":{\"Order Date\":\"2016-01-30T18:41:00.000Z\"},\"sort\":[1576653361739],\"_score\":null},{\"_index\":\"sales_csv\",\"_source\":{\"Order Date\":\"2016-01-30T18:41:00.000Z\"},\"sort\":[1576653361739],\"_score\":null},{\"_index\":\"sales_csv\",\"_source\":{\"Order Date\":\"2016-01-28T18:37:00.000Z\"},\"sort\":[1576653361740],\"_score\":null}]";

final Set<String> result = new HashSet<>();
final com.fasterxml.jackson.databind.JsonNode jsonNode
        = new com.fasterxml.jackson.databind.ObjectMapper()
            .readValue(json, com.fasterxml.jackson.databind.JsonNode.class);
jsonNode.forEach(t -> {
        result.add(t.toString());
    });
result.forEach(System.out::println);

Remove Duplicate objects from JSON Array

Ultimately, I need a list with the each unique grade as the header and the unique domains as the list items to pass into an HTML page. I may be going about this wrong, so if there is an easier way to accomplish that end goal, I am open to ideas.

So you don't actually need that output array in the format you asked about.

That being the case, I would cut directly to the chase with a very simple and efficient solution:

var grades = {};
standardsList.forEach( function( item ) {
    var grade = grades[item.Grade] = grades[item.Grade] || {};
    grade[item.Domain] = true;
});

console.log( JSON.stringify( grades, null, 4 ) );

The resulting grades object is:

{
    "Math K": {
        "Counting & Cardinality": true,
        "Geometry": true
    },
    "Math 1": {
        "Counting & Cardinality": true,
        "Orders of Operation": true
    },
    "Math 2": {
        "Geometry": true
    }
}

One interesting thing about this approach is that it is very fast. Note that it makes only a single pass through the input array, unlike other solutions that require multiple passes (whether you write them yourself or whether _.uniq() does it for you). For a small number of items this won't matter, but it's good to keep in mind for larger lists.

And with this object you now have everything you need to run any code or generate any other format you want. For example, if you do need the exact array output format you mentioned, you can use:

var outputList = [];
for( var grade in grades ) {
    for( var domain in grades[grade] ) {
        outputList.push({ Grade: grade, Domain: domain });
    }
}

JSON.stringify( outputList, null, 4 );

This will log:

[
    {
        "Grade": "Math K",
        "Domain": "Counting & Cardinality"
    },
    {
        "Grade": "Math K",
        "Domain": "Geometry"
    },
    {
        "Grade": "Math 1",
        "Domain": "Counting & Cardinality"
    },
    {
        "Grade": "Math 1",
        "Domain": "Orders of Operation"
    },
    {
        "Grade": "Math 2",
        "Domain": "Geometry"
    }
]

Rai asks in a comment how this line of code works:

var grade = grades[item.Grade] = grades[item.Grade] || {};

This is a common idiom for fetching an object property or providing a default value if the property is missing. Note that the = assignments are done in right-to-left order. So we could translate it literally to use an if statement and a temp variable:

// Fetch grades[item.Grade] and save it in temp
var temp = grades[item.Grade];
if( ! temp ) {
    // It was missing, so use an empty object as the default value
    temp = {};
}
// Now save the result in grades[item.Grade] (in case it was missing)
// and in grade
grades[item.Grade] = temp;
var grade = temp;

You may notice that in the case where grades[item.Grade] already exists, we take the value we just fetched and store it back into the same property. This is unnecessary, of course, and you probably wouldn't do it if you were writing the code out like this. Instead, you would simplify it:

var grade = grades[item.Grade];
if( ! grade ) {
    grade = grades[item.Grade] = {};
}

That would be a perfectly reasonable way to write the same code, and it's more efficient too. It also gives you a way to do a more specific test than the "truthiness" that the || idiom relies on. For example instead of if( ! grade ) you might want to use if( grade === undefined ).

Avoiding duplicates while adding jsonobjects into the jsonarray using java

Make a temporary array list and add unique code in that arrayList and check if it already exists in arrayList then don't put this again

String code = jsonObj.opt("code");
if(!arrayList.contains(code))
{
    arrayList.add(code);
    responseObj.put("id", jsonObj.opt("id")); 
    responseObj.put("code", jsonObj.opt("code")); 
    responseObj.put("long_description", long_description);
    responseObj.put("description", description);
}

Removing duplicates from JSON array by a value in each JSON object in array

This should do it:

names_array = [
    {name: "a",  age: 15},
    {name: "a",  age: 16},
    {name: "a",  age: 17},
    {name: "b",  age: 18},
    {name: "b",  age: 19}];

function hash(o){
    return o.name;
}    

var hashesFound = {};

names_array.forEach(function(o){
    hashesFound[hash(o)] = o;
})

var results = Object.keys(hashesFound).map(function(k){
    return hashesFound[k];
})

The hash function decides which objects are duplicates, the hashesFound object stores each hash value together with the latest object that produced that hash, and the results array contains the matching objects.

Removing duplicate objects (based on multiple keys) from array

You could use a Set in a closure for filtering.

const    listOfTags = [{ id: 1, label: "Hello", color: "red", sorting: 0 }, { id: 2, label: "World", color: "green", sorting: 1 }, { id: 3, label: "Hello", color: "blue", sorting: 4 }, { id: 4, label: "Sunshine", color: "yellow", sorting: 5 }, { id: 5, label: "Hello", color: "red", sorting: 6 }],    keys = ['label', 'color'],    filtered = listOfTags.filter(        (s => o =>             (k => !s.has(k) && s.add(k))            (keys.map(k => o[k]).join('|'))        )        (new Set)    );
console.log(filtered);

.as-console-wrapper { max-height: 100% !important; top: 0; }

var arr1 = '[{"name":"Pune","city":"India"},{"name":"Pune","city":"India"}]';
var splitlen = JSON.parse(arr1);

var uniqueArray = [];
var uniqueJson = {};
for(i=0;i<splitlen.length;i++)
    {
        
        if(!uniqueArray.find(x => x.name === splitlen[i].name))
            {
                uniqueArray.push(splitlen[i]);
            }
    }

console.log(uniqueArray);

const file = this.files[0];
const  fileType = file['type'];
const validImageTypes = ['image/gif', 'image/jpeg', 'image/png'];
if (!validImageTypes.includes(fileType)) {
    // invalid file type code goes here.
}

var file = this.files[0];
var fileType = file["type"];
var validImageTypes = ["image/gif", "image/jpeg", "image/png"];
if ($.inArray(fileType, validImageTypes) < 0) {
     // invalid file type code goes here.
}