Java 如何在ArrayList中对数组进行排序？

我有一个ArrayList，它包含很多数组，每个数组都包含名字和姓氏。现在我想根据姓氏对列表进行排序

例如：

ArrayList<String[]> list=new ArrayList<String[]>();
 String[] name1={"koti" ,"reddy"};
 String[] name2={"hanu" ,"sanjay"};
 String[] name3={"ajay" ,"zedeja"};
 String[] name4={"basha" ,"kadhar"};

 list.add(name1);
 list.add(name2);
 list.add(name3);
 list.add(name4);

请您尽快提供帮助，提前谢谢

编写一个自定义文件，并将其与数据一起提供给适当的重载

但是，我建议使用一个单独的

Person/Name

类型，而不是字符串数组，因为它将使数据更易于跟踪，并且可以实现（这将消除/取代对比较器的需要）

现在，在将适用的

比较/比较写入
时，代码应类似于：

int cmpLastName = a_lastName.compareTo(b_lastName);
if (cmpLastName == 0) {
    // same lastname, order now based on first name
    return a_firstName.compareTo(b_firstName);
} else {
    // different lastname, so have enough ordering
    return cmpLastName;
}

编写一个自定义文件，并将其与数据一起提供给相应的重载

但是，我建议使用一个单独的
Person/Name
类型，而不是字符串数组，因为它将使数据更易于跟踪，并且可以实现（这将消除/取代对比较器的需要）

现在，在将适用的
比较/比较写入
时，代码应类似于：

int cmpLastName = a_lastName.compareTo(b_lastName);
if (cmpLastName == 0) {
    // same lastname, order now based on first name
    return a_firstName.compareTo(b_firstName);
} else {
    // different lastname, so have enough ordering
    return cmpLastName;
}

这就是我执行排序操作的方式

public static void main(String[] args) {
  ArrayList<String[]> list = new ArrayList<String[]>();
  String[] name1 = { "koti", "reddy" };
  String[] name2 = { "hanu", "sanjay" };
  String[] name3 = { "ajay", "zedeja" };
  String[] name4 = { "basha", "kadhar" };

  list.add(name1);
  list.add(name2);
  list.add(name3);
  list.add(name4);

  System.out.println("Before sorting");
  for (String[] r : list) {
    System.out.println(Arrays.toString(r));
  }
  Collections.sort(list, new Comparator<String[]>() {
    public int compare(String[] left, String[] right) {
      if (left == null) { // null?
        if (right == null) { // null == null!
          return 0;
        }
        return -1; // null < not(null)
      } else if (right == null) {
        return 1; // not(null) > null.
      }
      // If the last names aren't the same, return the result
      // of comparing the last names.
      if (left[1].compareTo(right[1]) != 0) {
        return left[1].compareTo(right[1]);
      }
      // Return the result of comparing the first names.
      return left[0].compareTo(right[0]);
    }
  });
  System.out.println("After sorting");
  for (String[] r : list) {
    System.out.println(Arrays.toString(r));
  }
}

publicstaticvoidmain（字符串[]args）{
ArrayList=新建ArrayList（）；
字符串[]name1={“koti”，“reddy”}；
字符串[]name2={“哈努”，“桑杰”}；
字符串[]name3={“ajay”，“zedeja”}；
字符串[]name4={“basha”，“kadhar”}；
列表。添加（名称1）；
列表。添加（名称2）；
列表。添加（名称3）；
列表。添加（名称4）；
System.out.println（“排序前”）；
for（字符串[]r:list）{
System.out.println（Arrays.toString（r））；
}
Collections.sort（list，newcomparator（）{
公共整数比较（字符串[]左，字符串[]右）{
如果（left==null）{//null？
如果（right==null）{//null==null！
返回0；
}
return-1；//nullnull。
}
//如果姓氏不相同，则返回结果
//比较姓氏的方法。
if（左[1]。与（右[1]）！=0比较{
返回左[1]。比较（右[1]）；
}
//返回比较名字的结果。
返回左[0]。比较（右[0]）；
}
});
System.out.println（“排序后”）；
for（字符串[]r:list）{
System.out.println（Arrays.toString（r））；
}
}
这就是我执行排序操作的方式

public static void main(String[] args) {
  ArrayList<String[]> list = new ArrayList<String[]>();
  String[] name1 = { "koti", "reddy" };
  String[] name2 = { "hanu", "sanjay" };
  String[] name3 = { "ajay", "zedeja" };
  String[] name4 = { "basha", "kadhar" };

  list.add(name1);
  list.add(name2);
  list.add(name3);
  list.add(name4);

  System.out.println("Before sorting");
  for (String[] r : list) {
    System.out.println(Arrays.toString(r));
  }
  Collections.sort(list, new Comparator<String[]>() {
    public int compare(String[] left, String[] right) {
      if (left == null) { // null?
        if (right == null) { // null == null!
          return 0;
        }
        return -1; // null < not(null)
      } else if (right == null) {
        return 1; // not(null) > null.
      }
      // If the last names aren't the same, return the result
      // of comparing the last names.
      if (left[1].compareTo(right[1]) != 0) {
        return left[1].compareTo(right[1]);
      }
      // Return the result of comparing the first names.
      return left[0].compareTo(right[0]);
    }
  });
  System.out.println("After sorting");
  for (String[] r : list) {
    System.out.println(Arrays.toString(r));
  }
}

publicstaticvoidmain（字符串[]args）{
ArrayList=新建ArrayList（）；
字符串[]name1={“koti”，“reddy”}；
字符串[]name2={“哈努”，“桑杰”}；
字符串[]name3={“ajay”，“zedeja”}；
字符串[]name4={“basha”，“kadhar”}；
列表。添加（名称1）；
列表。添加（名称2）；
列表。添加（名称3）；
列表。添加（名称4）；
System.out.println（“排序前”）；
for（字符串[]r:list）{
System.out.println（Arrays.toString（r））；
}
Collections.sort（list，newcomparator（）{
公共整数比较（字符串[]左，字符串[]右）{
如果（left==null）{//null？
如果（right==null）{//null==null！
返回0；
}
return-1；//nullnull。
}
//如果姓氏不相同，则返回结果
//比较姓氏的方法。
if（左[1]。与（右[1]）！=0比较{
返回左[1]。比较（右[1]）；
}
//返回比较名字的结果。
返回左[0]。比较（右[0]）；
}
});
System.out.println（“排序后”）；
for（字符串[]r:list）{
System.out.println（Arrays.toString（r））；
}
}
试试这个

    Collections.sort(list, new Comparator<String[]>() {
        @Override
        public int compare(String[] o1, String[] o2) {
            int c = o1[0].compareTo(o2[0]);
            if (c != 0) {
                return c;
            }
            return o1[1].compareTo(o2[1]);
        }
    });

Collections.sort（列表，新比较器（）{
@凌驾
公共整数比较（字符串[]o1，字符串[]o2）{
int c=o1[0]。与（o2[0]）相比；
如果（c！=0）{
返回c；
}
返回o1[1]。比较（o2[1]）；
}
});
试试这个

    Collections.sort(list, new Comparator<String[]>() {
        @Override
        public int compare(String[] o1, String[] o2) {
            int c = o1[0].compareTo(o2[0]);
            if (c != 0) {
                return c;
            }
            return o1[1].compareTo(o2[1]);
        }
    });

Collections.sort（列表，新比较器（）{
@凌驾
公共整数比较（字符串[]o1，字符串[]o2）{
int c=o1[0]。与（o2[0]）相比；
如果（c！=0）{
返回c；
}
返回o1[1]。比较（o2[1]）；
}
});
尝试此代码以实现输出

public static void main(String []args){
           ArrayList<String[]> list=new ArrayList<String[]>();
     String[] name1={"koti" ,"reddy"};
     String[] name2={"hanu" ,"sanjay"};
     String[] name3={"ajay" ,"zedeja"};
     String[] name4={"basha" ,"kadhar"};

     list.add(name1);
     list.add(name2);
     list.add(name3);
     list.add(name4);
     Collections.sort(list, new Comparator<String[]>() {
            @Override
            public int compare(String[] s1, String[] s2) {
                int i = s1[0].compareTo(s2[0]);
                if (i != 0) {
                    return i;
                }
                return s1[1].compareTo(s2[1]);
            }
        });
     System.out.println("after sorting"+"\n");
     for (String[] s : list) {
         for(int i=0;i<s.length;i++){ 
         System.out.print(s[i]+"\t");
         }
         System.out.print("\n");
        }



}

publicstaticvoidmain（字符串[]args）{
ArrayList=新建ArrayList（）；
字符串[]name1={“koti”，“reddy”}；
字符串[]name2={“哈努”，“桑杰”}；
字符串[]name3={“ajay”，“zedeja”}；
字符串[]name4={“basha”，“kadhar”}；
列表。添加（名称1）；
列表。添加（名称2）；
列表。添加（名称3）；
列表。添加（名称4）；
Collections.sort（list，newcomparator（）{
@凌驾
公共整数比较（字符串[]s1，字符串[]s2）{
int i=s1[0]。比较（s2[0]）；
如果（i！=0）{
返回i；
}
返回s1[1]。比较（s2[1]）；
}
});
System.out.println（“排序后”+“\n”）；
对于（字符串[]s:list）{
对于（inti=0；i请尝试使用此代码来实现输出

public static void main(String []args){
           ArrayList<String[]> list=new ArrayList<String[]>();
     String[] name1={"koti" ,"reddy"};
     String[] name2={"hanu" ,"sanjay"};
     String[] name3={"ajay" ,"zedeja"};
     String[] name4={"basha" ,"kadhar"};

     list.add(name1);
     list.add(name2);
     list.add(name3);
     list.add(name4);
     Collections.sort(list, new Comparator<String[]>() {
            @Override
            public int compare(String[] s1, String[] s2) {
                int i = s1[0].compareTo(s2[0]);
                if (i != 0) {
                    return i;
                }
                return s1[1].compareTo(s2[1]);
            }
        });
     System.out.println("after sorting"+"\n");
     for (String[] s : list) {
         for(int i=0;i<s.length;i++){ 
         System.out.print(s[i]+"\t");
         }
         System.out.print("\n");
        }



}

publicstaticvoidmain（字符串[]args）{
ArrayList=新建ArrayList（）；
字符串[]name1={“koti”，“reddy”}；
字符串[]name2={“哈努”，“桑杰”}；
字符串[]name3={“ajay”，“zedeja”}；
字符串[]name4={“basha”，“kadhar”}；
列表。添加（名称1）；
列表。添加（名称2）；
列表。添加（名称3）；
列表。添加（名称4）；
Collections.sort（list，newcomparator（）{
@凌驾
公共整数比较（字符串[]s1，字符串[]s2）{
int i=s1[0]。比较（s2[0]）；
如果（i！=0）{
返回i；
}
返回s1[1]。比较（s2[1]）；
}
});
System.out.println（“排序后”+“\n”）；
对于（字符串[]s:list）{
对于（int i=0；i检查有关集合的更多信息检查有关集合的更多信息