Java LinkedList实现自定义排序的实战应用
简介：LinkedList在Java中是一个重要的数据结构，适用于列表的插入和删除操作。该实例演示了如何利用LinkedList和Comparator接口来实现人事信息系统的自定义排序功能。通过创建Employee类并实现Comparable接口，以及使用Collections.sort方法与Comparator接口，可以实现多样化的排序逻辑。从控制台输入人事信息，利用LinkedList存储和排序，最后输出排序后的人事信息列表。掌握这些技能对于处理复杂数据结构和算法非常有帮助。 
1. Java LinkedList数据结构应用
在现代软件开发中，数据结构的选择对于应用程序的性能和可扩展性至关重要。 Java LinkedList 是一种基于双向链表的高级数据结构，它提供了动态数组的高效性能。这种数据结构对于那些频繁插入和删除操作的应用场景特别有用，因为与数组相比，链表提供了更快的插入和删除速度。
1.1 LinkedList的基本特性
LinkedList 是 Java 集合框架的一部分，它实现了 List 和 Deque 接口。这意味着 LinkedList 不仅可以作为队列和栈使用，而且还可以像其他列表一样进行操作。其特性如下：
- 动态数组 ：在运行时根据需求自动扩容或缩容。
- 元素添加与删除效率高 ：在链表的任何位置进行插入和删除操作平均只需要 O(1) 的时间复杂度。
- 无容量限制 ：不同于静态数组，链表不需要预先指定大小，能有效利用内存资源。
1.2 LinkedList的应用场景
由于 LinkedList 的特性，在以下场景中，它是一个不错的选择：
- 实现队列 ：如任务处理、消息传递等系统中，使用 LinkedList 可以高效地处理先进先出（FIFO）的场景。
- 频繁插入删除操作 ：如编辑器中的撤销/重做功能，或者在图形用户界面中的菜单项管理。
接下来的章节，我们将深入探讨如何使用 LinkedList，并且结合 Java 中的其他组件来实现复杂的功能，例如排序和数据的动态输入。我们将通过代码示例和逻辑分析，展示如何有效地利用 LinkedList 提高开发效率和应用性能。
2. Employee类实现Comparable接口
2.1 Employee类的基本构成
2.1.1 基本属性的定义
在创建 Employee 类时，首先需要定义其基本属性。这些属性通常包括员工的姓名、年龄、工龄、薪水等。为了确保这些数据在创建对象时被正确地初始化，我们会使用私有成员变量，并通过公共的getter和setter方法来访问和修改这些属性。下面是一个简单的属性定义示例：
public class Employee {
private String name;
private int age;
private int workExperience;
private double salary;
// 构造方法、getter和setter方法将在下面的章节中定义
}
2.1.2 构造方法和getter、setter方法
为了方便创建 Employee 对象，我们需要提供至少一个构造方法。另外，为了确保属性的封装性，需要提供对应的getter和setter方法。构造方法允许我们在创建对象时设置对象的初始状态，而getter和setter方法允许我们在对象创建之后访问和修改对象的属性。下面是一个包含构造方法和getter、setter方法的完整示例：
public class Employee {
// 基本属性定义
// 构造方法
public Employee(String name, int age, int workExperience, double salary) {
this.name = name;
this.age = age;
this.workExperience = workExperience;
this.salary = salary;
}
// getter和setter方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getWorkExperience() {
return workExperience;
}
public void setWorkExperience(int workExperience) {
this.workExperience = workExperience;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
}
2.2 实现Comparable接口
2.2.1 compareTo方法的实现原理
Java中的 Comparable 接口要求实现 compareTo 方法，该方法用于定义对象排序的规则。 compareTo 方法需要返回一个整数值，表示调用该方法的对象与传入的参数对象的比较结果。具体来说，如果调用对象小于参数对象，应返回负数；如果调用对象等于参数对象，应返回零；如果调用对象大于参数对象，应返回正数。这允许 Collections.sort() 等方法根据对象的自然顺序（即对象的“自然排序”）进行排序。
以下是一个 Employee 类实现 Comparable 接口并重写 compareTo 方法的示例：
public class Employee implements Comparable<Employee> {
// 基本属性定义、构造方法、getter和setter方法省略
@Override
public int compareTo(Employee other) {
// 假设我们按薪水降序排列员工
if (this.salary < other.salary) return 1;
if (this.salary > other.salary) return -1;
return 0;
}
}
2.2.2 按单一属性排序的示例
当实现 Comparable 接口并重写了 compareTo 方法后，我们就可以按照单一属性对 Employee 对象列表进行排序。下面是一个使用 Collections.sort() 方法按照薪水对 Employee 对象进行排序的示例：
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class SortExample {
public static void main(String[] args) {
List<Employee> employees = new ArrayList<>();
// 假设这里添加了一些员工对象到列表中
Collections.sort(employees); // 自然排序，按薪水降序排列
// 排序后打印员工信息
for (Employee employee : employees) {
System.out.println(employee.getName() + ": " + employee.getSalary());
}
}
}
以上代码演示了如何将一组 Employee 对象存储在 ArrayList 中，并通过调用 Collections.sort() 方法对它们进行排序。由于 Employee 类实现了 Comparable 接口， Collections.sort() 方法会使用 compareTo 方法定义的自然排序规则进行排序。
3. 自定义Comparator实现不同排序逻辑
3.1 Comparator接口与自定义比较器
3.1.1 Comparator接口的使用场景
在Java中，Comparator接口是设计用来对对象进行比较的。与Comparable接口不同，Comparable需要在类中直接实现，而Comparator则允许在外部定义比较逻辑，这为动态比较提供了灵活性。Comparator接口的使用场景通常包括以下情况：
- 当对象的类没有实现Comparable接口，而我们需要对这类对象进行排序时。
- 当我们需要多种排序方式时。例如，可以创建多个Comparator实例，每个实例根据不同的属性或条件进行排序。
- 当排序规则不固定，需要在运行时决定排序逻辑时。
3.1.2 自定义比较器的创建步骤
创建一个自定义比较器分为几个步骤，具体如下：
- 定义一个实现了Comparator接口的类。
- 在这个类中，重写
compare方法，以定义两个对象间的比较逻辑。 - 如果需要，还可以实现
equals方法，以提供更准确的比较结果。
下面是一个简单的例子，展示如何创建一个比较器：
import java.util.Comparator;
public class EmployeeAgeComparator implements Comparator<Employee> {
@Override
public int compare(Employee e1, Employee e2) {
// 升序排列
return e1.getAge() - e2.getAge();
// 如果要降序排列，则可使用
// return e2.getAge() - e1.getAge();
}
}
在这个例子中，我们定义了一个名为 EmployeeAgeComparator 的比较器，专门按照员工的年龄进行升序排序。通过 compare 方法实现了比较逻辑。
3.2 多条件排序逻辑实现
3.2.1 多条件排序的需求分析
在实际应用中，我们可能需要根据多个条件对对象进行排序。例如，先按工资排序，如果工资相同，则按年龄排序。这要求我们能够编写复合比较逻辑，以适应这些复杂的排序需求。
3.2.2 复合比较器的编写与测试
复合比较器允许我们定义多个排序条件，并按优先级顺序排列。编写复合比较器的步骤通常如下：
- 创建一个实现了Comparator接口的类。
- 在
compare方法中，首先比较第一个条件。如果两个对象在第一个条件上相等，则使用第二个条件进行比较，以此类推。 - 对每个比较条件的返回值进行逻辑分析，确保整个排序过程符合预期。
下面的例子演示了一个复合比较器，该比较器首先按工资排序，如果工资相同，则按年龄排序：
import java.util.Comparator;
public class EmployeeSalaryAndAgeComparator implements Comparator<Employee> {
@Override
public int compare(Employee e1, Employee e2) {
int salaryComparison = Double.compare(e1.getSalary(), e2.getSalary());
if (salaryComparison != 0) {
return salaryComparison;
}
// 当工资相同，按年龄排序
return Integer.compare(e1.getAge(), e2.getAge());
}
}
在这个例子中， compare 方法首先比较两个员工的工资。如果工资不同，则直接根据工资排序；如果工资相同，则比较年龄。这样，我们就可以实现多条件排序的需求。
为了测试复合比较器，我们可以创建一个Employee对象列表，然后使用Collections.sort()方法配合我们的复合比较器进行排序：
List<Employee> employees = new ArrayList<>();
// 假设我们已经初始化并添加了一些Employee对象到employees列表中
Collections.sort(employees, new EmployeeSalaryAndAgeComparator());
然后，我们可以通过遍历排序后的列表来验证排序是否符合预期。如果员工列表根据工资降序排列，且在工资相同的情况下根据年龄降序排列，则复合比较器编写成功。
通过本章节的介绍，我们了解了Comparator接口在实现不同排序逻辑中的重要性，学习了自定义比较器的创建步骤，并通过实例演示了如何实现复合条件排序。这种灵活的排序方法在处理复杂数据结构时显得尤为重要，它为我们的应用程序提供了强大的排序功能。
4. 使用Collections.sort()方法进行排序
4.1 Collections.sort()方法概述
4.1.1 sort()方法的工作原理
Collections.sort() 方法是Java集合框架中用于对List中的元素进行排序的静态方法。它利用了元素自身实现的 Comparable 接口或者提供的 Comparator 接口来决定排序逻辑。 sort() 方法内部采用了一种称为”TimSort”的算法，这种算法是归并排序和插入排序的混合，优化了在实际应用中的性能表现。
从技术层面讲， Collections.sort() 在执行时会检查List的类型以及元素是否实现了 Comparable 接口。如果是，就使用元素的 compareTo 方法来排序；如果不是，则需要提供一个 Comparator 实现来指定排序规则。
4.1.2 使用sort()方法排序的必要条件
要使用 Collections.sort() 方法，List集合中的元素类型必须是可比较的。对于实现了 Comparable 接口的元素，这意味着元素类必须定义了 compareTo 方法来返回一个整数，指示该元素与另一个元素的相对顺序。如果元素没有实现 Comparable 接口，或者需要按照非自然顺序进行排序，那么就必须提供一个 Comparator 来明确排序逻辑。
此外， sort() 方法要求List是可变的（Mutable），即元素可以在运行时被添加或者移除。不可变的（Immutable）集合，如 Collections.unmodifiableList() 返回的集合，是不能被排序的，因为对这类集合的修改会抛出 UnsupportedOperationException 。
4.2 排序实例演示
4.2.1 LinkedList的初始化和添加元素
要演示使用 Collections.sort() 方法进行排序，我们首先需要创建一个 LinkedList 并添加一些元素。假设我们有一个 Employee 类，它实现了 Comparable 接口，那么我们可以这样做：
import java.util.LinkedList;
import java.util.Collections;
public class SortLinkedListDemo {
public static void main(String[] args) {
LinkedList<Employee> employees = new LinkedList<>();
employees.add(new Employee("Alice", 30));
employees.add(new Employee("Bob", 25));
employees.add(new Employee("Charlie", 35));
// ...添加更多员工信息
System.out.println("排序前的员工列表：");
System.out.println(employees);
}
}
在这个示例中，我们创建了一个 LinkedList 并添加了几个 Employee 对象。这个列表目前还没有排序。
4.2.2 使用Collections.sort()进行单属性排序
接下来，我们将使用 Collections.sort() 对 Employee 对象列表按照年龄排序：
Collections.sort(employees);
如果 Employee 类正确实现了 Comparable 接口，例如按照年龄（ age ）排序，那么执行上述代码后， employees 列表中的元素将会被按照年龄从小到大排序。
4.2.3 使用自定义Comparator进行复合属性排序
如果需要进行更复杂的排序，比如我们希望先按照年龄排序，如果年龄相同，则按照名字的字典顺序排序，我们可以使用 Comparator 实现：
Collections.sort(employees, new Comparator<Employee>() {
@Override
public int compare(Employee o1, Employee o2) {
int ageComparison = Integer.compare(o1.getAge(), o2.getAge());
if (ageComparison != 0) {
return ageComparison;
}
return o1.getName().compareTo(o2.getName());
}
});
上述代码创建了一个匿名类的 Comparator 实例，首先比较年龄，如果年龄相同，再比较名字。 Collections.sort() 方法使用这个 Comparator 来对 employees 列表进行排序。
下面是一个表格来展示 Collections.sort() 方法在不同情况下的行为：
| 情况 | 排序前列表 | 比较逻辑 | 排序后列表 |
|---|---|---|---|
| 单属性排序 | [Alice, 30, Bob, 25, Charlie, 35] | 按年龄 | [Bob, 25, Alice, 30, Charlie, 35] |
| 复合属性排序 | [Alice, 30, Bob, 25, Charlie, 35] | 先年龄后名字 | [Bob, 25, Alice, 30, Charlie, 35] |
上述示例和表格展示了 Collections.sort() 方法在实际应用中的灵活性和实用性。通过自定义 Comparator ，我们几乎可以定义任何复杂的排序逻辑来满足业务需求。
5. 利用Scanner类从控制台输入人事信息
5.1 Scanner类的基本使用
5.1.1 Scanner类的作用与优势
Scanner类是Java中的一个简单易用的文本扫描器，主要用于从各种输入源（如控制台输入、文件、字符串等）读取基本类型和字符串。使用Scanner类的优势在于它的灵活性和易用性。它能够解析基本数据类型和字符串的正则表达式，支持基本的输入格式，如整数、浮点数、字符串以及布尔值等。
5.1.2 读取控制台输入的方法和技巧
通过Scanner类读取控制台输入非常简单。首先，需要创建一个Scanner对象，并将 System.in 作为参数传递给构造函数。然后，使用 nextLine() 方法可以读取一整行输入（直到遇到换行符），而使用 nextInt() , nextDouble() 等方法则可以读取特定类型的下一个标记。
import java.util.Scanner;
public class InputExample {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你的名字：");
String name = scanner.nextLine();
System.out.println("请输入你的年龄：");
int age = scanner.nextInt();
scanner.nextLine(); // 清除换行符
System.out.println("请输入你的职位：");
String position = scanner.nextLine();
System.out.println("欢迎 " + name + "，你 " + age + " 岁，职位是 " + position);
scanner.close();
}
}
5.2 实现人事信息的动态输入
5.2.1 设计用户交互界面
为了有效地从用户那里获取人事信息，我们可以设计一个简单的命令行用户交互界面。这个界面会提示用户输入各项必要的信息，并可以对输入信息的格式和内容进行初步校验。
import java.util.Scanner;
import java.util.LinkedList;
public class PersonnelDataInput {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
LinkedList<Employee> employeeList = new LinkedList<>();
while (true) {
System.out.println("\n请输入员工信息：");
System.out.println("1. 添加新员工");
System.out.println("2. 退出输入");
System.out.print("选择一个操作：");
String option = scanner.nextLine();
if ("1".equals(option)) {
String name = scanner.nextLine();
int age = scanner.nextInt();
scanner.nextLine(); // 清除换行符
String department = scanner.nextLine();
String position = scanner.nextLine();
employeeList.add(new Employee(name, age, department, position));
System.out.println("员工信息已添加。");
} else if ("2".equals(option)) {
break;
} else {
System.out.println("无效的输入，请重新选择！");
}
}
// 关闭Scanner
scanner.close();
// 接下来进行员工信息的存储和排序操作...
}
}
5.2.2 使用Scanner接收输入数据并存储到LinkedList中
在上述的用户交互界面代码中，我们定义了一个 LinkedList<Employee> 来动态地存储用户输入的员工信息。通过循环，我们不断地提示用户输入新员工的信息，创建 Employee 对象，并将它们添加到链表中。当用户完成输入，选择退出操作时，链表中存储了所有输入的员工信息，可用于后续的数据处理和排序操作。
简介：LinkedList在Java中是一个重要的数据结构，适用于列表的插入和删除操作。该实例演示了如何利用LinkedList和Comparator接口来实现人事信息系统的自定义排序功能。通过创建Employee类并实现Comparable接口，以及使用Collections.sort方法与Comparator接口，可以实现多样化的排序逻辑。从控制台输入人事信息，利用LinkedList存储和排序，最后输出排序后的人事信息列表。掌握这些技能对于处理复杂数据结构和算法非常有帮助。
Agent 垂直技术社区，欢迎活跃、内容共建。
更多推荐
8
0- 0
已为社区贡献117条内容
所有评论(0)