Java中的“ ===”等效

时间:2019-06-20 11:40:52

标签: java operators

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

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

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

9 个答案:

答案 0 :(得分:40)

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代码示例中,如果要在xy之间进行比较,可以使用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方法不能在原始类型上调用。

一些有用的读物​​是:

答案 1 :(得分:5)

我制作了一个函数,该函数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()与此答案中先前所述的功能相同

希望这对您有用。 :)

答案 2 :(得分:3)

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

答案 3 :(得分:3)

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

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

答案 4 :(得分:3)

在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

答案 5 :(得分:2)

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

答案 6 :(得分:2)

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

if(firstreference==secondreference) 
  1. 如果以上条件1不满足,则应通过instanceof运算符检查其类型:
if (secondreference instanctof classoffirstreference)
  1. 如果上述条件2满足,则应通过equals运算符(例如)检查属性比较。
firstreference.property1.equals(secondreference.property1)
//do this for all properties.

答案 7 :(得分:1)

如果我们在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中,由于类型不同,这会给您带来编译错误。

答案 8 :(得分:1)

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

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);
}

...