前言
由于Comparable和Comparator密切相关,所以我们先介绍这两个接口!
文章目录
1. 简述Comparable Comparator
Java中的排序是由Comparable和Comparator这两个接口来提供的。
Comparable表示可被排序的,实现该接口的类的对象自动拥有排序功能。
Comparator则表示一个比较器,实现了该接口的的类的对象是一个针对目标类的对象定义的比较器,一般情况,这个比较器将作为一个参数进行传递。
1.1 Comparable接口
这个接口一般用于内部比较,侵入性比较强,也就是不太灵活!
我们来具体看例子说话:
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;
class Student implements Comparable<Student>{
private String name;
private int score;
private int age;
public Student(String name,int score,int age){
this.name=name;
this.score=score;
this.age=age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", score=" + score +
", age=" + age +
'}';
}
@Override
public int compareTo(Student o) {
//return this.score-o.score;//用成绩排
//return this.name.compareTo(o.name);//用姓名排
return this.age-o.age;//用年龄排
}
}
public class TestDemo {
public static void main(String[] args) {
Student[] studens= {new Student("wang",99,18),
new Student("sun",93,11),
new Student("li",95,13)
};
for (int i = 0; i < studens.length; i++) {
System.out.println(studens[i].toString());
}
System.out.println();
Arrays.sort(studens);
for (int i = 0; i < studens.length; i++) {
System.out.println(studens[i].toString());
}
}
}
当我们对自定义对象进行排序时,我们的得指定一个排序的基准,比如以成绩或者年龄或者姓名.
但是用这种方法,我们的面临着一个问题,比如我们一开始是以成绩来排的,现在我们想用年龄来排,那这就得去修改,个人还好,如果在一个公司中呢?你一改,别人都得跟着改,这不是牵一发而动全身吗??
所以我们可以使用Comparator这个接口来实现!
1.2 Comparator接口
这个接口我们可以称为外部比较器,因为与Comparable相比而言,他是单独在外部实现类来进行排序的!
sort中有这个方法!
我们来看看怎么实现吧:
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Random;
import java.util.Scanner;
class Student{
public String name;
public int score;
public int age;
public Student(String name,int score,int age){
this.name=name;
this.score=score;
this.age=age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", score=" + score +
", age=" + age +
'}';
}
}
class AgeComparator implements Comparator<Student>{
@Override
public int compare(Student o1, Student o2) {
return o1.age-o2.age;
}
}
class ScoreComparator implements Comparator<Student>{
@Override
public int compare(Student o1, Student o2) {
return o1.score-o2.score;
}
}
class NameComparator implements Comparator<Student>{
@Override
public int compare(Student o1, Student o2) {
return o1.name.compareTo(o2.name);
}
}
public class TestDemo {
public static void main(String[] args) {
Student[] studens= {new Student("wang",99,18),
new Student("sun",93,11),
new Student("li",95,13)};
for (int i = 0; i < studens.length; i++) {
System.out.println(studens[i].toString());
}
System.out.println("分数比较");
ScoreComparator scoreComparator=new ScoreComparator();
Arrays.sort(studens,scoreComparator);
for (int i = 0; i < studens.length; i++) {
System.out.println(studens[i].toString());
}
System.out.println("姓名比较");
NameComparator nameComparator=new NameComparator();
Arrays.sort(studens,nameComparator);
for (int i = 0; i < studens.length; i++) {
System.out.println(studens[i].toString());
}
System.out.println("年龄比较");
AgeComparator ageComparator=new AgeComparator();
Arrays.sort(studens,ageComparator);
for (int i = 0; i < studens.length; i++) {
System.out.println(studens[i].toString());
}
}
大家看这样是不是灵活多了,我想用啥比较就用啥比较,简直
1.3 二者比较
Comparable可以看做是内部比较器,Comparator可以看做是外部比较器。
一个类,可以通过实现Comparable接口来自带有序性,也可以通过额外指定Comparator来附加有序性。
2.Cloneable接口
2.1简述
Cloneable是标记型的接口,它们内部都没有方法和属性,实现 Cloneable来表示该对象能被克隆,能使用Object.clone()方法。如果没有实现 Cloneable的类对象调用clone()就会抛出CloneNotSupportedException。
也就是说Cloneable接口赋予类可以被克隆的属性!
2.2克隆的分类
浅克隆(shallow clone),浅克隆是指拷贝对象时仅仅copy对象本身和对象中的基本变量,而不拷贝对象包含的引用指向的对象。
深克隆(deep clone),不仅copy对象本身,而且copy对象包含的引用指向的所有对象。
举例:对象X中包含对Y的引用,Y中包含对Z的引用。浅拷贝X得到X1,X1中依然包含对Y的引用,Y中依然包含对Z的引用。深拷贝则是对浅拷贝的递归,深拷贝X得到X1,X1中包含对Y1(Y的copy)的引用,Y1中包含对Z1(Z的copy)的引用。
2.3 克隆代码举例
要让对象可以被克隆,应具备以下2个条件:
让该类实现java.lang.Cloneable接口;
重写(Override)Object的clone()方法;
class Person implements Cloneable{
private String name;
private int age;
public Person(String name,int age){
this.name=name;
this.age=age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
public class TestDemo {
public static void main(String[] args) throws CloneNotSupportedException {
Person person1=new Person("xiaohong",20);
Person person2=(Person) person1.clone();
System.out.println(person2.toString());
}
内存图类似
2.3.1浅拷贝
class Money{
public double m=12.5;
}
class Person implements Cloneable{
private String name;
private int age;
public Person(String name,int age){
this.name=name;
this.age=age;
}
Money money=new Money();
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
public class TestDemo {
public static void main(String[] args) throws CloneNotSupportedException {
Person person1=new Person("xiaohong",20);
Person person2=(Person) person1.clone();
System.out.println(person1.money.m);
System.out.println(person2.money.m);
System.out.println("========================");
person1.money.m=100;
System.out.println(person2.money.m);
}
}
我们看到了我们new一个money后,我们是我们通过person1修改了money中的值后,person也随之修改,这就验证了,直接重写clone方法就是浅拷贝!
内存图大概:
那我们如何让他深拷贝呢?
2.3.2深拷贝
我们在类中clone方法中进一步克隆,看代码:
class Money implements Cloneable{
public double m=12.5;
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
class Person implements Cloneable{
private String name;
private int age;
public Person(String name,int age){
this.name=name;
this.age=age;
}
Money money=new Money();
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
protected Object clone() throws CloneNotSupportedException {
Person tmp=(Person) super.clone();
tmp.money= (Money) this.money.clone();
return tmp;
}
}
public class TestDemo {
public static void main(String[] args) throws CloneNotSupportedException {
Person person1=new Person("xiaohong",20);
Person person2=(Person) person1.clone();
System.out.println(person1.money.m);
System.out.println(person2.money.m);
System.out.println("========================");
person1.money.m=100;
System.out.println(person1.money.m);
System.out.println(person2.money.m);
}
}
也就是说我们先克隆了一个person1对象给tmp,然后再将person1中的money这个对象再克隆给tmp中的money,然后返回tmp;
这就实现了深拷贝!!!
大概内存图: