blocks|key|1604049|text|不，这通常是不安全的。==运算符比较引用，而不是值。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1604050|使用==恰好适用于-128和127之间的整数，但不适用于其他整数。下面的代码演示了==并不总是有效的：|1604051|Integer+a+=+Integer.valueOf(10);+
Integer+b+=+Integer.valueOf(10);+
System.out.println(a+==+b);

true

Integer+c+=+Integer.valueOf(1000);+
Integer+d+=+Integer.valueOf(1000);+
System.out.println(c+==+d);

false|code-block|syntax|javascript|1604052|在线查看它的工作方式：ideone|1604053|对此行为的解释在于Integer.valueOf的实现|1604054|public+static+Integer+valueOf(int+i)+{
+++++final+int+offset+=+128;
+++++if+(i+>=+-128+&&+i+<=+127)+{+//+must+cache
+++++++++return+IntegerCache.cache[i+%2B+offset];
+++++}
+++++return+new+Integer(i);
+}|1604055|source|1604056|此外，标准还要求对小输入(-128到127)的整数进行装箱，以提供具有相等引用的对象。|1604057|1604058|+5.1.7装箱转换|blockquote|BOLD|1604059|1604060|如果要装箱的值p是true、false、字节、\u0000到\u007f范围内的字符，或者是-128和127之间的整数或短数，则r1和r2是p的任意两个装箱转换的结果。r1+==+r2总是这样。|1604061|1604062|但是，该标准对超出此范围的整数没有这样的保证。|1604063|1604064|一般来说，是否可以通过使用==而不是|1604065|来比较不可变类的两个引用，这两个引用是通过调用相同的静态工厂方法创建的？|1604066|1604067|1604068|如上所示，它通常不会工作。但是，如果您确保两个具有相同值的不可变对象始终具有相同的引用，那么是的，它可以工作。然而，有一些规则你必须仔细遵守：|1604069|当系统要求您创建对象时，必须先检查缓存，看是否已经创建了具有相同值的对象。|1604070|entityMap|0|LINK|mutability|MUTABLE|url|http://ideone.com/rvcT1|1|http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/lang/Integer.java#Integer.valueOf%2528int%2529^0|B|2|0|2|2|15|2|0|0|B|6|0|0|9|F|0|0|0|6|1|0|0|0|1|9|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1S|8|@$9|1T|A|1U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1V|8|@$9|1W|A|1X|B|C]|$9|1Y|A|1Z|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|20|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|21|8|@]|D|@$9|22|A|23|1|24]]|E|$]]|$1|O|3|P|5|6|7|25|8|@$9|26|A|27|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|J|7|28|8|@]|D|@]|E|$K|L]]|$1|S|3|T|5|6|7|29|8|@]|D|@$9|2A|A|2B|1|2C]]|E|$]]|$1|U|3|V|5|6|7|2D|8|@]|D|@]|E|$]]|$1|W|3|-4|5|6|7|2E|8|@]|D|@]|E|$]]|$1|X|3|Y|5|Z|7|2F|8|@$9|2G|A|2H|B|10]]|D|@]|E|$]]|$1|11|3|-4|5|6|7|2I|8|@]|D|@]|E|$]]|$1|12|3|13|5|6|7|2J|8|@]|D|@]|E|$]]|$1|14|3|-4|5|6|7|2K|8|@]|D|@]|E|$]]|$1|15|3|16|5|6|7|2L|8|@]|D|@]|E|$]]|$1|17|3|-4|5|6|7|2M|8|@]|D|@]|E|$]]|$1|18|3|19|5|6|7|2N|8|@]|D|@]|E|$]]|$1|1A|3|1B|5|Z|7|2O|8|@]|D|@]|E|$]]|$1|1C|3|-4|5|6|7|2P|8|@]|D|@]|E|$]]|$1|1D|3|-4|5|6|7|2Q|8|@]|D|@]|E|$]]|$1|1E|3|1F|5|6|7|2R|8|@]|D|@]|E|$]]|$1|1G|3|1H|5|6|7|2S|8|@]|D|@]|E|$]]|$1|1I|3|-4|5|6|7|2T|8|@]|D|@]|E|$]]]|1J|$1K|$5|1L|1M|1N|E|$1O|1P]]|1Q|$5|1L|1M|1N|E|$1O|1R]]]]

No, that's not safe in general. The <code>==</code> operator compares the references, not the values.
Using <code>==</code> happens to work for integers between -128 and 127, but not for other integers. The following code demonstrates that <code>==</code> won't always work:
<pre><code>Integer a = Integer.valueOf(10); 
Integer b = Integer.valueOf(10); 
System.out.println(a == b);

true

Integer c = Integer.valueOf(1000); 
Integer d = Integer.valueOf(1000); 
System.out.println(c == d);

false
</code></pre>
See it working online: <a href="http://ideone.com/rvcT1" rel="nofollow noreferrer">ideone</a>
The explanation for this behaviour lies in the implementation of <code>Integer.valueOf</code>:
<pre><code>public static Integer valueOf(int i) {
 final int offset = 128;
 if (i &gt;= -128 &amp;&amp; i &lt;= 127) { // must cache
 return IntegerCache.cache[i + offset];
 }
 return new Integer(i);
 }
</code></pre>
<a href="http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/lang/Integer.java#Integer.valueOf%28int%29" rel="nofollow noreferrer">source</a>
Not also that the standard requires that boxing integers for small inputs (-128 to 127) gives objects with equal references.
<blockquote>
5.1.7 Boxing Conversion
If the value p being boxed is true, false, a byte, a char in the range \u0000 to \u007f, or an int or short number between -128 and 127, then let r1 and r2 be the results of any two boxing conversions of p. It is always the case that r1 == r2.
</blockquote>
However the standard makes no such guarantees for integers outside this range.
<hr />
<blockquote>
In general, is it ok to compare two references of an immutable class that are created using a call to the same static factory method by using == instead of equals?
</blockquote>
As shown above, it won't work in general. But if you ensure that two immutable objects with the same value always have the same reference, then yes, it could work. However there are some rules you must follow carefully:
<ul>
<li>The constructor must not be public.</li>
<li>Every object you create via the static method must be cached.</li>
<li>Every time you are asked to create an object you must first check the cache to see if you have already created an object with the same value.</li>
</ul>

blocks|key|2826493|text|==和equals()在本质上是不同的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2826494|你应该阅读这篇文章以获得更多详细信息：|2826495|Difference+between+Equals/equals+and+==+operator?|offset|length|2826496|它与不可变对象无关。|2826497|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/971954/difference-between-equals-and^0|0|0|0|1D|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@$F|U|G|V|1|W]]|A|$]]|$1|H|3|I|5|6|7|X|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q]]]]

== and equals() is fundamentally different.

You should read this post for more details:

<a href="https://stackoverflow.com/questions/971954/difference-between-equals-and">Difference between Equals/equals and == operator?</a>

It has nothing to do with immutable objects.

blocks|key|1102004|text|它们不是同一个对象，所以==不会是真的。对于对象，请注意安全并使用equals()。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1102005|entityMap^0|C|2|X|8|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

They are not the same object, so <code>==</code> will not be true. With objects, be safe and use <code>equals()</code>.

blocks|key|2826555|text|如果您的工厂方法为相等的输入返回相同的对象，则可以安全地将它们与==进行比较。例如，String.intern是这样工作的。枚举也可以与==进行比较。但是Integer.valueOf只在-128+...+127范围内返回相同的对象(在默认配置中)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2826556|Integer.valueOf(127)+==+Integer.valueOf(127)|code-block|syntax|javascript|2826557|但|2826558|Integer.valueOf(128)+!=+Integer.valueOf(128)|2826559|一般来说，你应该使用equals方法来比较任何对象。当对象有少量不同的值时，可以使用运算符==来提高性能。我不推荐使用这种方法，除非你100%25确定你在做什么。|2826560|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

If your factory method returns the same object for equal inputs, it's safe to compare them with ==. For example String.intern works this way. Enums are also could be compared with ==. But Integer.valueOf returns the same object only for -128 ... 127 range (in default configuration).

<pre><code>Integer.valueOf(127) == Integer.valueOf(127)
</code></pre>

but

<pre><code>Integer.valueOf(128) != Integer.valueOf(128)
</code></pre>

Generally speaking you should use equals method to compare any objects. Operator == could be used to improve performance, when there are small number of different values for object. I wouldn't recommend to use this method, unless you are 100% sure in what you are doing.

Consider two references of type Integer that call the static factory method valueOf as shown below:- 

<pre><code> Integer a = Integer.valueOf("10"); 
 Integer b = Integer.valueOf("10"); 
</code></pre>

Considering that Integer is immutable, is it ok to compare a and b using == instead of using equals method. I am guessing that the valueOf method makes sure that only one instance of Integer with the value 10 is created and a reference to this instance is returned for every Integer created with a value 10. 

In general, is it ok to compare two references of an immutable class that are created using a call to the same static factory method by using == instead of equals? 

Edit: 
The Integer class was used just as an example. I am aware thar Intgers upto 127 will return true if they are compared using ==. What i need to know is that when l create my own immutable class, say MyImmutable with a method create() that will ensure that no duplicate MyImmutable objects are created, will it be ok if I compare 2 MyImmutable references created using the create method by using == instead of equals.

Is it ok to compare immutable objects in Java using == instead of equals

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

考虑两个Integer类型的引用，它们调用静态工厂方法valueOf，如下所示：    Integer a = Integer.valueOf("10");     Integer b = Integer.valueOf("10"); 考虑到整数是不可变的，是否可以使用==而不是使用equals方法来比较a和b。我猜测...

问在Java中使用==而不是equals来比较不可变对象可以吗
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中使用==而不是equals来比较不可变对象可以吗EN