Java基础07——equals、对象数组、clone

1.equals

（1）关系操作符”==“——生成的是一个boolean结果，它们计算的是操作数的值之间的关系。

它比较的是堆地址是否相等。（java中，值相等的两个量默认指向一个堆，例如下）

public class Eg {
    public static void main(String[] args) {
        String s="hl";
        String s1="hl";
        String s2=new String("hl");
        System.out.println(s==s1);//return true
        System.out.println(s==s2);//return false(不在一个堆中)
    }
}

（2）equals方法——Object类中，equals方法是用来比较两个对象的引用是否相等，即是否指向同一个对象。

它比较的是值是否相等。

一般我们在设计一个类时，需要重写父类的equals方法，在重写这个方法时，需要按照以下几个规则设计：
1、自反性：对任意引用值X，x.equals(x)的返回值一定为true.
2、对称性：对于任何引用值x,y,当且仅当y.equals(x)返回值为true时，x.equals(y)的返回值一定为true;
3、传递性：如果x.equals(y)=true, y.equals(z)=true,则x.equals(z)=true
4、一致性：如果参与比较的对象没任何改变，则对象比较的结果也不应该有任何改变
5、非空性：任何非空的引用值X，x.equals(null)的返回值一定为false

重写的例子如下：

class AnimalWorld{
    private int age;
    private String name;
    public AnimalWorld(int age,String name){
        this.age=age;
        this.name=name;
    }
    public boolean equals(Object obj){
        if(obj==null){
            return false;
        }
        if(obj==this){
            return true;
        }
        if(obj.getClass()!=this.getClass()){
            return false;
        }
        AnimalWorld that=(AnimalWorld) obj;
        return this.age==that.age&&this.name.equals(that.name);
    }
}
public class 比较的重写 {
    public static void main(String[] args) {
        AnimalWorld a=new AnimalWorld(10,"we");
        AnimalWorld a1=new AnimalWorld(10,"we");
        System.out.println(a==a1);
        System.out.println(a.equals(a1));//重写的比较方法
    }
}

2.对象数组

所谓对象数组，就是指包含了一组相关的对象，但是在对象数组的使用中一定要清楚一点：数组一定要先开辟空间，但是因为其是引用数据类型，所以数组里面的每一个对象都是null值，则在使用的时候数组中的每一个对象必须分别进行实例化操作。

public class A {

    public static void main(String[] args) {
        Person[] p={
                new Person(6,"MIKE"),
                new Person(2,"ROSE"),
                new Person(6,"NIKE")
        };
    }

}
class Person{
    public Person(int age, String name) {
        this.age = age;
        this.name = name;
    }
    private int age;
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

}

（1）对象数组的排序——需要重写sort方法，告诉系统按哪种方式排序。

方法：对这个对象数组的类实现Comparable，重写其中的compareTo方法。例如下：

import java.util.Arrays;
public class A{
    public static void main(String[] args) {
        Person[] ps={
                new Person(6,"MIKE"),
                new Person(2,"ROSE"),
                new Person(4,"NIKE")
        };

        Arrays.sort(ps);

        for(Person person :p){
            System.out.println(person.getName());
        }
    }

}
class Person implements Comparable{
    public Person(int age, String name) {
        this.age = age;
        this.name = name;
    }

    private int age;
    private String name;


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public int compareTo(Object o) {//排序算法
        Person that=(Person)o;
        return this.age-that.age==0?this.name.compareTo(that.name):this.age-that.age;
    }
}

 

3.对象的克隆（clone）

（1）浅层拷贝（Fleet）

仅仅对对象成员的逐成员拷贝。只适用于基本类型和高级类型中的基本类型的克隆。

public class 浅克隆 extends Object{

    public static void main(String[] args) throws CloneNotSupportedException {//抛出克隆不支持异常
        Person p=new Person("mike",100);
        Person p1=(Person)p.clone();
        System.out.println(p1.getName()+p1.getAge());
        p.setName("rose");
        System.out.println(p1.getName());//p1不再随p改变，证明克隆成功。
    }
}
class Person implements Cloneable{

    private String name;
    private int age;
    
    @Override//重写克隆方法
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    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 Person(String name,int age){
        this.name=name;
        this.age=age;
    }

}


//输出：
//mike100
//mike

高级类型浅克隆存在的问题：

public class 克隆 extends Object{
    public static void main(String[] args) throws CloneNotSupportedException {
        Professor pro=new Professor("pink");
        Person p=new Person("mike",100,pro);
        Person p1=(Person)p.clone();//开始克隆
        System.out.println(p.getPro().getColor());//输出pink

        p1.getPro().setColor("red");//这时修改p1的属性，如果克隆成功，p便不会发生变化
        System.out.println(p.getPro().getColor());//输出red，说明color属性的地址并未改变，浅克隆不能解决这个问题。
    }
}


class Professor{
    private String color;
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public Professor(String color) {
        this.color = color;
    }
}
class Person implements Cloneable{

    private String name;
    private int age;
    private Professor pro;

    @Override//重写克隆方法
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    public Professor getPro() {
        return pro;
    }
    public void setPro(Professor pro) {
        this.pro = pro;
    }
    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 Person(String name,int age,Professor pro){
        this.name=name;
        this.age=age;
        this.pro=pro;//聚合
    }
}

 所以我们需要进行深克隆。

（2）深层拷贝（Deep）

不仅拷贝对象的字段，而且还对对象通过字段关联的其他对象实施拷贝，即对于当前对象关联的其他对象，深克隆要先创建这个其他对象再实施克隆、迭代。

由浅克隆修改为深克隆方法：Professor实现cloneable，重写clone方法；Person中重写方法中添加pro的克隆内容。

public class 克隆 extends Object{

    public static void main(String[] args) throws CloneNotSupportedException {//抛出克隆不支持异常
        Professor pro=new Professor("pink");
        Person p=new Person("mike",100,pro);
        Person p1=(Person)p.clone();//开始克隆
        System.out.println(p.getPro().getColor());//输出pink

        p1.getPro().setColor("red");//这时修改p1的属性，如果克隆成功，p便不会发生变化
        System.out.println(p.getPro().getColor());//输出pink，说明克隆成功。
    }
}


class Professor implements Cloneable{

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    private String color;

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public Professor(String color) {
        this.color = color;
    }
}
class Person implements Cloneable{

    private String name;
    private int age;
    private Professor pro;

    @Override//重写克隆方法
    protected Object clone() throws CloneNotSupportedException {
        Person p=(Person) super.clone();//克隆出新的person
        p.pro=(Professor) this.pro.clone();//克隆出pro并将其与新的person关联
        return p;
    }

    public Professor getPro() {
        return pro;
    }
    public void setPro(Professor pro) {
        this.pro = pro;
    }
    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 Person(String name,int age,Professor pro){
        this.name=name;
        this.age=age;
        this.pro=pro;//聚合
    }
}

Clone推荐阅读——详解Java中的clone方法 -- 原型模式：https://blog.csdn.net/zhangjg_blog/article/details/18369201