Kotlin是否有基础类型_represents a 32-bit signed integer. on the jvm, no-CSDN博客

本文链接：https://blog.csdn.net/qq_36670483/article/details/123347848

Kotlin是否有基础类型

源码解析
示例演示
总结

源码解析

下面用Int举例，先看kotlin中的Int源码（基于kotlin1.5.20）

/**
 * Represents a 32-bit signed integer.
 * On the JVM, non-nullable values of this type are represented as values of the primitive type `int`.
 */
public class Int private constructor() : Number(), Comparable<Int> {
	//省略内部代码
}

Represents a 32-bit signed integer. On the JVM, non-nullable values of
this type are represented as values of the primitive type int.

表示32位有符号整数。
在JVM上，这种类型的不可为null的值表示为原语类型“int”的值。

也就说明在我们定义Int类型的值后他其实是基础数据类型

示例演示

实际演示，示例1：

fun main(){
	var a:Int = 200
	var b:Int = 200
	println("a == b ${a == b}")
	println("a === b ${a === b}")
}

输出如下：

a == b true
a === b true

可以看到无论是值还是地址都是一样的

那怎么让他成为封装类型？，前面源码注释也说了不可为null的时候是基础类型，那我们定义的时候只要让参数可以为null即可

实际演示，示例2：

fun main() {
    var a:Int? = 200
	var b:Int? = 200
	println("a == b ${a == b}")
	println("a === b ${a === b}")
}

输出如下：

a == b true
a === b false

从这里可以看到我们将变量设为可为null后，他们的地址就不一样了
但是我们继续往下看
实际演示，示例3：

fun main() {
    var a:Int? = 200
	var b:Int? = 200
	println("a == b ${a == b}")
	println("a === b ${a === b}")
    a = 127
    b = 127
    println("a === b ${a === b}")
}

输出如下：

a == b true
a === b false
a === b true

怎么赋值127后地址就一样了呢

我们将示例1中的代码转Java看看

public final class Test {
   //省略
   @JvmStatic
   public static final void main(@NotNull String[] args) {
      Intrinsics.checkNotNullParameter(args, "args");
      int a = true;
      int b = true;
      String var3 = "a == b " + true;
      boolean var4 = false;
      System.out.println(var3);
      var3 = "a === b " + true;
      var4 = false;
      System.out.println(var3);
   }
   //省略
}

可以看到a和b都是int基础类型

再看看示例2

public final class Test {
   //省略
   @JvmStatic
   public static final void main(@NotNull String[] args) {
      Intrinsics.checkNotNullParameter(args, "args");
      Integer a = 200;
      Integer b = 200;
      String var3 = "a == b " + Intrinsics.areEqual(a, b);
      boolean var4 = false;
      System.out.println(var3);
      var3 = "a === b " + (a == b);
      var4 = false;
      System.out.println(var3);
   }

   //省略
}

可以看到a和b都是Integer封装类型了，看到这其实也就解决了我们的标题问题，kotlin是有基础数据类型的

那我们接着看示例3，为什么定义成127后他们的值就相等了呢，这里其实我们是要去看Java中的Integer源码的

//省略
	private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];

        static {
            // high value may be configured by property
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                try {
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            high = h;

            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);

            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }

        private IntegerCache() {}
    }
//省略