实现接口封装排序框架两种方法

最新推荐文章于 2025-05-29 15:54:41 发布

纤月流水@刘小哥

最新推荐文章于 2025-05-29 15:54:41 发布

阅读量386

点赞数

CC 4.0 BY-SA版权

分类专栏： java

本文链接：https://blog.youkuaiyun.com/qq_43316411/article/details/88702146

java 专栏收录该内容

26 篇文章

订阅专栏

博客介绍了Java中两种排序实现方法。一是实现Comparator接口，可通过匿名内部类或外部类实现，重写compare方法；二是在类中实现Comparable接口，重写compareTo方法，还给出了自定义代码实现原理及利用JDK类实现的示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

第一种方法:实现比较器中的Comparator 接口
第二种方法，在类中实现Comparable接口

实现第二种方法的原理，自定义写的代码

1.首先是以排序工具包

package 排序工具1;

import java.util.ArrayList;

public class SortUlit
{
//这里穿传入的第一个参数是待排序的列表，第二个是一个逻辑关系返回值是boolean值
	public static void sort(ArrayList<User> ulist,Bijiaoqi b1){
		for(int i=0;i<ulist.size()-1;i++){
			for(int j=0;j<ulist.size()-1-i;j++){
				boolean flag = b1.bijiaoqi(ulist.get(j), ulist.get(j+1));
				if(flag){
					User temp = ulist.get(j);
					ulist.set(j, ulist.get(j+1));
					ulist.set(j+1, temp);
				}
			}
		}
	}
}

2.传入的逻辑关系的接口类

package 排序工具1;

public interface Bijiaoqi
{
	public boolean bijiaoqi(User u1,User u2);
}

3.对应接口的实现类

package 排序工具1;

public class AgeBijiaoqi implements Bijiaoqi
{

	@Override
	public boolean bijiaoqi(User u1, User u2)
	{
		if(u1.getAge() > u2.getAge()){
			return true;
		}
		return false;
	}

}

4.测试类
package 排序工具1;

import java.util.ArrayList;

public class Test
{

public static void main(String[] args)
{
	//造数据
			User u1 = new User("a",12,22500);
			User u2 = new User("b",120,12500);
			User u3 = new User("c",14,8500);
			User u4 = new User("d",18,5500);
			User u5 = new User("e",19,95000);
			User u6 = new User("f",145,5500);
			//创建一个列表
			ArrayList<User> ulist = new ArrayList<>();
			ulist.add(u1);
			ulist.add(u2);
			ulist.add(u3);
			ulist.add(u4);
			ulist.add(u5);
			ulist.add(u6);
			SortUlit.sort(ulist, new AgeBijiaoqi());
			for(User temp:ulist){
				System.out.println(temp.getAge());
			}
			

}

}
5.题中对应的User类

package 排序工具1;

public class User
{
	private String name;
	private int age;
	private int salary;
	
	public User(){
		
	}
	
	public User(String name, int age, int salary)
	{
		this.name = name;
		this.age = age;
		this.salary = salary;
	}
	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 getSalary()
	{
		return salary;
	}
	public void setSalary(int salary)
	{
		this.salary = salary;
	}
	
}

利用JDK中的类进行实现

第一种方法：
利用比较器，此时比较器的实现类必须要重写compare方法：这个地方可以使用这种匿名内部类实现：Collections.sort(ls, new Comparator(){重写compare方法}）。
当逻辑复杂时，可以使用外部类实现Comparator接口，可以参照上面的的原理代码。

类型类：

package testpackage;

public class Student {
	
	private String name;
	private int age;
	
	public Student() {}
	
	public Student(String name, int age) {
		this.name = name;
		this.age = age;
	}
	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;
	}

	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
}

主函数类：

package testpackage;

import java.util.ArrayList;

import java.util.Collections;
import java.util.Comparator;
//利用比较器进行排序
public class SortStudentDemo1 {

	public static void main(String[] args) {
		Student s1 = new Student("刘谦1",23);
		Student s2 = new Student("刘谦2",28);
		Student s3 = new Student("刘谦3",230);
		Student s4 = new Student("刘谦4",10);
		Student s5 = new Student("刘谦5",24);
		Student s6 = new Student("刘谦6",53);
		
		ArrayList<Student> ls = new ArrayList<Student>();
		ls.add(s1);
		ls.add(s2);
		ls.add(s3);
		ls.add(s4);
		ls.add(s5);
		ls.add(s6);
		//这个地方可以使用这种匿名内部类实现，当逻辑复杂时，可以使用外部类实现Comparator接口，可以参照上面的的原理代码。
		Collections.sort(ls, new Comparator<Student>() {

			public int compare(Student o1, Student o2) {
				int res = o1.getAge() - o2.getAge();
				if(res>0) {
					return 1;
				}
				return -1;
			}
			
		});
		
		
		for(Student s:ls) {
			System.out.println(s.toString());
		}

	}

}

结果如下：

Student [name=刘谦4, age=10]
Student [name=刘谦1, age=23]
Student [name=刘谦5, age=24]
Student [name=刘谦2, age=28]
Student [name=刘谦6, age=53]
Student [name=刘谦3, age=230]

第二种方法：sort中只传入一个参数，比如sort(ls),ls中封装的类型类要实现comparable接口，必须重写compareTo方法。

类型类：（要实现comparable接口，必须重写compareTo方法。）

package testpackage;

public class Student2 implements Comparable<Student2>{
	private String name;
	private int age;
	
	public Student2() {}
	
	public Student2(String name, int age) {
		this.name = name;
		this.age = age;
	}
	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 compareTo(Student2 o) {
		return this.age - o.age;
	}

	@Override
	public String toString() {
		return "Student2 [name=" + name + ", age=" + age + "]";
	}
}

主函数类：

package testpackage;

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


public class SortStudentDemo2 {

	public static void main(String[] args) {
		Student2 s1 = new Student2("刘谦1",23);
		Student2 s2 = new Student2("刘谦2",28);
		Student2 s3 = new Student2("刘谦3",230);
		Student2 s4 = new Student2("刘谦4",10);
		Student2 s5 = new Student2("刘谦5",24);
		Student2 s6 = new Student2("刘谦6",53);
		
		ArrayList<Student2> ls = new ArrayList<Student2>();
		ls.add(s1);
		ls.add(s2);
		ls.add(s3);
		ls.add(s4);
		ls.add(s5);
		ls.add(s6);
		
		Collections.sort(ls);
		for(Student2 s:ls) {
			System.out.println(s.toString());
		}

	}
}

结果如下：

Student2 [name=刘谦4, age=10]
Student2 [name=刘谦1, age=23]
Student2 [name=刘谦5, age=24]
Student2 [name=刘谦2, age=28]
Student2 [name=刘谦6, age=53]
Student2 [name=刘谦3, age=230]