排序集合性能提示列表

Question

I have a list of collections that contains pairs, I should keep the list sorted alphabetically by it's collections pairs key, My current solution is keeping the list sorted by overriding the add method, Like the code below.

Note: the list collections pairs key are always the same like

(Car,1)(Car,1)

(Bear,1)

So i just need to get first pair key of collections to get it sorting the list

List<Collection<Pair<String, Integer>>> shufflingResult;

public void init() {
    shufflingResult = new ArrayList<>() {
        public boolean add(Collection<Pair<String, Integer>> c) {
            super.add(c);
            Collections.sort(shufflingResult, new Comparator<Collection<Pair<String, Integer>>>() {
                @Override
                public int compare(Collection<Pair<String, Integer>> pairs, Collection<Pair<String, Integer>> t1) {
                    return pairs.iterator().next().getKey().compareTo(t1.iterator().next().toString());
                }
            });
            return true;
        }
    };
}

Is this the best performance way to do what i'm looking for?

Answer 1

If the collection is already sorted and all you want to do is add. do a binary search and then just use list.add(index,element); sorting every time you want to insert is bad. you should do it once and then just maintain with good insertion order.

adding some code to show the bsearch. as the one for collections will only return matches. just supply the list. the new object. and the comparator that sorts the list how you want it. if adding many items where N> current size of the list probably better to add all then sort.

private static void add(List<ThingObject> l, ThingObject t, Comparator<ThingObject> c) {
    if (l != null) {
        if (l.size() == 0) {
            l.add(t);
        } else {
            int index = bSearch(l, t, c);
            l.add(index, t);
        }
    }
}

private static int bSearch(List<ThingObject> l, ThingObject t, Comparator<ThingObject> c) {
    boolean notFound = true;
    int high = l.size() - 1;
    int low = 0;
    int look = (low + high) / 2;
    while (notFound) {
        if (c.compare(l.get(look), t) > 0) {
            // it's to the left of look
            if (look == 0 || c.compare(l.get(look - 1), t) < 0) {
                //is it adjacent?
                notFound = false;
            } else {
                //look again.
                high = look - 1;
                look = (low + high) / 2;
            }
        } else if (c.compare(l.get(look), t) < 0) {
            // it's to the right of look
            if (look == l.size() - 1 || c.compare(l.get(look + 1), t) > 0) {
                //is it adjacent?
                look = look + 1;
                notFound = false;
            } else {
                //look again.
                low = look + 1;
                look = (low + high) / 2;
            }
        } else {
            notFound = false;
        }

    }
    return look;
}

Answer 2

Performance is a tricky thing. The best sort algorithm will depend largely on the volume and type of data, and to what degree it is random. Some algorithms are best when Data which is partially sorted, others for truly random data.

Generally speaking, worry about optimization until you've determined that working code is not sufficiently performant. Get things working first, and then determine where the bottleneck it. It may not be sorting, but something else.

Java provides good general sorting algorithms. You're using one with Collections.sort(). There is no SortedList in Java, but javafx.base contains a SortedList which wraps a supplied List and keeps is sorted based on a Comparator supplied at instantiation. This would prevent you from having to override the base behavior of the List implementation.

While your code seems like it may work, here's a couple of suggestions:

1. pairs.iterator().next().getKey() will throw an NPE if pairs is null.
2. pairs.iterator().next().getKey() will throw an NoSuchElementException if pairs is empty.
3. pairs.iterator().next().getKey() will throw an NPE if the first Pair has a null key is empty.
4. All of this is true for t1 as well.
5. You're comparing pairs.iterator().next().getKey() to t1.iterator().next().toString(). One is the String representation of the Pair, and the other is the Key from the Pair. Is this correct?

While your code may make sure these conditions never happen, someone may modify it later with resulting unpleasant surprises. You may want to add validations to your add method to ensure that these cases won't occur. Throwing IllegalArgumentException when arguments aren't valid is generally good practice.

Another thought: Since your Collection contents are always the same, and if no two Collections have the same kind of Pairs, you should be able to use a SortedMap<String, Collection<Pair<String,Integer>>> instead of a List. If you are comparing by Key this sort of Map will keep things sorted for you. You'll put the Collection using the first Pair's Key as the map/entry key. The map's keySet() , values() and entrySet() will all return Collections which iterate in sorted order.