Java--对自定义类型进行排序、拷贝

**自定义类型进行排序 **

1.Arrays.sort() 用于简单类型排序
自定义类型排序需要在类上实现一个接口Comparable<>，并且重写他的compareTo（）方法

class Student implements Comparable<Student>{
    public String name;
    public int age;
    public double score;

    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }
        @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
    @Override
    public int compareTo(Student o) {
        return this.age-o.age;//整形
        //return (int)(this.score - o.score);
        //return this.name.compareTo(o.name);
    }
}


    public static void main1(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("liubei",78,97.6);
        students[1] = new Student("caocao",48,186.9);
        students[2] = new Student("ahangfei",98,100.8);
		Arrays.sort(students);
        
    }

重写compareTo（）方法时返回值的三种类型：

    @Override
    public int compareTo(Student o) {
		1.return this.age-o.age;//整形
		2.return (int)(this.score - o.score);//double型
		3.return this.name.compareTo(o.name);//String类型
    }
}

2.自己写sort()方法
方法中传的数据类型肯定是Comparable接口类型的。

    public static void sort(Comparable[] comparables) {
        //冒泡写
        for (int i = 0; i < comparables.length; i++) {
            for (int j = 0; j < comparables.length-1-i; j++) {
                if(comparables[j].compareTo(comparables[j+1]) > 0) {
                    Comparable tmp = comparables[j + 1];
                    comparables[j  + 1] = comparables[j];
                    comparables[j] = tmp;
                }
            }
        }
    }

自定义类型进行拷贝

Arrays.clone用于简单类型拷贝
自定义类型拷贝需要在类上实现一个接口Cloneable
Cloneable：没有抽象方法，空接口
空接口:标记接口–>标志当前类可以进行克隆
重写clone（）方法并抛出异常throws CloneNotSupportedException

class Person{
    public String name;
    Money money;
    public Person (String name) {
        this.name = name;
        this.money = new Money();
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
    public static void main2(String[] args) throws CloneNotSupportedException {
        Person person = new Person();
        person.name = "caocao";
        System.out.println(person.name);
        System.out.println("clone");
        Person person2 = (Person) person.clone();
        person2.name = "liubei";
        System.out.println(person.name);
        System.out.println(person2.name);
    }

自定义类型Person 中存在一个自定义类型Money money，现在克隆person 实现money的深拷贝

class Money implements Cloneable{
    double m  = 12.9;
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
class Person implements Cloneable{
    public String name;
    Money money;
    public Person() {

    }
    public Person (String name) {
        this.name = name;
        this.money = new Money();
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Person p = (Person) super.clone();
        p.money = (Money) this.money.clone();
        return p;
    }
}

    public static void main3(String[] args) throws CloneNotSupportedException {
        Person person = new Person("caocao");
        Person person2 = (Person) person.clone();
        person2.money.m = 99.99;
        System.out.println(person.money.m);
        System.out.println(person2.money.m);
    }