Sort list of objects with respect to list of given input values

Try this:

Building the objects.

List<Traveler> travelers = new ArrayList<>();
Traveler t1 = new Traveler();
t1.traveler = "Richard";
t1.countries = List.of("India", "Poland", "Australia");     
travelers.add(t1);

t1 = new Traveler();
t1.traveler = "John";
t1.countries = List.of("US", "Australia", "Maldives");
travelers.add(t1);


t1 = new Traveler();        
t1.traveler = "Emma";       
t1.countries = List.of("US");       
travelers.add(t1);

The filter

List<String> countryFilter = List.of("US", "Maldives");

The test predicates. These are the heart of the matter.

• they both stream countryFilter and check to see if those
  countries are in the list of traveled countries.
• or returns true if the travelers countries contain at least one country
• and returns true if the traveler's countries contain all the countries.

Predicate<Traveler> or = t -> countryFilter.stream()
                .anyMatch(cc -> t.countries.contains(cc));

Predicate<Traveler> and = t -> countryFilter.stream()
                .allMatch(cc -> t.countries.contains(cc));

Now just stream just stream the traveler objects
and apply the filters. Then prints the results.

System.out.println("Filtering on: " + countryFilter);
System.out.println("\nVisited all of the countries");
travelers.stream().filter(and)
    .forEach(t -> System.out.println(t.traveler));
System.out.println("\nVisited some of the countries");
travelers.stream().filter(or)
    .forEach(t -> System.out.println(t.traveler));

Prints

Filtering on: [US, Maldives]

Visited all of the countries
John

Visited some of the countries
John
Emma

The class supporting class

class Traveler {
    String traveler;
    List<String> countries;

    public String toString() {
        return traveler + " => " + countries.toString();
    }
}

Instead of sorting, iterate twice, once for the AND matches and once for the OR matches:

// Say you have a list of MyValueObject type called travelers
ArrayList<MyValueObject> copyTravelers = new ArrayList<>(travelers);
List<MyValueObject> filtered = new ArrayList<>();

// AND
for (MyValueObject t : copyTravelers) {
    MyValueObject traveler = t;
    for (String country : countryFilter)
        if (!traveler.countryTags.contains(country)) {
            traveler = null;
            break;
        }
    if (traveler != null) {
        filtered.add(traveler);
        copyTravelers.remove(traveler);
    }
}

// OR
for (MyValueObject t : copyTravelers) {
    for (String country : countryFilter)
        if (traveler.countryTags.contains(country)) {
            filtered.add(t);
            copyTravelers.remove(t);
            break;
        }
}

i tried an approach where you get an ordered Map of country matches:

public Map<Long, String> sortMatches(List<MyValueObject> travellers, List<String> countries){

        TreeMap<Long, List> collect = travellers.stream()
                .flatMap(t -> t.countries.stream()
                        .filter(c -> countries.contains(c))
                        .map(c -> t.getTravellerName())
                        .collect(groupingBy(Function.identity(), counting()))
                .entrySet()
                .stream()
                ).collect(groupingBy(
                        e -> e.getValue(),
                        TreeMap::new,
                        listCollector
                ));
        return collect;
}

first the matches are counted and written to a temporary Map<String, Long> where the String is the travellerName and as value there is the match count of this traveller.

in a second step a new map is created which stores as key the amount of matches and as values the travellerNames of the travellers who have visited so many countries. therefore, the listCollector is used:

Collector<Map.Entry, List, List> listCollector =
    Collector.of(ArrayList::new,
                (l, e) -> l.add(e.getKey()), 
                (l1, l2) -> { l1.addAll(l2); return l1;});