如何基于Java中的几种条件从列表中删除重复项

Question

I have a List of Flight Objects, that object has id(Long) and destinations(String). what i need to do is remove the duplicate entries of same id. But the condition is to remove those element, i can only keep the elements which has the longest destination list.

Flight{
   Long id;
   String destination;       
}

List flights <- This is what is have to filter based on the condition.

Examples for the List :

flight1 -> id:456 , destination LON/DXB
flight2 -> id:456 , destination LON/DXB/IND
flight3 -> id:465 , destination LON/DXB/IND/CMB
flight4 -> id:555 , destination LON/DXB
flight5 -> id:666 , destination DXB/SHJ
flight6 -> id:666 , destination DXB/SHJ/BOM

According to the condition given i can only keep in the list is : flight3,flight4,flight6 . other flights can`t be in the list. How can i get done this?

Answer 1

What you can do is to have a map that will make the relation ship between an id and an instance.

While iterating through the list, you check if there is an instance with the same id in the map. If it's not the case, you just add the mapping, otherwise you compare the destination's length (or whatever you want to compare) and you update the mapping if necessary.

Map<Long, Flight> map = new HashMap<>();
for(Flight f : flights) {
    if(map.containsKey(f.id)) {
        if(map.get(f.id).destination.length() < f.destination.length()) {
            map.put(f.id, f);
        }
    } else {
        map.put(f.id, f);
    }
}

//you can even store them in a set
List<Flight> longestDestinationFlights = new ArrayList<>(map.values());

Answer 2

Ok I expect you to have a list of flights like in : List<Flight> . And I assume further, that there will be more entries which are duplicated and the "longer" destination should be stored.

What you would do is iterating using the iterator. (You can't use a for loop while removing)

   List<Flight> a = new ArrayList<>();
   List<Flight> copy = new ArrayList<>();
   Collections.copy(copy, a);
   Iterator<Flight> it = a.iterator();
   while(it.hasNext()){
       Flight f = it.next();
       if(shouldGetRemoved(f, copy)){
           it.remove();
       }
   }

shouldGetRemoved is you logic to compare the destinations. Would be another for loop over the copy.

Answer 3

My implementation goes a little long, but it is easy.

• Sort the list in descending order of size of destination list.
• Remove flights with duplicate ids.

Working code here .

Here is the code.

private static List<Flight> removeDuplicates(List<Flight> list) {

    //sort the list, descending order of size of destination list
    Collections.sort(list, new Comparator<Flight>() {

        @Override
        public int compare(Flight o1, Flight o2) {
            if (o1.getId().equals(o2.getId())) {
                int l1 = o1.getDestination().split("/").length;
                int l2 = o2.getDestination().split("/").length;
                if (l1 < l2) {  //check whose destination list is long
                    return 1;
                } else {
                    return -1;
                }
            }
            return 0;
        }
    });

    // remove duplicates
    Set<Long> ids = new HashSet<>();
    List<Flight> newList = new ArrayList<>();
    for (int i = 0; i < list.size(); i++) {
        if (!ids.contains(list.get(i).getId())) {
            newList.add(list.get(i));
            ids.add(list.get(i).getId());
        }
    }
    return newList;
}