Java 如何对ArrayList进行排序<；ArrayList<；字符串>>；？

因此，我正在为一个我正在为学校工作的程序开发广度优先搜索功能，当我通过给定节点的输出边时，根据我如何通过可能的边，它看起来像这样：

[[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。这是完整的工作代码。 在JavaSDK8中使用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);          
    }    
}

//要点链接

---

@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);
    }
}

及

比较器比较器比较器=比较器 .比较（边缘：：getName） .然后比较（Edge:：getLabel）； 输出为：

---

[D，1]，[D，2]，[C，2]，[A，1]]

[[A，1]，[D，1]，[C，2]，[D，2]

不是

ArrayList

的有效示例，您可以使用

.stream（）.sorted（）

按自然顺序排序，甚至可以定义自定义的

比较器

您可以使用HashMap而不是ArrayList…RoiEX，无法使用HashMap，因为他可以有一个具有不同值的键，或者必须是HashMap。。。这使得一些简单的东西的结构变得相当复杂。这看起来很棒！这正是我想实现的（Edge类），它让我对如何管理我的Edge有了更多的了解。我的下一个问题是，因为我不是在Edge类中处理这些边，而是在一个完全不同的类中处理这些边，所以我将把比较器放在哪里？它会进入我目前使用的任何函数中吗？抱歉，我对Java比较陌生，对comparators也非常陌生。另外，我对命令Edge:：getName和Edge:：getLabel有一个问题，因为在这个作业中，我的教授希望我们使用JRE 1.7，而不是1.8。使用JRE 1.7是否有其他方法来实现这一点？

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);