Java 模拟 Comparator接口 策略模式

续上一篇  《Java 模拟 Comparable接口》

一、Teacher类及Student类的比较大小方式是不固定的,比如老师除了比较职称外,还可比较工龄大小,年龄大小等。则定义Comparator接口,不同比较方法去定义为一个xxComparator类,去实现Comparator接口,Teacher类及Student类引用具体的xxComparator比较器,则可实现灵活的比较方式切换。此则为策略模式的一个例子:当我要比较大小的时候,先定义一个比较器Comparator,但具体的比较由具体的比较策略去实现,如TeacherAgeComparator

PS:解决的问题一涉及要求灵活多变,可扩展等进,则应重点考虑使用多态思想。

二、有如下几个类:

1.DataSorter.java

2.Studnet.java

3.Teacher.java

4.Comparable.java

5.Comparator.java

6.TeacherAgeComparator.java

7.StudentMarkComparaotr.java

1.DataSorter.java(和上一篇一样)

public class DataSorter {

	public static void sort(Comparable [] a) {

		int index;							//保存每次比较,最大值的下标;

		for(int i = 1; i < a.length; i++){	//控制外循环次数
			index = 0;
			for(int j = 1; j <= a.length - i ; j++){
				if(a[j].compareTo(a[index]) == 1){
					index = j;
				}
			}
			swap(a, index, a.length -i);
		}
	}

	private static void swap(Comparable[] a, int x, int y) {
		Comparable tmp = a[x];
		a[x] = a[y];
		a[y] = tmp;

	}

	//输出数组元素
	public static void show(Comparable[] a) {
		for(int i = 0; i < a.length; i++){
			System.out.println(a[i]);
		}
	}

}

  

2.Studnet.java

public class Student implements Comparable<Student> {

	private int mark;
	private Comparator<Student> comparator = new StudentMarkComparator();

	public int getMark() {
		return mark;
	}

	public void setMark(int mark) {
		this.mark = mark;
	}

	public Student(int mark) {
		super();
		this.mark = mark;
	}

	@Override
	public String toString() {
		return "student" +mark+" ";
	}

	@Override
	public int compareTo(Student o) {
		return comparator.compare(this, o);
	}
}

  

3.Teacher.java

public class Teacher implements Comparable<Teacher> {

	private int title;
	private int age;
	private Comparator<Teacher> comparator = new TeacherAgeComparator();

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public Teacher(int age) {
		super();
		this.age = age;
	}

	public int getTitle() {
		return title;
	}

	public void setTitle(int title) {
		this.title = title;
	}

	@Override
	public int compareTo(Teacher o) {
		return comparator.compare(this, o);
	}

	@Override
	public String toString() {
		return "teacher--" +age+" ";
	}
}

  

4.Comparable.java

public interface Comparable<T> {
	public int compareTo(T o);
}

  

5.Comparator.java

public interface Comparator<T> {

	int compare(T o1, T o2);

}

  

6.TeacherAgeComparator.java

public class TeacherAgeComparator implements Comparator<Teacher> {

	@Override
	public int compare(Teacher o1, Teacher o2) {
		if(o1.getAge() > o2.getAge()){
			return 1;
		}else if(o1.getAge() == o2.getAge()){
			return 0;
		}else{
			return -1;
		}
	}

}

  

7.StudentMarkComparaotr.java

public class StudentMarkComparator implements Comparator<Student> {

	@Override
	public int compare(Student o1, Student o2) {
		if(o1.getMark() > o2.getMark())	return 1;
		else if(o1.getMark() == o2.getMark())	return 0;
		else	return -1;
	}

}

  

8.Test.java

public class Test {

	public static void main(String[] args) {
		//int [] a = {9,2,1,8,0,3};
		Student [] ss = {new Student(59),new Student(30),new Student(90)};
		DataSorter.sort(ss);
		DataSorter.show(ss);

		Teacher [] ts = {new Teacher(10),new Teacher(3),new Teacher(12)};
		DataSorter.sort(ts);
		DataSorter.show(ts);

	}

}

  

测试结果

时间: 2024-10-14 20:53:13

Java 模拟 Comparator接口 策略模式的相关文章

Java中Comparator接口

Comparator位于java.util包下 public interface Comparator<T> 强行对某个对象 collection 进行整体排序 的比较函数.可以将 Comparator 传递给 sort 方法(如 Collections.sort 或 Arrays.sort),从而允许在排序顺序上实现精确控制.还可以使用 Comparator 来控制某些数据结构(如有序 set或有序映射)的顺序,或者为那些没有自然顺序的对象 collection 提供排序. 当且仅当对于一组

使用Java中Comparator接口实现自定义排序

一般情况下,自己动手写一个简单排序程序还是没有问题的,但是你能保证写出来的排序程序的时间复杂度吗?你能保证程序的正确性吗,鲁棒性呢,还有程序结构的清晰性,可维护性.......综上所述,学习一下排序接口来实现对复杂对象的排序还是很有必要的.Java中有两个用来实现排序的接口Comparator和Comparable接口,本人比较喜欢使用java的Comparator接口,在程序里实现Comparator接口里的compare(Object o1,Object o2)方法,然后在程序中通过调用Ar

Java设计模式6:策略模式

策略模式 策略模式的用意是针对一组算法,将每一个算法封装到具有共同接口的独立类中,从而使得它们可以相互替换.策略模式使得算法可以在不影响到客户端的情况下发生变化. 策略模式的结构 策略模式是对算法的包装,是把使用算法的责任和算法本身分开.策略模式通常是把一系列的算法包装到一系列的策略类里面,作为一个抽象策略类的子类. 策略模式涉及到三个角色: 1.环境角色 持有一个策略Strategy的引用 2.抽象策略角色 这是一个抽象角色,通常由一个接口或抽象类实现,此角色给出所有具体策略类所需的接口 3.

Java的设计模式----strategy(策略模式)

设计模式: 一个程序员对设计模式的理解: “不懂”为什么要把很简单的东西搞得那么复杂.后来随着软件开发经验的增加才开始明白我所看到的“复杂”恰恰就是设计模式的精髓所在,我所理解的“简单”就是一把钥匙开一把锁的模式,目的仅仅是着眼于解决现在的问题,而设计模式的“复杂”就在于它是要构造一个“万能钥匙”,目的是提出一种对所有锁的开锁方案.在真正理解设计模式之前我一直在编写“简单”的代码. 这个“简单”不是功能的简单,而是设计的简单.简单的设计意味着缺少灵活性,代码很钢硬,只在这个项目里有用,拿到其它的

Java记录 -68- Java实现策略模式

Java实现策略模式 策略模式的编写步骤: 1. 对策略对象定义一个公共接口: 2. 编写策略类,该类实现了上面的公共接口: 3. 在使用策略对象的类中保存一个对策略对象的引用: 4. 在使用策略对象的类中,实现对策略对象的set和get方法(注入)或者使用构造方法完成赋值 代码实例实现简单的加减乘除运算. 策略接口: public interface Strategy {     public int calculate(int a, int b); } 策略类: public class A

java lang(Comparable接口) 和java util(Comparator接口)分析比较

//Comparable 接口强行对实现它的每个类的对象进行整体排序. -- 自然排序.类的compareTo称为自然比较方法. public interface Comparable<T> { public int compareTo(T o); } 此接口强行对实现它的每个类的对象进行整体排序.这种排序被称为类的自然排序,类的 compareTo 方法被称为它的自然比较方法. 实现此接口的对象列表(和数组)可以通过 Collections.sort(和 Arrays.sort)进行自动排序

《Java设计模式》之策略模式

策略模式属于对象的行为模式.其用意是针对一组算法,将每一个算法封装到具有共同接口的独立的类中,从而使得它们可以相互替换.策略模式使得算法可以在不影响到客户端的情况下发生变化. 1,什么是策略模式? 策略模式,又叫算法簇模式,就是定义了不同的算法族,并且之间可以互相替换,此模式让算法的变化独立于使用算法的客户. 2,策略模式有什么好处? 策略模式的好处在于你可以动态的改变对象的行为. 3,设计原则 设计原则是把一个类中经常改变或者将来可能改变的部分提取出来,作为一个接口(c++z中可以用虚类),然

Java设计模式系列之策略模式

策略模式的定义: 策略模式定义了一系列的算法,并将每一个算法封装起来,而且使它们还可以相互替换,策略模式让算法独立于使用它的客户而独立变化. 策略模式使这些算法在客户端调用它们的时候能够互不影响地变化. 策略模式的意义:   策略模式使开发人员能够开发出由许多可替换的部分组成的软件,并且各个部分之间是低耦合的关系. 低耦合的特性使软件具有更强的可扩展性,易于维护:更重要的是,它大大提高了软件的可重用性.    策略模式中有三个对象:      环境对象(Context):该类中实现了对抽象策略中

Java:Comparator接口

public interface Comparator<T> 接口里面的方法 int compare(T o1, T o2) o1 > o2 返回 1 o1 = o2 返回 0 o1 < o2 返回 -1 boolean equals(Object obj) 判断是否相等 其他方法:https://docs.oracle.com/javase/8/docs/api/java/util/Comparator.html 强行对某个对象 collection 进行整体排序 的比较函数.可