java 对象/字符串的比较

1、同类型对象的比较：

        同一性关系：对象是否为同一个对象

        相等性关系：对象的具体内容是否相等

直接使用==进行比较默认比较对象的同一性，即引用指向的是否为同一个对象。

如果要进行对象具体内容的比较，则通过重写equals方法来实现。

例如现在有两本一样的书，他们的内容是完全相同的，直接使用==比较的话那么比较的为同一性，由于不是同一本书，因此就是false。但这两本书的内容是相同的，通过重写equals方法可以根据需要对对象进行内容的比较：示例如下

public class Book {
    public String name;
    public String color;
    public int page;

    public Book(String name, String color, int page) {
        this.name = name;
        this.color = color;
        this.page = page;
    }

    //根据需要判断所要比较的对象内容
    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        Book v = (Book) o;
        return this.name == v.name && this.color == v.color
                && this.page == v.page;
    }
}

public class Demo {
    public static void main(String[] args) {
        //内容相同的两本书
       Book book1 = new Book("百年孤独","黑",360);
       Book book2 = new Book("百年孤独","黑",360);
        System.out.println(book1 == book2); //false 同一性（同一对象）比较
        System.out.println(book1 == book1); //true

        //判断对象的内容是否相等
        System.out.println(book1.equals(book2)); //true 重写了equals方法
    }
}

2、对象大小的比较：

        理论上对象是没有大小的，进行对象大小的比较实际上是人为按照一定的逻辑进行比较。JDK中的本身提供了comparable接口当某个类实现了该接口，那么这个类实例化的对象就具备了比较能力。例如有两个Person对象，假定身高高的对象要比身高低的对象大。对象大小的比较返回值类型默认为int型。返回值小于0意味着this < obj.余下同理

最直观的应用就是比如我们要根据人的身高来排序，最后进行输出，通过实现comparable接口进行对象大小的比较就提供了很大的便利。

示例如下：

public class Person implements Comparable{ //实现Comparable接口
    public String name;
    public int height;
    public Person(String name,int height){
        this.name = name;
        this.height = height;
    }

    @Override
    public int compareTo(Object o) {
        Person p = (Person) o;
        if(this.height < p.height){
            return -1;  //身高低的对象小
        }
        if(this.height == p.height){
            return 0;
        }
        return 1;
    }
}

public class Demo {
    public static void main(String[] args) {
        Person[] person ={
                new Person("张三",180),
                new Person("李胜",175),
                new Person("赵五",182),
                new Person("周放",160)
        };
        sortPerson(person);
        for (Person v :person) {
            System.out.println(v.name + "  " + v.height);
        }
    }
    private static void sortPerson(Person[] p){
        for(int i = 0;i < p.length - 1;i++){
            for(int k = 0;k < p.length - i - 1;k++){
                int n = p[k].compareTo(p[k + 1]);
                if(n >= 0){
                    Person tmp = p[k];
                    p[k] = p[k + 1];
                    p[k + 1] = tmp;
                }
            }
        }
    }
}

结果如下：

由于compareTo无法满足所有场景，因此java中还提供了比较器Comparator，通过实现Comparator接口实现两个对象的比较

public class compare implements Comparator {

    @Override
    public int compare(Object o1, Object o2) {

    }
}

3、字符串的比较：

        使用==直接比较，是比较的同一性（同一对象）。

        通常情况下equals方法比较的仍然为同一性，要比较相等性（对象内数据）就需要重写equals方法。但String用的频率高，所以String中的的equals比较的是相等性。

字符串比较较为特殊，String s = "hello", String s1 = "hello"s引用应当指向一个对象。但是在java中逻辑上存在字符串常量池，此时的s与s1都在字符串常量池中因此判断s == s1是true。

当String s2 = new String("hello");new出来的s2就在JVM的堆上，此时s1 == s2 就为false 

==判断，在字符串常量池中的相同字符串就是true，在堆上同一个对象则为true。

还可以利用inter()使堆中字符串对象进入字符串常量池。

 

当执行完s3.intern()后，返回堆区对象的引用。

public class Demo2 {
    public static void main(String[] args) {
        String s1 = "hello";  //存在于逻辑上的字符串常量池中
        String s2 = "hello";
        String s3 = new String("hello"); //两不同对象
        String s4 = new String("hello");

        System.out.println(s1 == s2); //true
        System.out.println(s1 == s3); //false
        System.out.println(s3 == s4); //false
        System.out.println(s1.equals(s3)); //true
        String v = s3.intern();
        System.out.println(v == s2); //true
    }
}