Java中100==100为true,而1000==1000为false?

2024-01-03 13:27:38

前言

今天跟大家聊一个有趣的话题,在Java中两个Integer对象做比较时,会产生意想不到的结果。

例如:

Integer?a?=?100;
Integer?b?=?100;
System.out.println(a==b);

其运行结果是:true。

而如果改成下面这样:

Integer?a?=?1000;
Integer?b?=?1000;
System.out.println(a==b);

其运行结果是:false。

看到这里,懵了没有?

为什么会产生这样的结果呢?

1 Integer对象

上面例子中的a和b,是两个Integer对象。

而非Java中的8种基本类型。

8种基本类型包括:

  • byte

  • short

  • int

  • long

  • float

  • double

  • boolean

  • char

Integer其实是int的包装类型。

在Java中,除了上面的这8种类型,其他的类型都是对象,保存的是引用,而非数据本身。

Integer?a?=?1000;
Integer?b?=?1000;

可能有些人认为是下面的简写:

Integer?a?=?new?Integer(1000);
Integer?b?=?new?Integer(1000);

这个想法表面上看起来是对的,但实际上有问题。

在JVM中的内存分布情况是下面这样的:

图片

在栈中创建了两个局部变量a和b,同时在堆上new了两块内存区域,他们存放的值都是1000。

变量a的引用指向第一个1000的地址。

而变量b的引用指向第二个1000的地址。

很显然变量a和b的引用不相等。

既然两个Integer对象用==号,比较的是引用是否相等,但下面的这个例子为什么又会返回true呢?

Integer?a?=?100;
Integer?b?=?100;
System.out.println(a==b);

不应该也返回false吗?

对象a和b的引用不一样。

Integer?a?=?1000;
Integer?b?=?1000;

其实正确的简写是下面这样的:

Integer?a?=?Integer.valueOf(1000);
Integer?b?=?Integer.valueOf(1000);

在定义对象a和b时,Java自动调用了Integer.valueOf将数字封装成对象。

图片

而如果数字在low和high之间的话,是直接从IntegerCache缓存中获取的数据。

图片

Integer类的内部,将-128~127之间的数字缓存起来了。

也就是说,如果数字在-128~127,是直接从缓存中获取的Integer对象。如果数字超过了这个范围,则是new出来的新对象。

文章示例中的1000,超出了-128~127的范围,所以对象a和b的引用指向了两个不同的地址。

而示例中的100,在-128~127的范围内,对象a和b的引用指向了同一个地址。

所以会产生文章开头的运行结果。

为什么Integer类会加这个缓存呢?

答:-128~127是使用最频繁的数字,如果不做缓存,会在内存中产生大量指向相同数据的对象,有点浪费内存空间。

Integer?a?=?1000;
Integer?b?=?1000;

如果想要上面的对象a和b相等,我们该怎么判断呢?

当用户打开指定页面时,在缓存中每次都设置成count = count+1即可。

用户第一次访问页面时,redis中的count值设置成1。用户以后每访问一次页面,都让count加1,最后重新设置到redis中。

图片

这样在需要展示数量的地方,从redis中查出count值返回即可。

该场景无需从数据埋点表中使用count(*)实时统计数据,性能将会得到极大的提升。

不过在高并发的情况下,可能会存在缓存和数据库的数据不一致的问题。

但对于统计浏览总次数或者浏览总人数这种业务场景,对数据的准确性要求并不高,容忍数据不一致的情况存在。

2.2 加二级缓存

对于有些业务场景,新增数据很少,大部分是统计数量操作,而且查询条件很多。这时候使用传统的count(*)实时统计数据,性能肯定不会好。

假如在页面中可以通过id、name、状态、时间、来源等,一个或多个条件,统计品牌数量。

这种情况下用户的组合条件比较多,增加联合索引也没用,用户可以选择其中一个或者多个查询条件,有时候联合索引也会失效,只能尽量满足用户使用频率最高的条件增加索引。

也就是有些组合条件可以走索引,有些组合条件没法走索引,这些没法走索引的场景,该如何优化呢?

答:使用二级缓存

二级缓存其实就是内存缓存。

我们可以使用caffine或者guava实现二级缓存的功能。

目前SpringBoot已经集成了caffine,使用起来非常方便。

只需在需要增加二级缓存的查询方法中,使用@Cacheable注解即可。

?@Cacheable(value?=?"brand",?,?keyGenerator?=?"cacheKeyGenerator")
???public?BrandModel?getBrand(Condition?condition)?{
???????return?getBrandByCondition(condition);
???}

然后自定义cacheKeyGenerator,用于指定缓存的key。

public?class?CacheKeyGenerator?implements?KeyGenerator?{
????@Override
????public?Object?generate(Object?target,?Method?method,?Object...?params)?{
????????return?target.getClass().getSimpleName()?+?UNDERLINE
????????????????+?method.getName()?+?","
????????????????+?StringUtils.arrayToDelimitedString(params,?",");
????}
}

这个key是由各个条件组合而成。

这样通过某个条件组合查询出品牌的数据之后,会把结果缓存到内存中,设置过期时间为5分钟。

后面用户在5分钟内,使用相同的条件,重新查询数据时,可以直接从二级缓存中查出数据,直接返回了。

这样能够极大的提示count(*)的查询效率。

但是如果使用二级缓存,可能存在不同的服务器上,数据不一样的情况。我们需要根据实际业务场景来选择,没法适用于所有业务场景。

2.3 多线程执行

不知道你有没有做过这样的需求:统计有效订单有多少,无效订单有多少。

这种情况一般需要写两条sql,统计有效订单的sql如下:

select?count(*)?from?order?where?status=1;

统计无效订单的sql如下:

select?count(*)?from?order?where?status=0;

但如果在一个接口中,同步执行这两条sql效率会非常低。

这时候,可以改成成一条sql:

select?count(*),status?from?order
group?by?status;

使用group by关键字分组统计相同status的数量,只会产生两条记录,一条记录是有效订单数量,另外一条记录是无效订单数量。

但有个问题:status字段只有1和0两个值,重复度很高,区分度非常低,不能走索引,会全表扫描,效率也不高。

还有其他的解决方案不?

答:使用多线程处理。

我们可以使用CompleteFuture使用两个线程异步调用统计有效订单的sql和统计无效订单的sql,最后汇总数据,这样能够提升查询接口的性能。

最近我建了新的技术交流群,打算将它打造成高质量的活跃群,欢迎小伙伴们加入。

我以往的技术群里技术氛围非常不错,大佬很多。

image.png

加微信:su_san_java,备注:加群,即可加入该群。

2 判断相等

在Java中,如果使用==号比较两个对象是否相等,比如:a==b,其实比较的是两个对象的引用是否相等。

很显然变量a和b的引用,指向的是两个不同的地址,引用肯定是不相等的。

因此下面的执行结果是:false。

Integer?a?=??Integer.valueOf(1000);
Integer?b?=?Integer.valueOf(1000);
System.out.println(a==b);

由于1000在Integer缓存的范围之外,因此上面的代码最终会变成这样:

Integer?a?=??new?Integer(1000);
Integer?b?=?new?Integer(1000);
System.out.println(a==b);

如果想要a和b比较时返回true,该怎么办呢?

答:调用equals方法。

当用户打开指定页面时,在缓存中每次都设置成count = count+1即可。

用户第一次访问页面时,redis中的count值设置成1。用户以后每访问一次页面,都让count加1,最后重新设置到redis中。

图片

这样在需要展示数量的地方,从redis中查出count值返回即可。

该场景无需从数据埋点表中使用count(*)实时统计数据,性能将会得到极大的提升。

不过在高并发的情况下,可能会存在缓存和数据库的数据不一致的问题。

但对于统计浏览总次数或者浏览总人数这种业务场景,对数据的准确性要求并不高,容忍数据不一致的情况存在。

2.2 加二级缓存

对于有些业务场景,新增数据很少,大部分是统计数量操作,而且查询条件很多。这时候使用传统的count(*)实时统计数据,性能肯定不会好。

假如在页面中可以通过id、name、状态、时间、来源等,一个或多个条件,统计品牌数量。

这种情况下用户的组合条件比较多,增加联合索引也没用,用户可以选择其中一个或者多个查询条件,有时候联合索引也会失效,只能尽量满足用户使用频率最高的条件增加索引。

也就是有些组合条件可以走索引,有些组合条件没法走索引,这些没法走索引的场景,该如何优化呢?

答:使用二级缓存

二级缓存其实就是内存缓存。

我们可以使用caffine或者guava实现二级缓存的功能。

目前SpringBoot已经集成了caffine,使用起来非常方便。

只需在需要增加二级缓存的查询方法中,使用@Cacheable注解即可。

?@Cacheable(value?=?"brand",?,?keyGenerator?=?"cacheKeyGenerator")
???public?BrandModel?getBrand(Condition?condition)?{
???????return?getBrandByCondition(condition);
???}

然后自定义cacheKeyGenerator,用于指定缓存的key。

public?class?CacheKeyGenerator?implements?KeyGenerator?{
????@Override
????public?Object?generate(Object?target,?Method?method,?Object...?params)?{
????????return?target.getClass().getSimpleName()?+?UNDERLINE
????????????????+?method.getName()?+?","
????????????????+?StringUtils.arrayToDelimitedString(params,?",");
????}
}

这个key是由各个条件组合而成。

这样通过某个条件组合查询出品牌的数据之后,会把结果缓存到内存中,设置过期时间为5分钟。

后面用户在5分钟内,使用相同的条件,重新查询数据时,可以直接从二级缓存中查出数据,直接返回了。

这样能够极大的提示count(*)的查询效率。

但是如果使用二级缓存,可能存在不同的服务器上,数据不一样的情况。我们需要根据实际业务场景来选择,没法适用于所有业务场景。

2.3 多线程执行

不知道你有没有做过这样的需求:统计有效订单有多少,无效订单有多少。

这种情况一般需要写两条sql,统计有效订单的sql如下:

select?count(*)?from?order?where?status=1;

统计无效订单的sql如下:

select?count(*)?from?order?where?status=0;

但如果在一个接口中,同步执行这两条sql效率会非常低。

这时候,可以改成成一条sql:

select?count(*),status?from?order
group?by?status;

使用group by关键字分组统计相同status的数量,只会产生两条记录,一条记录是有效订单数量,另外一条记录是无效订单数量。

但有个问题:status字段只有1和0两个值,重复度很高,区分度非常低,不能走索引,会全表扫描,效率也不高。

还有其他的解决方案不?

答:使用多线程处理。

我们可以使用CompleteFuture使用两个线程异步调用统计有效订单的sql和统计无效订单的sql,最后汇总数据,这样能够提升查询接口的性能。

最近我建了新的技术交流群,打算将它打造成高质量的活跃群,欢迎小伙伴们加入。

我以往的技术群里技术氛围非常不错,大佬很多。

image.png

加微信:su_san_java,备注:加群,即可加入该群。

代码改成这样的:

Integer?a?=?Integer.valueOf(1000);
Integer?b?=?Integer.valueOf(1000);
System.out.println(a.equals(b));

执行结果是:true。

其实equals方法是Object类的方法,所有对象都有这个方法。

图片

它的底层也是用的==号判断两个Object类型的对象是否相等。

不过Integer类对该方法进行了重写:

图片

它的底层会先调用Integer类的intValue方法获取int类型的数据,然后再通过==号进行比较。

此时,比较的不是两个对象的引用是否相等,而且比较的具体的数据是否相等。

我们使用equals方法,可以判断两个Integer对象的值是否相等,而不是判断引用是否相等。

总结

Integer类中有缓存,范围是:-128~127

Integer?a?=?1000;

其实默认调用了Integer.valueOf方法,将数字转换成Integer类型:

Integer?a?=?Integer.valueOf(1000);

如果数字在-128~127之间,则直接从缓存中获取Integer对象。

如果数字在-128~127之外,则该方法会new一个新的Integer对象。

我们在判断两个对象是否相等时,一定要多注意:

  1. 判断两个对象的引用是否相等,用==号判断。

  2. 判断两个对象的值是否相等,调用equals方法判断。

最后说一句(求关注,别白嫖我)

如果这篇文章对您有所帮助,或者有所启发的话,帮忙扫描下发二维码关注一下,您的支持是我坚持写作最大的动力。

求一键三连:点赞、转发、在看。

关注公众号:【苏三说技术】,在公众号中回复:面试、代码神器、开发手册、时间管理有超赞的粉丝福利,另外回复:加群,可以跟很多BAT大厂的前辈交流和学习。

文章来源:https://blog.csdn.net/lisu061714112/article/details/135356794
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。