Question

比较Java中的两个值时，如何测试类型和值是否相等？

我知道可以使用JavaScript ===来完成此操作，因此我在Java中进行了尝试，但是没有用。

我知道这是一个简单的问题，但是我尝试查找它，但找不到它是什么。

Answer 1

TL; DR

在Java中，没有这样的比较运算符：===，但是==或equals

详细说明

在弱类型语言（例如JavaScript）中，可以使用严格比较运算符（===），因为该语言允许在具有不同 type 的变量之间进行比较。

例如，在JavaScript中，如果执行此操作，则不会出现编译错误：

var x = 10;
var y = 'foo';
console.log(x == y); // false

当您想比较可能包含“等于”值但类型不同的变量时，它很有用。

例如

var x = 10;
var y = '10';
console.log(x == y)  // true
console.log(x === y) // false

在强类型语言（如Java）中，您不需要使用严格的比较运算符，因为该语言已经“处理”了类型比较。

例如：

int x = 10;
String y = "10";
System.out.println("10" == y); // true
System.out.println(x == y);    // compile error : Incompatible operand types int and String

因此，基本上，在Java中，不需要使用===来检查严格性（报告了语法错误）。

首先，当您使用==运算符比较不同类型的值而无法执行conversion时，编译器会抱怨。

在前面的Java代码示例中，如果要在x和y之间进行比较，可以使用equals：

int x = 10;
String y = "10";
System.out.println(y.equals(x)); // compile warning: Unlikely argument type for equals(): int seems to be unrelated to String

请注意，equals方法不能在原始类型上调用。

一些有用的读物是：

Answer 2

我制作了一个函数，该函数r 复制了Java中Javascript的=== 的功能

static boolean compareData(Object v1, Object v2)
{
    if(v1 != null && v2 != null)
        return (v1.getClass() == v2.getClass() && (v1.toString().equals(v2.toString())));
    else
    {
        return (v1 == null ? v2 == null : v1.equals(v2));
    }
}

我能够将任何数据类型（数组除外）的值传递给该函数，并且仅当数据类型和值匹配时才 true ，否则返回false。像 List和HashMap这样的派生数据类型也可以使用。

对此函数的调用如下所示：

float s1 = 0.f;
float s2 = 0.1f;

System.out.println(compareData(s1, s2)); //Returns false

float s1 = 0.0f;
float s2 = 0.0f;

System.out.println(compareData(s1, s2)); //Returns true

float s1 = 0.1f;
String s2 = "0.1f";

System.out.println(compareData(s1, s2)); //Returns false

String s1 = "sdf";
String s2 = null;

System.out.println(compareData(s1, s2)); //Returns false

String s1 = null;
String s2 = null;

System.out.println(compareData(s1, s2)); //Returns true

以此类推...

更新：我也设法比较了数组，以下是代码片段，但是，我并未对此代码进行密集测试，但适用于我执行的每个测试用例

if(s1 != null && s2 != null)
    if(s1.getClass().isArray() && s2.getClass().isArray())
        compareDatab = s1.getClass().equals(s2.getClass()) && (Arrays.toString(s1).equals(Arrays.toString(s2)));
    else
        compareDatab = compareData(s1, s2);
else
    compareDatab = compareData(s1, s2);

以上代码段的用法（以下初始化应在上述代码段之前完成，smh：P）：

//s1 and s2 can be anything including Arrays and non-Array...
int[] s1 = {1,2,3};
int[] s2 = {1,2,3};
//compareDatab gives true

int[] s1 = {1,2,4};
int[] s2 = {1,2,3};
//compareDatab gives false

float[] s1 = {1,2,3};
int[] s2 = {1,2,3};
//compareDatab gives false

compareData（）与此答案中先前所述的功能相同。

希望这对您有用。：）

Answer 3

Java中没有真与假的概念，因此没有严格的比较运算符。

Answer 4

===在弱类型语言（例如Javascript）中很有用，因为它可以验证被比较的对象是同一类型，并避免隐式转换。

===在诸如Java之类的强类型语言中绝对没有用，因为如果不编写特定的方法来执行此操作，则无法比较不同类型的变量。

Answer 5

在Java中，您可以使用'=='比较基本类型，例如int，double，char，long，float。在这种情况下，将比较值。对于对象比较，这是不够的，因为如果比较对象的标识相同，则“ ==”仅计算为“真”-“标识”是存储对象的内存地址。这是由于所有类都隐式继承了“ Object”类提供的所有方法，并且“ equals（）”方法仅包含一个基本实现。因此，在对象中涉及对象的任何类，用于数据结构中或在其自身包之外的类都应包含equals（）和hashCode（）方法的可靠实现。提供正确的功能。

关于以下实现：

public class MyClass {

  private final int val;
  private final String name;

  public MyClass(int val, String name) {
     this.val = val;
     this.name = name;
  }

  public int getVal() { return val; }

  public String getName() { return name; }

  public boolean equals(Object o) {
     if(o == null) return false;
     if(this == o) return true;
     if(!this.getClass().getSimpleName().equals(o.getClass().getSimpleName()) return false;

     MyClass other = (MyClass) o;

     return this.getVal() == other.getVal() && this.getName().equals(other.getName());
  }

  public int hashCode() { ... }

}

也请查看官方Java API以获取更多信息https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html。

Answer 6

如果两个变量的类型不同，则无法对其进行比较，因此在这种情况下==就足够了。如果它们不可转换，将引发编译器错误。

Answer 7

没有===运算符可进行比较。如果要比较两个参考，则应检查- 1.如果它们指向同一对象。

if(firstreference==secondreference)

如果以上条件1不满足，则应通过instanceof运算符检查其类型：

if (secondreference instanctof classoffirstreference)

如果上述条件2满足，则应通过equals运算符（例如）检查属性比较。

firstreference.property1.equals(secondreference.property1)
//do this for all properties.

Answer 8

如果我们在JS中比较两个变量，则可以同时使用“ ==”和“ ===”。 “ ==”比较值，“ ===”也比较类型。

<p>Input takes all width?</p>
<table>
  <tbody>
    <tr>
      <td width="250px">
        <div>
          <input type="text" name="some-field" />
          <button class="symbol" type="button"></button>
          <button class="symbol" type="button"></button>
        </div>
      </td>
    </tr>
  </tbody>
</table>

<p>No Width</p>
<table>
  <tbody>
    <tr>
      <td>
        <div>
          <input type="text" name="some-field" />
          <button class="symbol" type="button"></button>
          <button class="symbol" type="button"></button>
        </div>
      </td>
    </tr>
  </tbody>
</table>

在Java中，由于类型不同，这会给您带来编译错误。

Answer 9

为此我看不到编写自己的比较器的任何好处。尤其是如果已经有本机实现。

java.util.Objects是你的朋友。

它包含很多小帮手，例如

Objects.compare(object1, object2, comparator);
Objects.equals(object1, object2);
Objects.deepEquals(object1, object2);
Objects.hash(object1, object2, object3, ...);

我在equals中使用Objects.equals进行覆盖，在hashCode方法中使用Objects.hash进行覆盖。它还会为您执行null检查，最后，代码看起来非常清晰易读。

例如：

...

@Override
public boolean equals(Object o) {
    if (this == o) {
        return true;
    }
    if (!(o instanceof Customer)) {
        return false;
    }
    Customer that = (Customer) o;
    return Objects.equals(firstName, that.firstName)
            && Objects.equals(lastName, that.lastName)
            && Objects.equals(street, that.street)
            && Objects.equals(houseNumber, that.houseNumber)
            && Objects.equals(postalCode, that.postalCode)
            && Objects.equals(city, that.city)
            && Objects.equals(emailAddress, that.emailAddress);
}

@Override
public int hashCode() {
    return Objects.hash(firstName,
            lastName,
            street,
            houseNumber,
            postalCode,
            city,
            emailAddress);
}

...

Java中的“ ===”等效

9 个答案: