为什么会有Comparable与Comparator接口? 引入策略模式

 

引入

  • 大家先考虑一个场景, 有一个整形数组, 我们希望通过调用一个工具类的排序方法就能对该数组进行排序. 请看下面的代码:
public class Strategy {
public static void main(String[] args) {
int[] arr = {5, 3, 1, 7, 2};
new DataSorter().sort(arr);//调用工具类进行排序
for(int i = 0; i < arr.length; i++){
System.out.println(arr[i]);
}
}
} class DataSorter{//用于排序的工具类
public void sort(int[] arr){//调用sort方法进行排序, 此处使用冒泡排序
for(int i = arr.length - 1; i > 0; i--){
for(int j = 0; j < i; j++){
if(arr[j] > arr[j + 1])
swap(arr, j, j + 1);
}
}
} private void swap(int[] arr, int i, int j){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}

Comparable接口的来龙去脉

  • 通过上面的代码, 我们能够轻易地对整形数组进行排序, 那么如果现在有了新需求, 需要对浮点类型数据进行排序, 排序工具类应该如何做呢?
  • 或许你会想, 不如就新添加一个排序方法, 方法的参数类型为float类型, 把int类型数组的排序算法复制一遍不就可以了吗?
  • 那如果我继续追问, 如果现在要对一只猫进行排序, 那应该怎么做呢? 猫的类如下
class Cat{
private int age;//猫的年龄
private int weight;//猫的体重 //get / set 方法...
}
  • 你也许会顺着原来的思路回答, 照样copy一份排序的算法, 修改方法参数, 然后在比较的地方指定比较猫的年龄或体重不就可以了吗?
public void sort(Cat[] arr){//以猫数组作为参数
for(int i = arr.length - 1; i > 0; i--){
for(int j = 0; j < i; j++){
if(arr[j].getAge() > arr[j + 1].getAge())//根据猫的年龄作比较
swap(arr, j, j + 1);
}
}
}
  • 但仔细想想, 如果还要继续比较小狗, 小鸡, 小鸭等各种对象, 那么这个排序工具类的代码量岂不是变得很大? 为了能让排序算法的可重用性高一点, 我们希望排序工具中的sort()方法可以对任何调用它的对象进行排序.
  • 你可能会想: 到对任何对象都能排序, 把sort()方法的参数改为Object类型不久可以了嘛. 这个方向是对的, 但是问题是, 当拿到两个Object类型对象, 应该根据什么规则进行比较呢?
  • 这个时候我们自然而然地就希望调用工具类进行排序的对象本身就具备自己的比较法则, 这样在排序的时候就能直接调用对象的排序法则进行排序了.
  • 我们把比较法则抽象为Comparable接口, 凡是要进行比较的类都要实现Comparable接口, 并且定义自己的比较法则, 也就是CompareTo()方法.
  • 这样当我们在封装工具时, 就可以直接对实现了Comparable接口的对象进行比较, 不用担心比较的细节了.
public class Strategy {
public class Strategy {
public static void main(String[] args) {
// Integer[] arr = {5, 3, 1, 7, 2};//注意这里把int改为Integer, Integer是Object的子类
Cat[] arr = {new Cat(3, 3), new Cat(1, 1), new Cat(5, 5)};
DataSorter ds = new DataSorter();
ds.sort(arr);
for(int i = 0; i < arr.length; i++){
System.out.println(arr[i]);
}
}
}
} class DataSorter{//用于排序的工具类
public void sort(Object[] arr){//参数类型为Object
for(int i = arr.length - 1; i > 0; i--){
for(int j = 0; j < i; j++){
Comparable c1 = (Comparable) arr[j];//先转为Comparable类型
Comparable c2 = (Comparable) arr[j + 1];
if(c1.CompareTo(c2) == 1)//调用CompareTo()进行比较, 不关心具体的实现
swap(arr, j, j + 1);
}
}
} private void swap(Object[] arr, int i, int j){
Object temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
} class Cat implements Comparable{
private int age;
private int weight; @Override
public int CompareTo(Object o) {
if(o instanceof Cat){//先判断传入的是否是Cat类对象, 不是则抛异常
Cat c = (Cat) o;
if(this.age > c.age) return 1;
else if (this.age < c.age) return -1;
else return 0;
}
throw null == o ? new NullPointerException() : new ClassCastException();
} // get / set ...
//toString() ...
} interface Comparable{
public int CompareTo(Object o);
}

引入Comparator接口

  • 相信看了上面的Comparable接口来由, 大家会感觉整个设计又美好了一些, 但是其中还有漏洞. 我们在Cat类的CompareTo()方法中, 对猫的比较策略是写死的, 现在我们按猫的年龄比较大小, 如果哪天我们想按照猫的体重比较大小, 又要去修改源码了. 有没有扩展性更好的设计?
  • 我们可以让用户自己定义一个比较器类, 对象可以根据用户指定的比较器比较大小.
  • 整个逻辑是: 如果这个对象需要进行比较, 那么它必须实现Comparable接口, 但是它具体是怎么比较的, 则通过具体的Comparator比较器进行比较.
  • 当然这里少不了多态, 我们首先要定义一个比较器接口Comparator, 用户的比较器需要实现Comparator接口, 下面上代码:
public class Strategy {
public static void main(String[] args) {
Cat[] arr = {new Cat(3, 3), new Cat(1, 1), new Cat(5, 5)};
DataSorter ds = new DataSorter();
ds.sort(arr);
for(int i = 0; i < arr.length; i++){
System.out.println(arr[i]);
}
}
} class DataSorter{//用于排序的工具类
public void sort(Object[] arr){//参数类型为Object
for(int i = arr.length - 1; i > 0; i--){
for(int j = 0; j < i; j++){
Comparable c1 = (Comparable) arr[j];//先转为Comparable类型
Comparable c2 = (Comparable) arr[j + 1];
if(c1.CompareTo(c2) == 1)//背后已经转换为使用Comparator的定义的规则进行比较
swap(arr, j, j + 1);
}
}
} private void swap(Object[] arr, int i, int j){
Object temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
} class Cat implements Comparable{
private int age;
private int weight;
private Comparator comparator = new CatAgeComparator();//默认持有年龄比较器 @Override
public int CompareTo(Object o) {
return comparator.Compare(this, o);//调用比较器比较而不是直接在此写比较法则
} // get / set / toString ...
} interface Comparable{
public int CompareTo(Object o);
} interface Comparator{
public int Compare(Object o1, Object o2);
} //用户自己定义的, 按照猫的年龄比较大小的比较器
class CatAgeComparator implements Comparator{
@Override
public int Compare(Object o1, Object o2) {
Cat c1 = (Cat) o1;
Cat c2 = (Cat) o2;
if(c1.getAge() > c2.getAge()) return 1;
else if(c1.getAge() < c2.getAge()) return -1;
else return 0;
}
} //按照猫的体重比较大小的比较器
class CatWeightComparator implements Comparator{
@Override
public int Compare(Object o1, Object o2) {
Cat c1 = (Cat) o1;
Cat c2 = (Cat) o2;
if(c1.getWeight() > c2.getWeight()) return 1;
else if(c1.getWeight() < c2.getWeight()) return -1;
else return 0;
}
}

什么是策略模式?

  • 在上面的例子中, 我们自己定义了Comparable接口和Comparator接口, 其实这两个接口都是Java自带的, 通过上面的代码示例, 想必大家也应该知道了为什么会有这两个接口.
  • 其实Comparable定义的就是一种比较的策略, 这里的策略你可以理解为一个功能, 然而策略有了, 我们还需要有具体的策略实现, 于是便有了Comparator接口.
  • 这里再举一个例子方便大家理解.
  • 现在有一个坦克小游戏, 坦克要能够发射炮弹, 那么我们可以认为发射炮弹就是一种策略, 但是具体到发送什么炮弹, 这可以由具体的策略实现.
  • 到GitHub上看看该坦克游戏
  • 首先定义发射炮弹这种策略
public interface Fire {
public void fire();//发射炮弹的策略
}
  • 为了实现发射炮弹这种策略, 定义策略的具体实现, 也就是定义发射炮弹动作
public interface FireAction {
public void fireAction(Tank tank);
}
  • 坦克想要发送炮弹必须实现Fire()接口, 而且坦克拥有发射炮弹的动作, 至于动作的具体实现, 这里默认给出只发射一颗炮弹的动作.
public class Tank implements TankHitListener, Fire {
//省略各种属性方法...
private FireAction fireAction = new NormalFireAction();//默认动作是只发射一颗炮弹 @Override
public void fire() {
fireAction.fireAction(this);
} //...

使用了策略模式有什么好处?

  • 以上面的坦克游戏为例, 当把发射炮弹定义为一种策略后, 能发射炮弹的对象就不只坦克一个了, 如果游戏中有机关, 可以让机关也实现fire()接口, 获得发射炮弹的能力.
  • 而且在定义策略后我们可以根据策略给出不同的实现方式, 比方说坦克发射炮弹的动作是每次只发射一颗炮弹, 而机关是每次向八个方向发射一颗炮弹. 非常灵活.
  • 结束

Comparable的更多相关文章

  1. Java中Comparable与Comparator的区别

    相同 Comparable和Comparator都是用来实现对象的比较.排序 要想对象比较.排序,都需要实现Comparable或Comparator接口 Comparable和Comparator都 ...

  2. 12.Java中Comparable接口,Readable接口和Iterable接口

    1.Comparable接口 说明:可比较(可排序的) 例子:按照MyClass的y属性进行生序排序 class MyClass implements Comparable<MyClass> ...

  3. 泛型的排序问题(Collections.sort及Comparable的应用)

    一.前言    java中对泛型(集合类型)排序的问题,主要采用了两张方式一种是对要排序的实体类,实现Comparable接口,另一种方式,Collections集合工具类进行排序. 二.实现Comp ...

  4. 【集合框架】JDK1.8源码分析之Comparable && Comparator(九)

    一.前言 在Java集合框架里面,各种集合的操作很大程度上都离不开Comparable和Comparator,虽然它们与集合没有显示的关系,但是它们只有在集合里面的时候才能发挥最大的威力.下面是开始我 ...

  5. 对象比较器:Comparable和Comparator

    在进行对象数组排序的过程中需要使用到比较器,比较器有两个:Comparable和Comparator ①.java.lang.Comparable:是在类定义是时候默认实现好的接口,里面提供有一个co ...

  6. java中的Comparable接口

    类对象之间比较"大小"往往是很有用的操作,比如让对象数组排序时,就需要依赖比较操作.对于不同的类有不同的语义.如Student类,比较2个学生对象可以比较他们的score分数来评判 ...

  7. java://Comparator、Comparable的用法(按照要求将map集合的键值对进行顺序输出)

    import java.util.*; public class Person implements Comparable<Person>//使Person的属性具有比较性 { priva ...

  8. Java中Comparable和Comparator接口区别分析

    Java中Comparable和Comparator接口区别分析 来源:码农网 | 时间:2015-03-16 10:25:20 | 阅读数:8902 [导读] 本文要来详细分析一下Java中Comp ...

  9. Comparable和Comparator的区别

    Comparable Comparable可以认为是一个内比较器,实现了Comparable接口的类有一个特点,就是这些类是可以和自己比较的,至于具体和另一个实现了Comparable接口的类如何比较 ...

  10. java.lang.Comparable<T> 接口

    package java.lang; import java.util.*; public interface Comparable<T> { public int compareTo(T ...

随机推荐

  1. 3ds Max File Format (Part 1: The outer file format; OLE2)

    The 3ds Max file format, not too much documentation to be found about it. There are some hints here ...

  2. mybatis(三):框架结构

  3. Freezable 对象概述 | Microsoft Docs

    原文:Freezable 对象概述 | Microsoft Docs Freezable 对象概述Freezable Objects Overview 2017/03/30 本文内容 什么是可冻结的? ...

  4. 虫师自动化测试robot Framework 框架的学习

    1.python关键字的定义 #coding=utf-8 def add(a,b): return a+b if __name__ == "__main__": c = add(4 ...

  5. 【18】 递归 X的N次幂

    题目(我没想到这也能出成题目--) 实现函数double Power(double base, int exponent),求base的exponent次方.不得使用库函数,同时不需要考虑大数问题. ...

  6. 使用鼠标左键事件实现VR中的Eye Gaze Input

    1.光标以及光标动画的显示 using System.Collections; using System.Collections.Generic; using UnityEngine; using U ...

  7. python之路之线程,进程,协程2

    一.线程 1.创建线程 2.主线程是否等待子线程 t.setDaemon(Ture/False):默认是false,等待子线程完成,ture,表示不等待子线程结束 3.主线程等待,子线程执行 join ...

  8. mysql(4):性能分析和性能优化

    性能分析 慢查询日志分析 ①查询慢查询日志的状态 show global variables like '%slow_query_log%'; ②开启慢查询日志(当mysql重启时会重置) set g ...

  9. apache http server 和tomcat的区别 以及nginx

    Apache HTTP Server(简称Apache)是Apache软件基金会的一个开放源码的网页服务器. 要明白他们之间的区别,我们首先需要明白HTTP协议.HTML页面.JSP.Servlet之 ...

  10. redis持久化优缺点