• Java学习——Comparable与Comparator区别&Cloneable

    目录

    经典接口：

    一、接口Comparable

    二、接口Comparator

    三、接口 Cloneable

    浅浅地总结一下下~

    经典接口：

    一、接口Comparable

    简单描述 java.lang.Comparable 接口：

            一个类实现了此接口，这个类的对象就可以使用重写的compareTo方法来比较对象的大小。

    类型参数：

            T - 可以与此对象进行比较的那些对象的类型

    方法摘要：

     intcompareTo(T o)
              比较此对象与指定对象的顺序。

    我们知道基本数据类型的数据（除boolean类型外）需要比较大小的话，之间使用比较运算符即可，但是引用数据类型是不能直接使用比较运算符来比较大小的。那么，如何解决这个问题呢？

    Java给所有引用数据类型的大小比较，指定了一个标准接口，就是java.lang.Comparable接口：

    1. package java.lang;
    2.  
    3. public interface Comparable{
    4.     int compareTo(Object obj);
    5. }

    那么我们想要使得我们某个类的对象可以比较大小，怎么做呢？步骤：

    第一步：哪个类的对象要比较大小，哪个类就实现java.lang.Comparable接口，并重写方法

    • 方法体就是你要如何比较当前对象和指定的另一个对象的大小

    第二步：对象比较大小时，通过对象调用compareTo方法，根据方法的返回值决定谁大谁小。

    • this对象（调用compareTo方法的对象）大于指定对象（传入compareTo()的参数对象）返回正整数

    • this对象（调用compareTo方法的对象）小于指定对象（传入compareTo()的参数对象）返回负整数

    • this对象（调用compareTo方法的对象）等于指定对象（传入compareTo()的参数对象）返回零

    代码示例：

    1. public class Student implements Comparable {
    2.     private String name;
    3.     private int age;
    4.     private int score;
    5.  
    6.     //重写接口的方法：
    7.     //比较此对象与指定对象的顺序。
    8.     //如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数
    9.     @Override
    10.     public int compareTo(Object o) {
    11.         Student stu = (Student) o;
    12.         int i = this.age - stu.age;//先比较年龄
    13.         i = i == 0 ? this.score - stu.score : i;//年龄相同再比较分数
    14.         i = i == 0 ? this.name.compareTo(stu.name) : i;//分数也相同
    15.         return i;
    16.     }
    17.  
    18.     @Override
    19.     public String toString() {
    20.         return "Student{" +
    21.                 "name='" + name + '\'' +
    22.                 ", age=" + age +
    23.                 ", score=" + score +
    24.                 '}';
    25.     }
    26.  
    27.     public String getName() {
    28.         return name;
    29.     }
    30.  
    31.     public void setName(String name) {
    32.         this.name = name;
    33.     }
    34.  
    35.     public int getAge() {
    36.         return age;
    37.     }
    38.  
    39.     public void setAge(int age) {
    40.         this.age = age;
    41.     }
    42.  
    43.     public int getScore() {
    44.         return score;
    45.     }
    46.  
    47.     public void setScore(int score) {
    48.         this.score = score;
    49.     }
    50.  
    51.     public Student(String name, int age, int score) {
    52.         this.name = name;
    53.         this.age = age;
    54.         this.score = score;
    55.     }
    56.  
    57.     public Student() {
    58.     }
    59.  
    60. }

    测试类：

    1. public class Demo {
    2.     public static void main(String[] args) {
    3.         Student[] arr = new Student[6];
    4.         arr[0] = new Student("Tom",18,99);
    5.         arr[1] = new Student("Jack",19,88);
    6.         arr[2] = new Student("Rose",20,95);
    7.         arr[3] = new Student("Jerry",21,90);
    8.         arr[4] = new Student("Lucy",18,87);
    9.         arr[5] = new Student("James",18,99);
    10.  
    11.         //对数组进行排序
    12.         for (int i = 0; i < arr.length -1; i++) {
    13.             for (int j = 0; j < arr.length - 1 - i; j++) {
    14.                 if(arr[j].compareTo(arr[j+1]) > 0 ){
    15.                     Student temp = arr[j];
    16.                     arr[j] = arr[j+1];
    17.                     arr[j+1] = temp;
    18.                 }
    19.             }
    20.         }
    21.         //遍历数组
    22.         for (int i = 0; i < arr.length; i++) {
    23.             System.out.println(arr[i]);
    24.         }
    25.  
    26.     }
    27. }

    练习：自定义数组排序工具类

    自定义一个数组工具类MyArrays，它包含一个静态方法，可以给任意对象数组用冒泡排序实现从小到大排序，该怎么定义这个方法呢？

    1. //自定义数组工具
    2. class MyArrays {
    3.     public static void sort(Object[] arr) {
    4.         //冒泡排序
    5.         for (int i = 0; i < arr.length - 1; i++) {
    6.             for (int j = 0; j < arr.length - 1 - i; j++) {
    7.                 Comparable c = (Comparable) arr[j];
    8.                 if (c.compareTo(arr[j + 1]) > 0){
    9.                     Object temp = arr[j];
    10.                     arr[j] = arr[j+1];
    11.                     arr[j+1]=temp;
    12.                 }
    13.             }
    14.         }
    15.     }
    16.  
    17.     public static void print(Object[] arr){
    18.         for (int i = 0; i < arr.length; i++) {
    19.             System.out.println(arr[i]);
    20.         }
    21.     }
    22. }
    1. //测试数组工具
    2. public class Demo {
    3.     public static void main(String[] args) {
    4.         Student[] arr = new Student[6];
    5.         arr[0] = new Student("Tom",18,99);
    6.         arr[1] = new Student("Jack",19,88);
    7.         arr[2] = new Student("Rose",20,95);
    8.         arr[3] = new Student("Jerry",21,90);
    9.         arr[4] = new Student("Lucy",18,87);
    10.         arr[5] = new Student("James",18,99);
    11.  
    12.         MyArrays.print(arr);
    13.         System.out.println("----排序后------------------------");
    14.  
    15.         MyArrays.sort(arr);
    16.  
    17.         MyArrays.print(arr);
    18.     }
    19. }

    二、接口Comparator

    简单描述 java.lang.Comparator 接口：

            创建这个接口的实现类对象，使用重写后的compare方法来对两个对象进行排序。

    类型参数：

            T - 此 Comparator 可以比较的对象类型

    方法摘要：

     intcompare(T o1, T o2)
              比较用来排序的两个参数。
     booleanequals(Object obj)
              指示某个其他对象是否“等于”此 Comparator。

    思考：

    （1）如果一个类，没有实现Comparable接口，而这个类你又不方便修改（例如：一些第三方的类，你只有.class文件，没有源文件），那么这样类的对象也要比较大小怎么办？

    （2）如果一个类，实现了Comparable接口，也指定了两个对象的比较大小的规则，但是此时此刻我不想按照它预定义的方法比较大小，但是我又不能随意修改，因为会影响其他地方的使用，怎么办？

    JDK在设计类库之初，也考虑到这种情况了，所以又增加了一个java.util.Comparator接口。

    1. package java.util;
    2.  
    3. public interface Comparator{
    4.     int compare(Object o1,Object o2);
    5. }

    那么我们想要比较某个类的两个对象的大小，怎么做呢？步骤：

    第一步：继续沿用Student举例，首先编写一个stuComparator类，通常称之为比较器类型，实现java.util.Comparator接口，并重写比较方法

    • 方法体就是你要如何指定的两个对象的大小

    第二步：比较大小时，通过比较器类型的对象调用compare()方法，将要比较大小的两个对象作为compare方法的实参传入，根据方法的返回值决定谁大谁小。

    • o1对象大于o2返回正整数

    • o1对象小于o2返回负整数

    • o1对象等于o2返回零

    代码示例：

    比较器：

    1. import java.util.Comparator;
    2.  
    3. class stuComparator implements Comparator {
    4.  
    5.     @Override
    6.     public int compare(Object o1, Object o2) {
    7.         Student s1 = (Student) o1;
    8.         Student s2 = (Student) o2;
    9.  
    10.         int i = s1.getScore() - s2.getScore();//先比较分数 s1s2 正数
    11.         i = i == 0 ? s1.getAge() - s2.getAge() : i;
    12.         i = i == 0 ? s1.getName().compareTo(s2.getName()) : i;
    13.         return i;
    14.     }
    15. }

     测试类：

    1. public class Student {
    2.     private String name;
    3.     private int age;
    4.     private int score;
    5.  
    6.     public Student(String name, int age, int score) {
    7.         this.name = name;
    8.         this.age = age;
    9.         this.score = score;
    10.     }
    11.  
    12.     public String getName() {
    13.         return name;
    14.     }
    15.  
    16.     public void setName(String name) {
    17.         this.name = name;
    18.     }
    19.  
    20.     public int getAge() {
    21.         return age;
    22.     }
    23.  
    24.     public void setAge(int age) {
    25.         this.age = age;
    26.     }
    27.  
    28.     public int getScore() {
    29.         return score;
    30.     }
    31.  
    32.     public void setScore(int score) {
    33.         this.score = score;
    34.     }
    35.  
    36.     @Override
    37.     public String toString() {
    38.         return "Student{" +
    39.                 "name='" + name + '\'' +
    40.                 ", age=" + age +
    41.                 ", score=" + score +
    42.                 '}';
    43.     }
    44. }

    1. public class Demo {
    2.     public static void main(String[] args) {
    3.         Student[] arrs = new Student[6];
    4.         arrs[0] = new Student("a", 11, 100);
    5.         arrs[1] = new Student("b", 22, 90);
    6.         arrs[2] = new Student("c", 33, 80);
    7.         arrs[3] = new Student("d", 44, 70);
    8.         arrs[4] = new Student("e", 55, 60);
    9.         arrs[5] = new Student("f", 66, 50);
    10.         stuComparator scp = new stuComparator();
    11.         int compare = scp.compare(arrs[4], arrs[5]);
    12.         System.out.println("compare = " + compare);
    13.  
    14.         //遍历
    15.         for (int i = 0; i < arrs.length - 1; i++) {
    16.             for (int j = 0; j < arrs.length - 1 - i; j++) {
    17.                 if (scp.compare(arrs[j],arrs[j+1])>0){
    18.                     Student temp = arrs[j+1];
    19.                     arrs[j+1] = arrs[j];
    20.                     arrs[j] = temp;
    21.                 }
    22.             }
    23.         }
    24.         //打印
    25.         for (int i = 0; i < arrs.length; i++) {
    26.             System.out.println(arrs[i]);
    27.         }
    28.  
    29.     }
    30. }

    输出结果：

    1. compare = 10
    2. Student{name='f', age=66, score=50}
    3. Student{name='e', age=55, score=60}
    4. Student{name='d', age=44, score=70}
    5. Student{name='c', age=33, score=80}
    6. Student{name='b', age=22, score=90}
    7. Student{name='a', age=11, score=100}

    三、接口 Cloneable

    简单描述 java.lang.Cloneable 接口：

            一个类实现了此接口，这个类的对象就可以被Object.clone()方法进行克隆。

    标记接口：没有任何方法的接口。类似注解。

    在java.lang.Object类中有一个方法：

    protected Object clone()throws CloneNotSupportedException

    所有类型都可以重写这个方法，它是获取一个对象的克隆体对象用的，就是造一个和当前对象各种属性值一模一样的对象。当然地址肯定不同。

    我们在重写这个方法后时，调用super.clone()，发现报异常CloneNotSupportedException，因为我们没有实现java.lang.Cloneable接口。

    1. //克隆接口
    2. class Teacher implements Cloneable{
    3. 	private int id;
    4. 	private String name;
    5. 	public Teacher(int id, String name) {
    6. 		super();
    7. 		this.id = id;
    8. 		this.name = name;
    9. 	}
    10. 	public Teacher() {
    11. 		super();
    12. 	}
    13. 	public int getId() {
    14. 		return id;
    15. 	}
    16. 	public void setId(int id) {
    17. 		this.id = id;
    18. 	}
    19. 	public String getName() {
    20. 		return name;
    21. 	}
    22. 	public void setName(String name) {
    23. 		this.name = name;
    24. 	}
    25. 	@Override
    26. 	public String toString() {
    27. 		return "Teacher [id=" + id + ", name=" + name + "]";
    28. 	}
    29. 	@Override
    30. 	public Object clone() throws CloneNotSupportedException {
    31. 		return super.clone();
    32. 	}
    33. 	@Override
    34. 	public int hashCode() {
    35. 		final int prime = 31;
    36. 		int result = 1;
    37. 		result = prime * result + id;
    38. 		result = prime * result + ((name == null) ? 0 : name.hashCode());
    39. 		return result;
    40. 	}
    41. 	@Override
    42. 	public boolean equals(Object obj) {
    43. 		if (this == obj)
    44. 			return true;
    45. 		if (obj == null)
    46. 			return false;
    47. 		if (getClass() != obj.getClass())
    48. 			return false;
    49. 		Teacher other = (Teacher) obj;
    50. 		if (id != other.id)
    51. 			return false;
    52. 		if (name == null) {
    53. 			if (other.name != null)
    54. 				return false;
    55. 		} else if (!name.equals(other.name))
    56. 			return false;
    57. 		return true;
    58. 	}
    59. }

    测试类：

    1. public class Demo {
    2.     public static void main(String[] args) throws CloneNotSupportedException {
    3.         Teacher src = new Teacher(1,"苍老师");
    4.         Object clone = src.clone();
    5.         System.out.println(clone);
    6.         System.out.println(src == clone);
    7.         System.out.println(src.equals(clone));
    8.     }
    9. }

    浅浅地总结一下下~

    • Comparable接口：当一个类实现了此接口后，此类的对象就可以使用重写的CompareTo方法比较大小，自然排序。

    • Comparator接口：这个接口的实现类的compare方法可以比较任意类型的两个对象的大小，定制排序。

    • Cloneable接口：一个类实现了此接口，那么这个类的对象可以被Object类的clone方法进行克隆。

  • 相关阅读:
    k8s--基础--12.1--pod--概念
    java毕业设计车位管理系统Mybatis+系统+数据库+调试部署
    vue重修之Vuex【下部】
    软件设计师考试---标题、判定表、页式存储管理器、快速原型模型、三层C/S结构、耦合类型，
    【python刷题】--实战技巧总结(持续更新……)
    nRF52832 之ADC的使用
    使用numba cuda 加速Python运算
    Linux 之 JavaEE 定制篇-搭建 JavaEE 环境
    谁在成为产业供应链的“新发动机”？
    Python之Django
  • 原文地址：https://blog.csdn.net/Lwehne/article/details/127742224