Java:equals和==

让我们看看我们有两个对用户定义类的实例的引用，Java中的a和b。 会不会有这样的情况

---

a==b但a.equals（b）返回false？

是的，只是重载

equals

来做一些愚蠢的事情。e、 g

class Foo {
    @Override
    boolean equals(Object rhs) { return false; }
}

---

当然！

.equals（）

的实现完全取决于类，因此我可以编写：

class Foo
    public boolean equals(Object other) {
        return false;
    }
}

现在不管你通过哪两个实例——甚至是两次完全相同的实例——我总是说它们不相等

这种特别的设置是愚蠢的，但它说明了可以从同一对象的

.equals（）

中两次获得

false

结果

请注意，我们在这里讨论的是可以发生什么，而不是应该发生什么。任何类都不应该实现声称对象不等于自身的

.equals

方法。对于受信任的代码，可以合理地假设这种情况永远不会发生。

是的，很容易：

public class Wrong{
    public boolean equals(Object other) 
    {
    return false;
    }
}

---

当然，这完全打破了实现

.equals（）

-的正常规则-请参阅-但除了良好的判断力之外，没有什么可以阻止您。

可以覆盖

equals

方法，以便提供除典型的

=

方法之外的自定义功能。另外，某些类型，例如

Strings

在使用==方法时不会返回true。必须使用

.equals

或

.compareTo

（返回0时等于）

---

这应该提供一些

如果a==b

那么a.equals（b）应该是真的。如果a等于（b），那么可能a==b，但不一定

=

操作符只需测试两者是否引用同一对象。而

equals

执行您实现的逻辑。最后一个可以重写，第一个是语言中的运算符，在Java中不能重写

工具书类

从文件：

equals方法在非null上实现等价关系 对象引用：

它是自反的：对于任何非空参考值x，x.equals（x）应该返回true

它是对称的：对于任何非空的引用值x和y，当且仅当y.equals（x）返回时，x.equals（y）应返回true 对

它是可传递的：对于任何非空引用值x、y和z，如果x.equals（y）返回true，y.equals（z）返回true，则 x、 equals（z）应该返回true

它是一致的：对于任何非空的引用值x和y，x.equals（y）的多次调用始终返回true或true 如果没有在equals中使用信息，则始终返回false 修改对象上的比较

对于任何非空引用值x，x.equals（null）应返回false

---

是的，我们可以重载

.equals

函数以提供所需的输出。但在任何情况下，

=

都不会返回true，而

.equals

则会返回false

class s {
    int a;
}

class dev {
    public static void main(String args[]) {
        s a = new s();
        s b = new s();
        System.out.println(a == b);
        System.out.println(a.equals(b));
    }
}

输出 假的 假的 很明显，正如其他答案所指出的那样，编写这样做的代码是有可能的

但是，它在代码中也总是一个逻辑错误，因为它违反了equals（）函数的隐式一般约定

一个对象应该总是等于它自己，所以如果

（a==b）

那么

a.equals（b）

应该总是返回true

package com.stackOverFlow;

import java.util.Date;

public class SampleClass {

public static int  myint = 1;
private SampleClass() {
};

public Integer returnRandom() {
    return myint++;
}

private static SampleClass _sampleClass;

public static SampleClass getInstance() {

    if (_sampleClass == null) {
        _sampleClass = new SampleClass();
    }
    return _sampleClass;
}

@Override
public boolean equals(Object other) {
    if (this.returnRandom().equals(((SampleClass) other).returnRandom())) {
        return true;

    }
    return false;
}

}



package com.stackOverFlow;

public class Run {

/**
 * @param args
 */
public static void main(String[] args) {
    // TODO Auto-generated method stub

    SampleClass a = SampleClass.getInstance();
    SampleClass b = SampleClass.getInstance();
    if(a==b){
        System.out.println("references are same as they are pointing to same object");
        if(!a.equals(b)){
            System.out.println("two random number Instance will never be same");
        }
    }

}

}

---

你可以通过实例来理解这一点。其中Singleton类将始终返回相同的引用，您可以重写equals方法以获得非类变量的内容。示例：两个特定时间的数据库值，或随机数。希望你的情况得到澄清

然而，如果遵守

等于

的合同，这是不可能的；我对我的回答进行了编辑，以包括这一澄清。虽然技术上可行，但任何真正构建了这样一个东西的人都应该被吊销其编程许可证。这只是一堵由格式不好的代码组成的墙，按照目前的编写方式，至少需要两次阅读才能让已经懂Java的人理解。@Joey我是新手，下次会注意的。谢谢你指出这一点

package com.stackOverFlow;

import java.util.Date;

public class SampleClass {

public static int  myint = 1;
private SampleClass() {
};

public Integer returnRandom() {
    return myint++;
}

private static SampleClass _sampleClass;

public static SampleClass getInstance() {

    if (_sampleClass == null) {
        _sampleClass = new SampleClass();
    }
    return _sampleClass;
}

@Override
public boolean equals(Object other) {
    if (this.returnRandom().equals(((SampleClass) other).returnRandom())) {
        return true;

    }
    return false;
}

}



package com.stackOverFlow;

public class Run {

/**
 * @param args
 */
public static void main(String[] args) {
    // TODO Auto-generated method stub

    SampleClass a = SampleClass.getInstance();
    SampleClass b = SampleClass.getInstance();
    if(a==b){
        System.out.println("references are same as they are pointing to same object");
        if(!a.equals(b)){
            System.out.println("two random number Instance will never be same");
        }
    }

}

}