Java中100==100为true，而1000==1000为false？

╰+哭是因爲堅強的太久メ 2024-02-05 21:28 13阅读 0赞

### 前言 ###

今天跟大家聊一个有趣的话题，在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中的内存分布情况是下面这样的：

![图片][5ad6b5636572c369aa6d4742fd3dea94.png]

在栈中创建了两个局部变量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`将数字封装成对象。

![图片][fcc394d3b3d3559c23fccb4c1b7499a8.png]

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

![图片][b3497414659668217b863dcafdd9273a.png]

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中。

![图片][dd23cc99ad99801374f5632b8f9e2091.png]

这样在需要展示数量的地方，从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中。

![图片][dd23cc99ad99801374f5632b8f9e2091.png]

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

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

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

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

#### 2.2 加二级缓存 ####

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

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

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

答：使用`二级缓存`。

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

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

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

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

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

这个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类的方法，所有对象都有这个方法。

![图片][d0edb026522dd6ed2f3a8532a014f133.png]

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

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

![图片][69c874a010b54eb61c6a51ffd87307a0.png]

它的底层会先调用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大厂的前辈交流和学习。

[5ad6b5636572c369aa6d4742fd3dea94.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/924a370bc1f94674a7fac9c333a89541.png
[fcc394d3b3d3559c23fccb4c1b7499a8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/d0941cbda07e4dfea3c7a90d2cfe32ab.png
[b3497414659668217b863dcafdd9273a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/e9e3c592db5c4056b3e7d330719e189b.png
[dd23cc99ad99801374f5632b8f9e2091.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/af3c549a48bf45ff9daa2231dde18747.png
[image.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/68e047d15d8b4b6b8a70149b218ffb91.png
[d0edb026522dd6ed2f3a8532a014f133.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/48ccfe646381473aa1a0a37e96790ea4.png
[69c874a010b54eb61c6a51ffd87307a0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/b8964c995e244690bf630d334c1b26eb.png