广安网络公司

val a: Int = 100println(a === a) // true，值相等，对象地址相等//经过了装箱，创建了两个不同的对象val boxedA: Int? = a
val anotherBoxedA: Int? = a//虽然经过了装箱，但是值是相等的，都是100println(boxedA === anotherBoxedA) //  true，值相等，128 之前对象地址一样println(boxedA == anotherBoxedA) // true，值相等

这里我把 a 的值换成 100，这里应该跟 Java 中是一样的，在范围是 [-128, 127] 之间并不会创建新的对象，比较输出的都是 true，从 128 开始，比较的结果才为 false。

val a = 10000//不显示声明类型不会封装新对象val boxedA = a
val anotherBoxedA = a
println(boxedA === anotherBoxedA) //  true

RomanLuo 这个说法有误导性：

val num: Int = 10000val num1: Int = num
val num2: Int = num
println(num1 === num2)  //true

这里判断为地址相同不是因为有没有显示声明类型，而是类型都相同，都是数值类型，没有进行装箱操作。而案例中的类型是 Int? 可空类型，类型不同所以必须装箱，导致产生一个新对象。

@刘义 的说法是对的，但不完整；@RomanLuo 的说法也对，但也只在 [-128, 127] 范围之外有效。

下面给一个完整的用例，包含了所有情况，供大家参考。

注意其中 Int 和 Int? ，127 和 128 之间的区别。

// Int? Int? Int?val a1: Int? = 128var boxedA: Int? = a1var boxedB: Int? = a1
log(" boxedA === boxedB ? " + (boxedA === boxedB))//truelog(" boxedA == boxedB ? " + (boxedA == boxedB))//true// Int Int? Int?val a2: Int = 128boxedA = a2
boxedB = a2
log(" boxedA === boxedB ? " + (boxedA === boxedB))//false//值相等log(" boxedA == boxedB ? " + (boxedA == boxedB))//true// Int? Int? Int?val a3: Int? = 127boxedA = a3
boxedB = a3
log(" boxedA === boxedB ? " + (boxedA === boxedB))//true//值相等log(" boxedA == boxedB ? " + (boxedA == boxedB))//true// Int Int? Int?val a4: Int = 127boxedA = a4
boxedB = a4
log(" boxedA === boxedB ? " + (boxedA === boxedB))//true//值相等log(" boxedA == boxedB ? " + (boxedA == boxedB))//true// Int Int Intval a5: Int = 128val boxedA2: Int = a5
val boxedB2: Int = a5

log(" boxedA === boxedB ? " + (boxedA2 === boxedB2))//true//值相等log(" boxedA == boxedB ? " + (boxedA2 == boxedB2))//true

综上各位仁兄的理解，小弟发挥了一下想象力，假设有一堆货物（初始值）如果货物比较少（在[-128, 127] 之间。java里面就是自动装箱，可以理解为货物本身自带包装盒）那么把这些东西无论给甲还是给乙都不需要额外的箱子来装。所以甲乙手上的货物是一致的，二者相等。如果货物比较多（[-128, 127]之外，多余一个包装盒。或者只多出一点，一个包装盒+一点散货）手拿不住了，需要拿箱子装了（装箱操作）那么甲需要一个箱子，乙需要一个箱子，手上的两个箱子是不同的（地址不同了）但是里面的货物还是一样的（值相等）