Java 对字符串数组列表进行排序

我收到一个字符串数组列表

String[] sa1 = {"120", "John" , "30" , "[\"science\",\"arts\"]"};
String[] sa2 = {"20", "Michael" , "29" , "[\"commerce\",\"engineering\"]"};
String[] sa3 = {"20", "Andrew" , "31" , "[\"science\",\"engineering\"]"};

我收到的列表包含这些类型的数组。 我目前用于排序的方法是：

Collections.sort(nameL, new Comparator<String[]>() {

        @Override
        public int compare(String[] o1, String[] o2) {


            return Arrays.toString(o1).compareTo(Arrays.toString(o2));
        }
    });

但是如果sa1是这样的，那么sa2和sa3在相同的位置也会有整数

目的是按第一个排序，如果相同，则按第二个排序，依此类推：

所需输出：

{"20", "Andrew" , "31" , "[\"science\",\"engineering\"]"}
{"20", "Michael" , "29" , "[\"commerce\",\"engineering\"]"},
{"120", "John" , "30" , "[\"science\",\"arts\"]"}

---

如果我理解正确，您需要一个多标准排序，那么比较器的技巧是索引0处的元素是表示整数的字符串，因此最好将它们解析为整数

    List<String[]> nameL = Arrays.asList(sa1, sa2, sa3);
    Collections.sort(nameL, (o1, o2) -> {
        if (o1[0].equals(o2[0])) {
            if (o1[1].equals(o2[1])) {

                return o1[2].compareTo(o2[2]);

            } else {
                return o1[1].compareTo(o2[1]);
            }
        } else {
            return Integer.compare(Integer.parseInt(o1[0]), Integer.parseInt(o2[0]));
        }
    });
    for (String[] strings : nameL) {
        System.out.println(Arrays.toString(strings));
    }

List-nameL=Arrays.asList（sa1、sa2、sa3）；
集合.排序（名称，（o1，o2）->{
如果（o1[0]。等于（o2[0]））{
如果（o1[1]。等于（o2[1]））{
返回o1[2]。比较（o2[2]）；
}否则{
返回o1[1]。比较（o2[1]）；
}
}否则{
返回Integer.compare（Integer.parseInt（o1[0]），Integer.parseInt（o2[0]）；
}
});
for（字符串[]字符串：nameL）{
System.out.println（Arrays.toString（strings））；
}

您可以试试这样的方法

Comparator<String[]> comparator = Comparator.comparing(array -> {
                                      try {
                                          return Integer.parseInt(array[0]);
                                      } catch (Exception ex) {
                                          return array[0];
                                      }
                                  });

// if all arrays have equal first elements, use the next elements to sort on
String[] firstArray = yourListOfArrays.get(0);
// i starts at 1 because we've used 0 already to create the comparator
for (int i = 1; i < firstArray.length; i++) {
    // i is changing on each iteration, so Java will not allow i
    // to be used inside a lamda
    int index = i;
    comparator.thenComparing(array -> try {
                                          return Integer.parseInt(array[index]);
                                       } catch (Exception ex) {
                                          return array[index];
                             });
}

yourListOfArrays.sort(comparator);

比较器比较器=比较器。比较（数组->{ 试一试{ 返回整数.parseInt（数组[0]）； }捕获（例外情况除外）{ 返回数组[0]； } }); //如果所有数组的第一个元素相等，请使用下一个元素进行排序 String[]firstArray=yourlistofArray.get（0）； //我从1开始，因为我们已经使用了0来创建比较器 for（int i=1；i尝试{ 返回Integer.parseInt（数组[index]）； }捕获（例外情况除外）{ 返回数组[索引]； }); } 排序（比较器）； 你可以这样做。 首先找出整数的位置。说到这里，你就知道你的字符串在哪里了。然后首先按字符串排序，然后按整数排序

public static void main(String[] args) {

    String[] sa1 = {"John", "120", "30", "[\"science\",\"arts\"]"};
    String[] sa2 = {"Michael", "20", "29", "[\"commerce\",\"engineering\"]"};
    String[] sa3 = {"Andrew", "20", "31", "[\"science\",\"engineering\"]"};
    String[] sa4 = {"Peter", "2020", "31", "[\"science\",\"engineering\"]"};
    String[] sa5 = {"Bob", "99", "31", "[\"science\",\"engineering\"]"};
    String[] sa6 = {"Frank", "333", "31", "[\"science\",\"engineering\"]"};

    List<String[]> nameL = new ArrayList<>();
    nameL.add(sa1);
    nameL.add(sa2);
    nameL.add(sa3);
    nameL.add(sa4);
    nameL.add(sa5);
    nameL.add(sa6);

    int positionInteger = 0;
    int positionString = 0;

    for (int i = 0; i < sa1.length; i++) {
        if (isNumeric(sa1[i])) {
            positionInteger = i;
            if(i == 0){
                positionString = 1;
            }
            break;
        }
    }


    final int pInteger = positionInteger;
    final int pString = positionString;

    Collections.sort(nameL, new Comparator<String[]>() {

        @Override
        public int compare(String[] o1, String[] o2) {
            return o1[pString].compareTo(o2[pString]);
        }
    });


    Collections.sort(nameL, new Comparator<String[]>() {
        public int compare(String[] o1, String[] o2) {

            if(Integer.parseInt(o1[pInteger]) - Integer.parseInt(o2[pInteger]) == 0)
            {
                return 0;
            }

            if(Integer.parseInt(o1[pInteger]) - Integer.parseInt(o2[pInteger]) > 0)
            {
                return 1;
            }

            if(Integer.parseInt(o1[pInteger]) - Integer.parseInt(o2[pInteger]) < 0)
            {
                return -1;
            }

            return 0;
        }
    });

    for (String[] str : nameL) {
      System.out.println(Arrays.toString(str));
    }
}

private static boolean isNumeric(String value)
{
    boolean isNumeric = false;

    try
    {
        int probe = Integer.parseInt(value);
        isNumeric = true;

    }catch(Exception e)
    {
        // do nothing
    }

    return isNumeric;
}

publicstaticvoidmain（字符串[]args）{
字符串[]sa1={“约翰”、“120”、“30”、“科学”、“艺术”]}；
字符串[]sa2={“迈克尔”、“20”、“29”、“商业”、“工程”]>；
字符串[]sa3={“安德鲁”、“20”、“31”、“科学”、“工程”]>；
字符串[]sa4={“彼得”、“2020”、“31”、“科学”、“工程”]>；
字符串[]sa5={“Bob”、“99”、“31”、“科学”、“工程”]>；
字符串[]sa6={“Frank”、“333”、“31”、“科学”、“工程”]>；
List nameL=new ArrayList（）；
名称添加（sa1）；
名称添加（sa2）；
名称添加（sa3）；
名称添加（sa4）；
名称添加（sa5）；
名称添加（sa6）；
int-positionInteger=0；
int positionString=0；
对于（int i=0；i0
{
返回1；
}
if（Integer.parseInt（o1[pInteger]）-Integer.parseInt（o2[pInteger]）<0
{
返回-1；
}
返回0；
}
});
for（字符串[]str:nameL）{
System.out.println（Arrays.toString（str））；
}
}
私有静态布尔值isNumeric（字符串值）
{
布尔值isNumeric=false；
尝试
{
int probe=Integer.parseInt（值）；
isNumeric=真；
}捕获（例外e）
{
//无所事事
}
返回是数字；
}

表示整数的字符串的位置未知，它们可以位于任意位置position@QO23所有其他字符串不仅仅是数字吗？我的意思是如果

sa1={“20”、“安德鲁”、“31”、“科学”、“工程”]

那么所有其他字符串的格式都相同，如果

sa1={“约翰”、“120”、“30”、“科学”、“艺术”}

将字符串整数放在第二个位置，那么所有其他字符串的格式都相同。字符串整数在字符串数组中的位置未知。我明白你的意思，因为字符串数组的大小未知，所以我对其进行了轻微修改，并调用了一个递归函数，该函数从if其他类似于

compareInt=o1[index].compareTo（o2[index]）；if（compareInt==0）{index=index+1；compareInt=sortRecursive（o1，o2，index）；}

这解决了我的问题，谢谢

public static void main(String[] args) {

    String[] sa1 = {"John", "120", "30", "[\"science\",\"arts\"]"};
    String[] sa2 = {"Michael", "20", "29", "[\"commerce\",\"engineering\"]"};
    String[] sa3 = {"Andrew", "20", "31", "[\"science\",\"engineering\"]"};
    String[] sa4 = {"Peter", "2020", "31", "[\"science\",\"engineering\"]"};
    String[] sa5 = {"Bob", "99", "31", "[\"science\",\"engineering\"]"};
    String[] sa6 = {"Frank", "333", "31", "[\"science\",\"engineering\"]"};

    List<String[]> nameL = new ArrayList<>();
    nameL.add(sa1);
    nameL.add(sa2);
    nameL.add(sa3);
    nameL.add(sa4);
    nameL.add(sa5);
    nameL.add(sa6);

    int positionInteger = 0;
    int positionString = 0;

    for (int i = 0; i < sa1.length; i++) {
        if (isNumeric(sa1[i])) {
            positionInteger = i;
            if(i == 0){
                positionString = 1;
            }
            break;
        }
    }


    final int pInteger = positionInteger;
    final int pString = positionString;

    Collections.sort(nameL, new Comparator<String[]>() {

        @Override
        public int compare(String[] o1, String[] o2) {
            return o1[pString].compareTo(o2[pString]);
        }
    });


    Collections.sort(nameL, new Comparator<String[]>() {
        public int compare(String[] o1, String[] o2) {

            if(Integer.parseInt(o1[pInteger]) - Integer.parseInt(o2[pInteger]) == 0)
            {
                return 0;
            }

            if(Integer.parseInt(o1[pInteger]) - Integer.parseInt(o2[pInteger]) > 0)
            {
                return 1;
            }

            if(Integer.parseInt(o1[pInteger]) - Integer.parseInt(o2[pInteger]) < 0)
            {
                return -1;
            }

            return 0;
        }
    });

    for (String[] str : nameL) {
      System.out.println(Arrays.toString(str));
    }
}

private static boolean isNumeric(String value)
{
    boolean isNumeric = false;

    try
    {
        int probe = Integer.parseInt(value);
        isNumeric = true;

    }catch(Exception e)
    {
        // do nothing
    }

    return isNumeric;
}