目录
经典接口：
一、接口Comparable<T>
简单描述 java.lang.Comparable 接口：
一个类实现了此接口，这个类的对象就可以使用重写的compareTo方法来比较对象的大小。
类型参数：
T - 可以与此对象进行比较的那些对象的类型
方法摘要：
int | compareTo(T o)比较此对象与指定对象的顺序。 |
我们知道基本数据类型的数据（除boolean类型外）需要比较大小的话，之间使用比较运算符即可，但是引用数据类型是不能直接使用比较运算符来比较大小的。那么，如何解决这个问题呢？
Java给所有引用数据类型的大小比较，指定了一个标准接口，就是java.lang.Comparable接口：
package java.lang;
public interface Comparable{
int compareTo(Object obj);
}那么我们想要使得我们某个类的对象可以比较大小，怎么做呢？步骤：
第一步：哪个类的对象要比较大小，哪个类就实现java.lang.Comparable接口，并重写方法
-
方法体就是你要如何比较当前对象和指定的另一个对象的大小
第二步：对象比较大小时，通过对象调用compareTo方法，根据方法的返回值决定谁大谁小。
-
this对象（调用compareTo方法的对象）大于指定对象（传入compareTo()的参数对象）返回正整数
-
this对象（调用compareTo方法的对象）小于指定对象（传入compareTo()的参数对象）返回负整数
-
this对象（调用compareTo方法的对象）等于指定对象（传入compareTo()的参数对象）返回零
代码示例：
public class Student implements Comparable {
private String name;
private int age;
private int score;
//重写接口的方法：
//比较此对象与指定对象的顺序。
//如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数
@Override
public int compareTo(Object o) {
Student stu = (Student) o;
int i = this.age - stu.age;//先比较年龄
i = i == 0 ? this.score - stu.score : i;//年龄相同再比较分数
i = i == 0 ? this.name.compareTo(stu.name) : i;//分数也相同
return i;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", score=" + score +
'}';
}
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 getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public Student(String name, int age, int score) {
this.name = name;
this.age = age;
this.score = score;
}
public Student() {
}
}测试类：
public class Demo {
public static void main(String[] args) {
Student[] arr = new Student[6];
arr[0] = new Student("Tom",18,99);
arr[1] = new Student("Jack",19,88);
arr[2] = new Student("Rose",20,95);
arr[3] = new Student("Jerry",21,90);
arr[4] = new Student("Lucy",18,87);
arr[5] = new Student("James",18,99);
//对数组进行排序
for (int i = 0; i < arr.length -1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
if(arr[j].compareTo(arr[j+1]) > 0 ){
Student temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
//遍历数组
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}练习：自定义数组排序工具类
自定义一个数组工具类MyArrays，它包含一个静态方法，可以给任意对象数组用冒泡排序实现从小到大排序，该怎么定义这个方法呢？
//自定义数组工具
class MyArrays {
public static void sort(Object[] arr) {
//冒泡排序
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
Comparable c = (Comparable) arr[j];
if (c.compareTo(arr[j + 1]) > 0){
Object temp = arr[j];
arr[j] = arr[j+1];
arr[j+1]=temp;
}
}
}
}
public static void print(Object[] arr){
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}//测试数组工具
public class Demo {
public static void main(String[] args) {
Student[] arr = new Student[6];
arr[0] = new Student("Tom",18,99);
arr[1] = new Student("Jack",19,88);
arr[2] = new Student("Rose",20,95);
arr[3] = new Student("Jerry",21,90);
arr[4] = new Student("Lucy",18,87);
arr[5] = new Student("James",18,99);
MyArrays.print(arr);
System.out.println("----排序后------------------------");
MyArrays.sort(arr);
MyArrays.print(arr);
}
}
二、接口Comparator<T>
简单描述 java.lang.Comparator 接口：
创建这个接口的实现类对象，使用重写后的compare方法来对两个对象进行排序。
类型参数：
T - 此 Comparator 可以比较的对象类型
方法摘要：
int | compare(T o1, T o2)比较用来排序的两个参数。 |
boolean | equals(Object obj)指示某个其他对象是否“等于”此 Comparator。 |
思考：
（1）如果一个类，没有实现Comparable接口，而这个类你又不方便修改（例如：一些第三方的类，你只有.class文件，没有源文件），那么这样类的对象也要比较大小怎么办？
（2）如果一个类，实现了Comparable接口，也指定了两个对象的比较大小的规则，但是此时此刻我不想按照它预定义的方法比较大小，但是我又不能随意修改，因为会影响其他地方的使用，怎么办？
JDK在设计类库之初，也考虑到这种情况了，所以又增加了一个java.util.Comparator接口。
package java.util;
public interface Comparator{
int compare(Object o1,Object o2);
}那么我们想要比较某个类的两个对象的大小，怎么做呢？步骤：
第一步：继续沿用Student举例，首先编写一个stuComparator类，通常称之为比较器类型，实现java.util.Comparator接口，并重写比较方法
-
方法体就是你要如何指定的两个对象的大小
第二步：比较大小时，通过比较器类型的对象调用compare()方法，将要比较大小的两个对象作为compare方法的实参传入，根据方法的返回值决定谁大谁小。
-
o1对象大于o2返回正整数
-
o1对象小于o2返回负整数
-
o1对象等于o2返回零
代码示例：
比较器：
import java.util.Comparator;
class stuComparator implements Comparator {
@Override
public int compare(Object o1, Object o2) {
Student s1 = (Student) o1;
Student s2 = (Student) o2;
int i = s1.getScore() - s2.getScore();//先比较分数 s1<s2 负数, s1=s2 0, s1>s2 正数
i = i == 0 ? s1.getAge() - s2.getAge() : i;
i = i == 0 ? s1.getName().compareTo(s2.getName()) : i;
return i;
}
}测试类：
public class Student {
private String name;
private int age;
private int score;
public Student(String name, int age, int score) {
this.name = name;
this.age = age;
this.score = score;
}
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 getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", score=" + score +
'}';
}
}public class Demo {
public static void main(String[] args) {
Student[] arrs = new Student[6];
arrs[0] = new Student("a", 11, 100);
arrs[1] = new Student("b", 22, 90);
arrs[2] = new Student("c", 33, 80);
arrs[3] = new Student("d", 44, 70);
arrs[4] = new Student("e", 55, 60);
arrs[5] = new Student("f", 66, 50);
stuComparator scp = new stuComparator();
int compare = scp.compare(arrs[4], arrs[5]);
System.out.println("compare = " + compare);
//遍历
for (int i = 0; i < arrs.length - 1; i++) {
for (int j = 0; j < arrs.length - 1 - i; j++) {
if (scp.compare(arrs[j],arrs[j+1])>0){
Student temp = arrs[j+1];
arrs[j+1] = arrs[j];
arrs[j] = temp;
}
}
}
//打印
for (int i = 0; i < arrs.length; i++) {
System.out.println(arrs[i]);
}
}
}输出结果：
compare = 10
Student{name='f', age=66, score=50}
Student{name='e', age=55, score=60}
Student{name='d', age=44, score=70}
Student{name='c', age=33, score=80}
Student{name='b', age=22, score=90}
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接口。
//克隆接口
class Teacher implements Cloneable{
private int id;
private String name;
public Teacher(int id, String name) {
super();
this.id = id;
this.name = name;
}
public Teacher() {
super();
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Teacher [id=" + id + ", name=" + name + "]";
}
@Override
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + id;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Teacher other = (Teacher) obj;
if (id != other.id)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}测试类：
public class Demo {
public static void main(String[] args) throws CloneNotSupportedException {
Teacher src = new Teacher(1,"苍老师");
Object clone = src.clone();
System.out.println(clone);
System.out.println(src == clone);
System.out.println(src.equals(clone));
}
}浅浅地总结一下下~
-
Comparable接口：当一个类实现了此接口后，此类的对象就可以使用重写的CompareTo方法比较大小，自然排序。
-
Comparator接口：这个接口的实现类的compare方法可以比较任意类型的两个对象的大小，定制排序。
-
Cloneable接口：一个类实现了此接口，那么这个类的对象可以被Object类的clone方法进行克隆。
196
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
