Java中的equals(),==,compareTo()和compare()

Java中的equals(),==,compareTo()和compare()

1. 首先只有==可以用作两个基本类型数据之间的比较，当然是值比较。当用作两个对象比较时，比较的是对象引用，而不是值比较。
2. 其次任何对象都可以调用.equals()方法，因为这是从Object类继承下来的。Object.equals(Object obj)的缺省实现也是比较对象引用（显然它不知道如何比较值），但Java类库中的绝大多数类都已覆盖了equals()方法，实现了值比较。当然如果你自定义一个类而且没有覆盖equals()方法，当然比较的还是对象引用。
3. 然后compareTo()方法是Comparable接口唯一需要实现的方法。它的返回值不同于equals()，返回的是int值-1、0和1，而不是true和false。如果你的自定义类有自然顺序，那么最好也implements这个Comparable接口并实现compartTo()方法。事实上，Java类库中许多类都实现了这个接口，比如：String、Integer、Date、Time等等。
4. 最后compare()是Comparator接口的一个方法。最为常见的用法是自定义一个类实现Comparator接口，然后在调用Collection.sort()时作为参数传递。这样可以在compare()方法的实现中指定集合元素的排序规则。

equals与compareTo的分别：

equals返回true   or   false。
CompareTo的用法如下：
      如果   String   str1   =   "ddd1 ";
String   str2   =   "ddd ";
那么，str1.compareTo(str2)   返回的是   1，即str1和str2   的长度差。
      如果   String   str1   =   "ddD ";
String   str2   =   "ddd ";
那么，str1.compareTo(str2)   返回的是   -32，即str1和str2中   第一个不相等的字符   ‘D’   和   ‘d’   的ASCII码的差值。

更详细的，可以去看javadoc

 

equals 是比较两个值的大小 而且在不重写的情况下 是比较两个值内容是否相等 ==是判断地址是否相等（好像是这样）

而compare to一般用来 比较引用的对象的值 而且可以被重写 Java compareTo作用是对一个类中的属性以一定的方式进行组织,写好了可以让数据更有序./** * 实现Comparable接口，重写compareTo方法，返回值1，0，-1 * 覆写compareTo方法就是重建排序规则 */ public int compareTo(Object obj) { Person p = (Person) obj; if (p.score > this.score) { return 1; } else if (p.score < this.score) { return -1; } else { // 如果成绩相等则判断年龄 if (p.age > this.age) { return 1; } else if (p.age < this.age) { return -1; } else { return 0; } } }

附其他资料1

一、简单类型比较

 

Java中，比较简单类型变量用“==”，只要两个简单类型值相等即返回ture，否则返回false；

 

二、引用类型比较

 

引用类型比较比较变态，可以用“==”，也可以用“equals()”来比较，equals()方法来自于Object类，每个自定义的类都可以重写这个方法。Object类中的equals()方法仅仅通过“==”来比较两个对象是否相等。

 

在用“==”比较引用类型时，仅当两个应用变量的对象指向同一个对象时，才返回ture。言外之意就是要求两个变量所指内存地址相等的时候，才能返回true，每个对象都有自己的一块内存，因此必须指向同一个对象才返回ture。

 

在用“equals()”比较引用类型时，情况就比较复杂，甚至有些变态，容易掉进陷阱。

 

在Java API中，有些类重写了equals()方法，它们的比较规则是：当且仅当该equals方法参数不是 null，两个变量的类型、内容都相同，则比较结果为true。这些类包括：String、Double、Float、Long、Integer、Short、Byte、、Boolean、BigDecimal、BigInteger等等，太多太多了，但是常见的就这些了，具体可以查看API中类的equals()方法，就知道了。

 

解析变态的Boolean类：在这些类中，最最变态的是要数Boolean类了，我感觉是开发Boolean类的人员头脑进水了。我也不想细说了，你有好四中方式来创建一个Boolean对象（两构造方法，两个静态方法valueOf()，推荐用静态方法）。

 

Boolean类的变态之处不在于其equals()方法。而是在于Boolean对象创建方法。其实Boolean类的对象最多有两个，其toString()值分别是true和false。当且仅当用true或者"true"创建的Boolean类为同一个对象且toString()值为true。其他的字符串或者false创建的Boolean对象的值一律相等且toString()值为false。

 

三、重写equals()方法

 

在定义一个类的时候，如果涉及到对象的比较，应该重写equals()方法。重写的一般规则是：

 

1、先用“==”判断是否相等。

 

2、判断equals()方法的参数是否为null，如果为null，则返回false；因为当前对象不可能为null，如果为null，则不能调用其equals()方法，否则抛java.lang.NullPointerException异常。

 

3、当参数不为null，则如果两个对象的运行时类（通过getClass()获取）不相等，返回false，否则继续判断。

 

4、判断类的成员是否对应相等。往下就随意发挥了。呵呵！

 

 

四、总结

 

“==”比较对象是否引用了同一个对象，或者比较简单类型变量值是否相等。

Object类的equals()方法用来比较是否一个对象（内存地址比较），可以重写。

JDK中有些类重写了equals()方法，只要类型、内容都相同，就认为相等。

很变态的Boolean类，仅存在两个实例。具体可查看API。

一般来说，一个类如果涉及到比较，应该重写equals()方法，因为内存地址比较没有意义。

附其他资料

java 中对象比较大小

java 中对象比较大小有两种方法
1：实现Comparable 接口 的 public int compareTo(T o) 方法；

2：实现Comparator 接口 的   int compare(T o1, T o2)方法；

代码如下：

    import java.util.ArrayList;  
    import java.util.Collections;  
    import java.util.Comparator;  
    import java.util.List;  
    import java.util.Set;  
    import java.util.TreeSet;  
      
    public class Test {  
        public static void main(String[] args) {  
            List list =new ArrayList();  
            list.add(new Dept("2","研发部",23));  
            list.add(new Dept("2","总公司",575));  
            list.add(new Dept("2","总公司",565));  
    //      Collections.sort(list);  
            Collections.sort(list, new Comparator(){  
      
                public int compare(Object arg0, Object arg1) {  
                    // TODO Auto-generated method stub  
                    Dept dept1=(Dept)arg0;  
                    Dept dept2=(Dept)arg1;  
                    return dept1.compareTo(dept2);  
                }  
                  
            });  
              
            for (int i=0;i<list.size();i++){  
                System.out.println((Dept)list.get(i));  
            }  
              
              
            Dept dept1=new Dept("2","研发部",23);  
            Dept dept2=new Dept("2","kk",44);  
            Set set=new TreeSet(new Comparator(){  
      
                public int compare(Object arg0, Object arg1) {  
                    // TODO Auto-generated method stub  
                    return 0;  
                }  
                  
            });  
            set.add(dept1);  
            set.add(dept2);  
              
          
        }  
    }  
      
    class Dept implements Comparable{  
        private String id;  
        private String name;  
        private long num;  
        public Dept(String id,String name,long num){  
            this.id=id;  
            this.name=name;  
            this.num=num;  
        }  
        public String getId() {  
            return id;  
        }  
      
        public void setId(String id) {  
            this.id = id;  
        }  
      
        public String getName() {  
            return name;  
        }  
      
        public void setName(String name) {  
            this.name = name;  
        }  
      
        public long getNum() {  
            return num;  
        }  
      
        public void setNum(long num) {  
            this.num = num;  
        }  
      
        public int compareTo(Object arg0) {  
            Dept dept=(Dept) arg0;  
            int i=0;  
            i=this.id.compareTo(dept.id);  
            if(i!=0){//部门id不相等  
                return i;  
            }else{//部门id相等  
                i=this.name.compareTo(dept.name);  
                if(i!=0){//部门名称不相等  
                    return i;  
                }else{//部门名称不相等  
                    if(this.num>dept.num)return 1;  
                    else if(this.num<dept.num)return -1;  
                    else return 0;  
                }  
            }  
              
        }  
        public String toString() {  
            // TODO Auto-generated method stub  
            return this.id+"-->"+this.name+"-->"+this.num;  
        }  
      
    }