Java如何使用整数集对对象列表进行排序

Question

I have a list of generic objects with some attributes and one of them it is a Set (treeSet) of Integers.

class GenericObject{
    Set<Integer> orderNumbers = new TreeSet<>();
    Other attributes...
}

I want to order this list of generic objects comparing the Set... example:

My actual List list;
GenericObject with Set --> 2,3,4
GenericObject with Set --> 1,2
GenericObject with Set --> 4,5
GenericObject with Set --> 2,3

I want order the list of object like that:
1) 1,2
2) 2,3
3) 2,3,4
4) 4,5

I am trying to implements the Comparator of GenericObject and Overriding the method compare but I have not got it.

Thanks, I'll be waiting for your answers

Answer 1

Since orderNumbers is a Set the elements will be arranged in their natural order, so you can compare the first elements and size of it. Here is the comparator:

(a, b) -> {

    Integer nexta = a.orderNumbers.iterator().next(),
            nextb = b.orderNumbers.iterator().next();

    if( nexta == nextb ) {
        return a.orderNumbers.size() > b.orderNumbers.size() ? 1 : -1;
    }

    return Integer.compare(nexta, nextb);
}

DEMO

Answer 2

In the GenericObject Comparator you will have to compare one by one the Integers contained in the Set s.
You should rely on the Integer comparable method but for the specific case (same elements but one additional), where the set with less elements should be placed before in the order.
It should be the most direct efficient approach in terms of time.

If performance is not a need (few list and few elements), you could accumulate the Integer s of the List in a String and perform a lexicographical comparison as finally that is what you need.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;

class GenericObject {

    private Set<Integer> orderNumbers;

    public GenericObject(Set<Integer> treeSet) {
        this.orderNumbers = treeSet;
    }
    // Other attributes...

    public static void main(String[] args) {

        List<GenericObject> list = new ArrayList<>();
        list.add(new GenericObject(new TreeSet<>(Arrays.asList(2, 3, 4))));
        list.add(new GenericObject(new TreeSet<>(Arrays.asList(1, 2))));
        list.add(new GenericObject(new TreeSet<>(Arrays.asList(4, 5))));
        list.add(new GenericObject(new TreeSet<>(Arrays.asList(2, 3))));

        list.sort(new Comparator<GenericObject>() {

            @Override
            public int compare(GenericObject o1, GenericObject o2) {

                String o1String = o1.orderNumbers.stream()
                                                 .map(Object::toString)
                                                 .reduce("", String::concat);

                String o2String = o2.orderNumbers.stream()
                                                 .map(Object::toString)
                                                 .reduce("", String::concat);

                return o1String.compareTo(o2String);
            }
        });

        System.out.println(list);
    }

    @Override
    public String toString() {
        return "GenericObject [orderNumbers=" + orderNumbers + "]";
    }
}

Output :

[GenericObject [orderNumbers=[1, 2]], GenericObject [orderNumbers=[2, 3]], GenericObject [orderNumbers=[2, 3, 4]], GenericObject [orderNumbers=[4, 5]]]