对具有可比性和比较器的对象的 ArrayList 进行排序

在本教程中，我们将了解如何使用 java.lang.Comparable 和 java.util.Comparator 两个接口对包含对象的 ArrayList 进行排序。如果你的程序需要对 String 或 Integer 的 ArrayList 进行排序，最好查看以下两篇文章：

- 对字符串或整数进行排序 ArrayList
- 按降序对 ArrayList 进行排序

当您想通过使用预定义方法比较两个对象来对对象列表进行排序时，将使用可比较接口 object1.compareTo（object2）.

使用 Comparable

对 ArrayList 进行排序首先，让我们看看对象的 arraylist 的排序结果，而没有实现 Comparable 接口。

让我们创建一个Employe.java类：

public class Employee {
 
 private String name;
 私人年龄;
 私人长薪;
 
 public String getName（） {
 return name;
 }
 
 public int getAge（） {
 return age;
 }
 
 public long getSalary（） {
 return salary;
 }
 
 public Employee（String name， int age， int salary） {
 this.name = name;
 this.age = 年龄;
 this.salary = 薪水;
 }
 
 @Override
 //此方法显示员工信息
 public String toString（） {
 return [name=” + this.name + ， age=” + this.age + ， salary=” +
 this.salary + ]”;
 }
}

我们想要创建一个 ArrayList 列表：

import java.util.ArrayList;
import java.util.Collections;

public class ArrayListComparable {

 public static void main（String[] args） {
 ArrayList<员工>arraylist = 新的 ArrayList<员工>();
 arraylist.add（new Employe（mateo”， 32， 20000））;
 arraylist.add（new Employe（katia”， 26， 10000））;
 arraylist.add（new Employe（aline”， 30， 40000））;
 arraylist.add（new Employe（salim”， 28， 35000））;
 
 System.out.println（员工有序列表：\n”+Collections.sort（arraylist））;
 }
}

调用 Collections.sort（）会导致问题，因为它是在对象的 ArrayList 上完成的，除非同时使用 Comparable 和 Comparator 接口，否则该对象不起作用。出现编译错误：

线程main”中的异常 java.lang.Error：未解决的编译问题：
 参数类型未定义运算符 + String， void
 绑定不匹配：Collections 类型的泛型方法 sort（List） 不适用于参数 （ArrayList）。推断类型 Employe 不是有界参数 >

 at ArrayListComparable.main（ArrayListComparable.java：14）

现在你一定已经了解了这两个接口的重要性。

假设我们想按属性对列表进行排序：员工的工资。这可以通过实现 Comparable 接口来完成，然后 java 会自动比较 compareTo（）declared Override.

在 Employe.java 类中实现 Comparable 接口后，结果如下：

public class Employe 实现 Comparable<员工>{
 
 private String name;
 私人年龄;
 私人长薪;
 
 public String getName（） {
 return name;
 }
 
 public int getAge（） {
 return age;
 }
 
 public long getSalary（） {
 return salary;
 }
 
 public Employee（String name， int age， int salary） {
 this.name = name;
 this.age = 年龄;
 this.salary = 薪水;
 }
 
 @Override
 //此方法显示员工信息
 public String toString（） {
 return [name=” + this.name + ， age=” + this.age + ， salary=” +
 this.salary + ]”;
 }

 @Override
 public int compareTo（Employee emp） {
 //如果该员工的年龄
 //低于对象，则按年龄对员工进行排序 croiddant
 ///如果该员工的年龄br / //低于对象，则逆向为负整数、零整数或正整数
 return （this.age - emp.age）;
 }
}

现在我们有权调用该方法 Collections.sort（）：

import java.util.ArrayList;
import java.util.Collections;

public class ArrayListComparable {

 public static void main（String[] args） {
 ArrayList<员工>arraylist = 新的 ArrayList<员工>();
 
 arraylist.add（new Employe（mateo”， 32， 20000））;
 arraylist.add（new Employe（katia”， 26， 10000））;
 arraylist.add（new Employe（aline”， 30， 40000））;
 arraylist.add（new Employe（salim”， 28， 35000））;
 
 Collections.sort（arraylist）;
 
 System.out.println（按年龄划分的员工有序列表：\n”）;
 for（员工 e：arraylist）
 System.out.println（e）;
 }
}

当我们运行这段代码时，我们将得到以下结果：

按年龄排序的员工列表：

[name=katia， age=26， salary=10000]
[name=salim， 年龄=28，薪水=35000]
[姓名=aline，年龄=30，薪水=40000]
[姓名=mateo，年龄=32，薪水=20000]

使用 Comparator

如您所见，上面的员工列表是按升序排序的。但是为什么要使用比较器接口呢？因为在某些情况下，排序可能基于多个参数，这与可比性不同。例如，我们希望员工的排序基于姓名、年龄和薪水。

compare（对象 o1，对象 o2）的比较器接口接受两个对象。在我们的示例中，它必须实现三次（姓名、年龄和薪水），以便如果第一个参数小于第二个参数，则返回负整数，如果它们相等，则返回零，如果第一个参数大于第二个参数，则返回正整数。

import java.util.Comparator;

public class Employee {
 
 private String name;
 私人年龄;
 私人长薪;
 
 public String getNom（） {
 return name;
 }
 
 public int getAge（） {
 return age;
 }
 
 public long getSalary（） {
 return salary;
 }
 
 public Employee（String name， int age， int salary） {
 this.name = name;
 this.age = 年龄;
 this.salary = 薪水;
 }
 
 @Override
 //此方法显示员工信息
 public String toString（） {
 return [name=” + this.name + ， age=” + this.age + ， salary=” +
 this.salary + ]”;
 }

 /*
 * 按姓名对员工进行排序的比较器 
 */
 public static Comparator<员工>ComparatorName = 新比较器<员工>（） {
 
 @Override
 public int compare（员工 e1， 员工 e2） {
 return e1.getName（）.compareTo（e2.getName（））;
 }
 };
 /*
 * 按年龄对员工进行排序的比较器 
 */
 公共静态比较器<员工>ComparatorAge = 新的比较器<员工>（） {
 
 @Override
 public int compare（员工 e1， 员工 e2） {
 return （int） （e1.getAge（） - e2.getAge（））;
 }
 };
 /*
 * 按工资对员工进行排序的比较器 
 */
 公共静态比较器<员工>ComparatorSalary = 新的比较器<员工>（） {
 
 @Override
 public int compare（员工 e1， 员工 e2） {
 return （int） （e1.getSalary（） - e2.getSalary（））;
 }
 };
}

测试类 main：

import java.util.ArrayList;
import java.util.Collections;

public class main{

 public static void main（String[] args） {
 ArrayList<员工>arraylist = 新的 ArrayList<员工>();
 
 arraylist.add（new Employe（mateo”， 32， 20000））;
 arraylist.add（new Employe（katia”， 26， 10000））;
 arraylist.add（new Employe（aline”， 30， 40000））;
 arraylist.add（new Employe（salim”， 28， 35000））;
 
 //按名称排序
 Collections.sort（arraylist， Employee.ComparatorName）;
 
 System.out.println（按姓名列出的员工有序列表：”）;
 for（员工 e：arraylist）
 System.out.println（e）;
 
 //按年龄排序
 Collections.sort（arraylist， Employee.ComparatorAge）;
 
 System.out.println（按年龄排列的员工有序列表：”）;
 for（员工 e：arraylist）
 System.out.println（e）;
 
 //按薪水排序
 Collections.sort（arraylist， Employee.ComparatorSalary）;
 
 System.out.println（按薪水排序的员工列表：”）;
 for（员工 e：arraylist）
 System.out.println（e）;
 }
}

执行此代码给出：

按姓名排序的员工列表：
[name=aline， age=30， salary=40000]
[name=katia， age=26， salary=10000]
[name=mateo， 年龄=32， 薪水=20000]
[姓名=Salim， 年龄=28， 薪水=35000]
按年龄排序的员工名单：
[姓名=Katia， 年龄=26， 薪水=10000]
[姓名=萨利姆， 年龄=28， 薪水=35000]
[姓名=aline， 年龄=30， 薪水=40000]
[姓名=马特奥， 年龄=32， 薪水=20000]
按薪水排序的员工列表：
[姓名=Katia，年龄=26，薪水=10000]
[姓名=马特奥，年龄=32，薪水=20000]
[姓名=Salim，年龄=28，薪水=35000]
[姓名=aline，年龄=30，薪水=40000]

对具有可比性和比较器的对象的 ArrayList 进行排序

使用 Comparable

使用 Comparator

AdBlock Detected