如何根据 Java 中的某些条件对自定义对象的无序列表进行排序

Question

@Data    
public class DocumentObject {
        public String current;
        public String next;
    
    }
    
    public static void main(String[] args) {
            //Unordered list of objects
            List<DocumentObject> list = Arrays.asList(
                    new DocumentObject("pnp","xyz"),
                    new DocumentObject("z","pnp"),
                    new DocumentObject("123","d"),
                    new DocumentObject("xyz","123"));
            //Expecting ordered list to be returned based on some conditions
            System.out.println(sortingLogic(list));
                    
        }
    
        private static List<DocumentObject> sortingLogic(List<DocumentObject> list) {
            if (list.size() > 0) {
//THIS APPROACH NOT WORKING :(
                  Collections.sort(list, new Comparator<DocumentObject>() {
                      @Override
                      public int compare(DocumentObject o1, DocumentObject o2) {
                          int index1 = list.indexOf(o1.getCurrent());
                          int index2 = list.indexOf(o2.getNext());
    
                          return Integer.compare(index2 , index1);
                      }
                  });
            }
            return list;
        }

//My Expected output
[{"z","pnp"},
{"pnp","xyz"},
{"xyz","123"},
{"123","d"}]

so the logic should be like first object must be {"z","pnp"} as current("z") there is no object where next is ("z"), so it should be first object after sorting. Then last object after sorting should be {"123","d"}, since there next("d"), there doestn exist any object whose current("d"), so its last object. The remaining objects are sorted in the middle based on their next and current properties.

How can i acheive this?

Answer 1

Rather than using a comparator to sort them, this solution considers this as an ordering problem and re-orders the list into a new list in O(n) time.

First, it builds a Map<String, DocumentObject> from the input list. Next, it gets all the keys of the map as a Set (all current values in the list of DocumentObject s) and then removes all the next elements from the set. This leaves only one element in the set which will be the root or first element (since it didn't have any DocumentObject instance with its value as the next ). Thinking in graph terminology, this element is the only element whose in-degree is 0.

Finally, starting from the root element, we build the ordered list (using the auxiliary map) by traversing the elements as per the next value of the current (previous) element.

private static List<DocumentObject> sortingLogic(List<DocumentObject> list) {
    Map<String, DocumentObject> map = list.stream()
            .collect(Collectors.toMap(DocumentObject::getCurrent, Function.identity()));

    Set<String> allCurrent = new HashSet<>(map.keySet());
    map.values()
                .forEach(documentObject -> 
                        allCurrent.remove(documentObject.getNext()));

    // The only 'current' value which is not present as next in any of the other entries
    String root = allCurrent.iterator().next();
    List<DocumentObject> orderedDocumentObjects = new ArrayList<>();
    orderedDocumentObjects.add(map.get(root));
        
    for (int i = 1; i < list.size(); i++) {
        String next = orderedDocumentObjects.get(i - 1).getNext();
        orderedDocumentObjects.add(map.get(next));
    }
    return orderedDocumentObjects;
}