用不同长度的1D列表对Java中的2D arraylist进行排序

我一直在尝试使用自定义的

比较器
对二维
数组列表进行字典排序。但是每个1D列表的长度都不一样，所以我没有得到预期的结果。这是我的代码：

List a=new ArrayList（）；
ArrayList a1=新的ArrayList（）；
ArrayList a2=新的ArrayList（）；
ArrayList a3=新的ArrayList（）；
ArrayList a4=新的ArrayList（）；
a1.加入第（1）款；
a2.加入第（1）款；
a2.加入第（3）款；
a3.加入第（1）款；
a3.加入（2）；
a3.加入（3）；
a、 添加（a1）；
a、 添加（a2）；
a、 增加（a3）；
Collections.sort（一个新的Comparator（）{
@凌驾
公共整数比较（ArrayList a、ArrayList b）{
如果（a.get（0）

所以输入是
[[1]，[1,3]，[1,2,3]]

我的输出是
[[1,2,3]，[1,3]，[1]]

预期输出为
[[1]，[1,2,3]，[1,3]]

请指出使代码正常工作所需的错误和添加内容
您正试图定义一个自定义的
比较器
对二维整数
数组列表
进行排序，比较两个1d
数组列表
的两个
字符串
表示：例如使用
数组列表
[1]
和
[1,3]
您将比较字符串
“1”
和
“13”
。这可以通过使用流和
字符串来获得。下面的
方法的值，我假设您没有空整数
ArrayList
：

Collections.sort(a, new Comparator<List<Integer>>() {
    @Override
    public int compare(List<Integer> a, List<Integer> b) {
        String j1 = a.stream().map(String::valueOf).collect(Collectors.joining(""));
        String j2 = b.stream().map(String::valueOf).collect(Collectors.joining(""));

        return j1.compareTo(j2);
    }
});

Collections.sort（一个新的比较器（）{
@凌驾
公共整数比较（列表a、列表b）{
字符串j1=a.stream（）.map（字符串：：valueOf）.collect（收集器.joining（“”））；
字符串j2=b.stream（）.map（字符串：：valueOf）.collect（收集器.joining（“”））；
返回j1.compareTo（j2）；
}
});

这将生成预期的有序输出。
您正试图定义一个自定义的
比较器
对二维整数
数组列表进行排序
比较两个1d
数组列表的两个
字符串
表示：例如使用
数组列表
[1]
和
[1,3]
您将比较字符串
“1”
和
“13”
。这可以使用流和
字符串来获得。下面的
方法的值，我假设您没有空整数
ArrayList
：

Collections.sort(a, new Comparator<List<Integer>>() {
    @Override
    public int compare(List<Integer> a, List<Integer> b) {
        String j1 = a.stream().map(String::valueOf).collect(Collectors.joining(""));
        String j2 = b.stream().map(String::valueOf).collect(Collectors.joining(""));

        return j1.compareTo(j2);
    }
});

Collections.sort（一个新的比较器（）{
@凌驾
公共整数比较（列表a、列表b）{
字符串j1=a.stream（）.map（字符串：：valueOf）.collect（收集器.joining（“”））；
字符串j2=b.stream（）.map（字符串：：valueOf）.collect（收集器.joining（“”））；
返回j1.compareTo（j2）；
}
});

这将生成您预期的有序输出。
首先确定要比较的列表中的哪一个较短。例如，您可以使用方法
Math.min（int a，int b）来确定这一点
。然后将第一个列表的每个元素与第二个列表的相应元素进行比较。如果它们不相等，则返回此比较的结果。如果所有元素都相等，则比较列表的长度并返回此值

List<List<Integer>> listOfLists = new ArrayList<>();
List<Integer> listOne = new ArrayList<>();
listOne.add(1);

List<Integer> listTwo = new ArrayList<>();
listTwo.add(1);
listTwo.add(2);
listTwo.add(3);

List<Integer> listThree = new ArrayList<>();
listThree.add(1);
listThree.add(3);

listOfLists.add(listOne);
listOfLists.add(listTwo);
listOfLists.add(listThree);
    
Collections.sort(listOfLists, new Comparator<List<Integer>>() {
    @Override
    public int compare(List<Integer> first, List<Integer> second) {
        int comp = 0;
        for(int i = 0; i < Math.min(first.size(), second.size()); i++){
            comp = Integer.compare(first.get(i), second.get(i));
            if(comp != 0){
                return comp;
            }
         }
         return Integer.compare(first.size(), second.size());
    }
});
System.out.println(listOfLists);

listOfLists=newarraylist（）；
List listOne=new ArrayList（）；
增加（1）；
List listTwo=新的ArrayList（）；
清单二.增加（1）；
清单2.添加（2）；
清单二.增加（3）；
List listThree=新的ArrayList（）；
清单3.添加（1）；
清单3.添加（3）；
添加（listOne）；
添加（列表二）；
添加（列表三）；
Collections.sort（listOfLists，newcomparator（）{
@凌驾
公共整数比较（列表第一，列表第二）{
int comp=0；
对于（inti=0；i
首先确定要比较的列表中哪一个较短。例如，您可以使用方法
Math.min（int a，int b）来确定这一点
。然后将第一个列表的每个元素与第二个列表的相应元素进行比较。如果它们不相等，则返回此比较的结果。如果所有元素都相等，则比较列表的长度并返回此值

List<List<Integer>> listOfLists = new ArrayList<>();
List<Integer> listOne = new ArrayList<>();
listOne.add(1);

List<Integer> listTwo = new ArrayList<>();
listTwo.add(1);
listTwo.add(2);
listTwo.add(3);

List<Integer> listThree = new ArrayList<>();
listThree.add(1);
listThree.add(3);

listOfLists.add(listOne);
listOfLists.add(listTwo);
listOfLists.add(listThree);
    
Collections.sort(listOfLists, new Comparator<List<Integer>>() {
    @Override
    public int compare(List<Integer> first, List<Integer> second) {
        int comp = 0;
        for(int i = 0; i < Math.min(first.size(), second.size()); i++){
            comp = Integer.compare(first.get(i), second.get(i));
            if(comp != 0){
                return comp;
            }
         }
         return Integer.compare(first.size(), second.size());
    }
});
System.out.println(listOfLists);

listOfLists=newarraylist（）；
List listOne=new ArrayList（）；
增加（1）；
List listTwo=新的ArrayList（）；
清单二.增加（1）；
清单2.添加（2）；
清单二.增加（3）；
List listThree=新的ArrayList（）；
清单3.添加（1）；
清单3.添加（3）；
添加（listOne）；
添加（列表二）；
添加（列表三）；
Collections.sort（listOfLists，newcomparator（）{
@凌驾
公共整数比较（列表第一，列表第二）{
int comp=0；
对于（inti=0；i
似乎您需要词典排序。番石榴图书馆有实用方法，可以帮助您：

import com.google.common.collect.Comparators；
...
Collections.sort（a，Comparators.lexicographical（Comparator.naturalOrder（））；
似乎您需要词典排序。番石榴图书馆有实用方法，可以帮助您：

import com.google.common.collect.Comparators；
...
Collections.sort（a，Comparators.lexicographical（Comparator.naturalOrder（））；
compare方法的JavaDoc说：“比较它的两个参数的顺序。当第一个参数小于、等于或大于第二个参数时，返回一个负整数、零或正整数。-实现者必须确保sgn（compare（x，y））===-sgn（compare（y，x））