如何对 ArrayList<ArrayList<String>> 进行排序？

Question

所以我正在为我正在为学校工作的程序开发广度优先搜索功能，当我通过给定节点的传出边缘时，凭借我如何通过我的可能边缘，它看起来像这样：

[[A, 1], [D, 1], [C, 2], [D, 2]]

但我真正想要的是：

[[A, 1], [C, 2], [D, 1], [D, 2]]

其中第一个索引是边缘指向的节点的名称，第二个索引是边缘的标签。本质上，我想按字母顺序遍历这些边缘，首先按节点名称，然后按标签名称，但我不知道该怎么做，因为 Collections.sort() 不适用于 2D ArrayList。关于排序的好方法的任何指针/想法？谢谢大家！

编辑：我使用的是 JRE 1.7，而不是 1.8

Answer 1

这是完整的工作代码。 在 java SDK8 中使用 lambda 表达式。

如您所见，我添加了一个简单的类和一个比较器。这既简单又强大。

package com.rizze.test.labs.sof;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import org.junit.Test;

public class SOF {    

    public static class Link {
        public String name;
        public int id;

        public static Link build(String n, int i){
            Link l = new Link();
            l.name = n;
            l.id=i;
            return l;
        }

        public String toString(){
            return String.format("[%s , %d]", name,id);
        }           
    }       

    @Test
    public void test() {

        List<Link> links = new ArrayList<Link>();

        //SSETUP [[A, 1], [C, 2], [D, 1], [D, 2]]
        links.add(Link.build("D", 1));
        links.add(Link.build("A", 1));
        links.add(Link.build("D", 2));
        links.add(Link.build("C", 2));


        Collections.sort(links, new Comparator<Link>() {    
            @Override
            public int compare(Link p1, Link p2) {
                int ret = p1.name.compareTo(p2.name);
                if(ret == 0) {
                    ret= p1.id - p2.id;
                }
                return ret;             
            }               
        });
        System.out.println(links);          
    }    
}

//控制台输出

Before : [[D , 1], [A , 1], [D , 2], [C , 2]]
Sorted: [[A , 1], [C , 2], [D , 1], [D , 2]]

//GIST 链接 https://gist.github.com/jeorfevre/cbcd7dac5d7fabde6a16db83bdfb7ef5

Answer 2

@jeorfevre 答案完全可以。您没有提到 Java 版本，但我会使用静态 Comparator 方法。

解决方案将是声明性的，并以简洁的方式为您提供更多控制和清晰：

public class Test {
    public static class Edge {
        private String name;
        private int label;
        public Edge(String name, int id) {
            this.name = name;
            this.label = id;
        }
        public String toString() {
            return String.format("[%s , %d]", name, label);
        } 
        public String getName() { return name; } 
        public int getLabel() { return label; }
    }


    public static void main(String[] args) {
        List<Edge> edges = new ArrayList<>();
        edges.add(new Edge("D", 1));
        edges.add(new Edge("A", 1));
        edges.add(new Edge("D", 2));
        edges.add(new Edge("C", 2));

        Comparator<Edge> comparator = Comparator
                .comparing(Edge::getName)
                .thenComparing(Edge::getLabel);

        edges.sort(comparator);

        System.out.println(edges);
    }
}

如果你想颠倒顺序：

            Comparator<Edge> comparator = Comparator
                .comparing(Edge::getName)
                .thenComparing(Edge::getLabel)
                .reversed();

给你：

[[D , 2], [D , 1], [C , 2], [A , 1]]

和

            Comparator<Edge> comparator = Comparator
                .comparing(Edge::getName)
                .reversed()
                .thenComparing(Edge::getLabel);

输出是： [[D, 1], [D, 2], [C, 2], [A, 1]]