数据结构笔记02

三个前置知识：
1.Person p=…;
2.Person q=…;

p==q  代表    p和q是否指向同一个对象
p.equals(q)  代表  p指向的对象和q指向的对象是否相同

class Teacher{
    String name;
    Teacher(String name){
        this.name=name;
    }

    Teacher t1=new Teacher("haha");
    Teacher t2=new Teacher("haha");
    Teacher t3=new Teacher("heha");
    Teacher t4=new Teacher("heha");
}

//t1.equals(t2) 目前的返回值是false
// t1.equals(t2) 目前的返回值是false
//因为，java语言本身无法得知，两个对象是否代表同一个现实的事物，需要开发者给出指导(通过重写equals方法）

修复方法：重写equals方法

 public boolean equals(Object o){
    //需要我们按照我们的建模方式，给出指导
    //指导this指向的对象和o指向的对象，是否代表同一个现实事物

        //1.this不是null，所以检查obj是不是null
        if(obj==null){
            return false;
        }

        //2/检查类型，不同的类型，“肯定”代表不了同一个事物
        if(!(obj instanceof Teacher)){
            return false;
        }

        //3.根据我们的设计类的目的，来判断对象是否代表同一个事物，主要名字一样，就代表同一类事物
        Teacher o=(Teacher)obj;//向下转型
        return this.name.equals(o.name);
    }

2.比较老师类中的“大小”

package NewJavaClass.Test2009;

/**
 * @ Author     ：CYD
 * @ Date       ：Created in 10:49 2020/9/12
 * @ Description：
 * @ Modified By：判断年龄等的大小
 */
// 同时实现 Comparable 接口，表名自己具备进行“比较”的能力
class Teacher2 implements Comparable<Teacher2> {
    String name;
    int age;
    int height;
    int weight;

    public Teacher2(String name, int age, int height, int weight) {
        this.name = name;
        this.age = age;
        this.height = height;
        this.weight = weight;
    }

    // natural ordering
    // “大小”关系如何决定，留给开发者自己决定
    // 目前的实现，是按照年龄进行比较
    @Override
    public int compareTo(Teacher2 o) {
        if (this.age < o.age) {
            // this 指向的对象“小于” o 指向的对象
            return -1;  // 任意负数都可以
        } else if (this.age == o.age) {
            // this 指向的对象 “等于” o 指向的对象
            return 0;
        } else {
            // this 指向的对象 “大于” o 指向的对象
            return 1;   // 任意整数都可以
        }
    }
}

public class ComparableDemo {
    public static void main(String[] args) {
        Teacher2 t1 = new Teacher2("haha", 18, 190, 80);
        Teacher2 t2 = new Teacher2("hehe", 38, 170, 100);

        // 对两个对象进行“比较”
        // 使用规则
        int r = t1.compareTo(t2);
        if (r < 0) {
            // 代表的意思就是 t1 指向的对象代表的现实事物 小于 t2 指向的对象代表的现实事物
            System.out.println("haha 小于 hehe");
        } else if (r == 0) {
            // 代表的意思就是 t1 指向的对象代表的现实事物 等于 t2 指向的对象代表的现实事物
            System.out.println("haha 等于 hehe");
        } else {
            // 代表的意思就是 t1 指向的对象代表的现实事物 大于 t2 指向的对象代表的现实事物
            System.out.println("haha 大于 hehe");
        }

        r = t2.compareTo(t1);
        // 怎么根据 r 的值理解？
        // r 肯定大于 0
        System.out.println(r);
    }

    //当需要比较别的是，通常很难改变Teacher类，所以引入comparator
}

3.当需要比较别的，通常很难改变Teacher类，所以引入comparator

package NewJavaClass.Test2009;
import java.util.Comparator;
/**
 * @ Author     ：CYD
 * @ Date       ：Created in 11:28 2020/9/12
 * @ Description：
 * @ Modified By：
 */
class ByHeightComparator implements  Comparator<Teacher2>{
    @Override
    public int compare(Teacher2 o1, Teacher2 o2) {
        return o1.height-o2.height;
    }
}

class ByWeightComparator implements  Comparator<Teacher2>{
    @Override
    public int compare(Teacher2 o1, Teacher2 o2) {
        return o1.weight-o2.weight;
    }
}


public class ComparatorDemo {
    public static void main(String[] args) {
        Teacher2 t1 = new Teacher2("haha", 18, 190, 80);
        Teacher2 t2 = new Teacher2("hehe", 38, 170, 100);

        Comparator<Teacher2> byHeight=new ByHeightComparator();
        Comparator<Teacher2> byWeight=new ByWeightComparator();

        int r;

        //按照自然顺序（我们实现的年龄）比较
        r=t1.compareTo(t2);
        System.out.println(r);   //

        //按照身高比较
        r=byHeight.compare(t1,t2);
        System.out.println(r);

        //按照年龄比较
        r=byWeight.compare(t1,t2);
        System.out.println(r);

    }
   

java 中提供了关于对象的比较，有以下方式：

1.eauals()

    所有的类都具有的能力
    理解：比较两个对象代表的是不是一个实际事物
   规则：需要重写equals方法才能达到

2.大小的比较

    1.自然顺序 Comparable comparTo()
    不是所有类都具备，需要通过实现Comparable接口来表明该类具备这个能力
理解：比较this和传入的引用指向的对象

    2.外部比较（比较器）Comparator--构造一个天平
不需要比较类具备Comparable的能力
        理解：比较 传入的两个引用指向的对象

两个比较相等，并不说明两个对象代表的是同一个现实事物
if(t1.compaeTo(t2))==0){
并不能保证t1.equals(t2)一定是true
}

泛型

1.为什么要引入泛型 实现了一个冒泡排序（只能int[] 数组）

若想冒泡排序（double类型 Teacher类型

思路一：为每一种类型都写一个冒泡排序算法 思路二：抽取不变的部分，把变化的部分独立

分析：整个冒泡排序过程中，只有类型在变，其他都不变 把类型变成“类似变量”效果

泛型—为此而生

见generic
好多代码

调用泛型方法：
完整的调用方式
类名.<实际的类型>方法名称（参数列表）；