java-基础类型和字符串

面试
面试
发布日期:   2021-02-18

一、基础类型

1、各个基本类型占用大小

基本类型 大小（字节） 默认值 封装类
byte 1 (byte)0 Byte
short 2 (short)0 Short
int 4 0 Integer
long 8 0L Long
float 4 0.0f Float
double 8 0.0d Double
boolean - false Boolean
char 2 \u0000(null) Character

基本数据类型在声明时系统会自动给它分配空间，而引用类型声明时只是分配了引用空间，必须通过实例化开辟数据空间之后才可以赋值。数组对象也是一个引用对象，将一个数组赋值给另一个数组时只是复制了一个引用，所以通过某一个数组所做的修改在另一个数组中也看的见。

虽然定义了 boolean 这种数据类型，但是只对它提供了非常有限的支持。在Java虚拟机中没有任何供 boolean 值专用的字节码指令，Java语言表达式所操作的 boolean 值，在编译之后都使用Java虚拟机中的 int 数据类型来代替，而 boolean 数组将会被编码成 Java 虚拟机的 byte 数组，每个元素 boolean 元素占8位。这样我们可以得出 boolean 类型占了单独使用是4个字节，在数组中又是1个字节。使用 int 的原因是，对于当下32位的处理器（CPU）来说，一次处理数据是32位（这里不是指的是32/64位系统，而是指CPU硬件层面），具有高效存取的特点。

2、Integer缓存机制

Integer i1 = 100;
Integer i2 = 100;
Integer i3 = 200;
Integer i4 = 200;

System.out.println(i1==i2);        //true
System.out.println(i3==i4);        //false

为什么会出现这样的结果？输出结果表明i1和i2指向的是同一个对象，而i3和i4指向的是不同的对象。此时只需一看源码便知究竟，下面这段代码是 Integer 的 valueOf 方法的具体实现：

    public static Integer valueOf(int i) {
        // 当前值在缓存数组区间段，则直接返回该缓存值
        // 默认 IntegerCache.low = -127 ,IntegerCache.high = 128
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            // 缓存范围[], 从-127到128
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

其中 IntegerCache 类为 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() {}
}

该类的作用是将数值等于 -128-127 (默认)区间的 Integer 实例缓存到 cache 数组中。通过 valueOf() 方法很明显发现，当再次创建值在 -128-127 区间的 Integer 实例时，会复用缓存中的实例，也就是直接指向缓存中的 Integer 实例。注意，这里的创建不包括用 new 创建，new 创建对象不会复用缓存实例。

Integer 的默认缓存范围为-128到127，可以通过jvm参数改变这个范围。

  • 缓存上界high可以通过 jvm 参数 -XX:AutoBoxCacheMax=size 指定，取指定值与127的最大值并且不超过Integer表示范围，
  • 下界不能指定，只能为-128。

实际上，可以将Integer的缓存机制理解为享元模式

实际上不仅仅Integer具有缓存机制，Byte、Short、Long、Character都具有缓存机制。除了 Integer 可以通过jvm参数改变范围外，其它的都不行。

  • Byte，Short，Integer，Long为 -128 到 127

  • Character范围为 0 到 127

3、

二、字符串

1、为什么字符串JDK9底层改成字节数组

使用 byte[] 而不是 char[] 的原因是为了节约内存。因为绝大多数字符串只包含英文字母数字等字符，可使用 Latin-1 编码方案，一个字符占用一个byte。 如果这个时候使用 char[] ，一个char要占用两个byte，会占用双倍的内存空间。

新版的String其实支持两个编码： Latin-1和UTF-16，如果String的内容中有汉字等超出 Latin-1 表示范围的字符。这个时候会使用UTF-16编码，然后这个时候占用的空间和旧版（使用 char[]）是一样的。

private final byte[] value;

private final byte coder;

2、String、StringBuffer和StringBuilder

String是只读字符串，从底层源码来看是一个final类型的字符数组，所引用的字符串不能被改变，一经定义，无法再增删改。每次对String的操作都会生成新的String对象。

private final char value[];

每次+操作 ： 隐式在堆上new了一个跟原字符串相同的 StringBuilder 对象，再调用append方法 拼接+后面的字符。

StringBuffer 和 StringBuilder 他们两都继承了 AbstractStringBuilder 抽象类，从 AbstractStringBuilder 抽象类中我们可以看到

char[] value;

他们的底层都是可变的字符数组，所以在进行频繁的字符串操作时，建议使用 StringBuffer 和 StringBuilder 来进行操作。 另外 StringBuffer 对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder 并没有对方法进行加同步锁，所以是非线程安全的。

三、对象

1、equals、==、hashcode

==

==比较的是变量（栈）内存中存放的对象的(堆)内存地址，用来判断两个对象的地址是否相同，即是否是指相同一个对象。比较的是真正意义上的指针操作。

1、比较的是操作符两端的操作数是否是同一个对象。

2、两边的操作数必须是同一类型的（可以是父子类之间）才能编译通过。

3、比较的是地址，如果是具体的阿拉伯数字的比较，值相等则为true，如：

int a=10 与 long b=10L 与 double c=10.0都是相同的（为true），因为他们都指向地址为10的堆。

equals

Object 类中的 equals 方法用于检测一个对象是否等于另外一个对象。在 Object 类中，这个方法将判断两个对象是否具有相同的引用。如果两个对象具有相同的引用，它们一定是相等的。

equals 方法的实现源码如下：

public boolean equals(Object obj) {
    return (this == obj);
}

通过上述源码和 equals 的定义我们可以看出，在大多数情况来说，equals 的判断是没有什么意义的！例如，使用 Object 中的 equals 比较两个自定义的对象是否相等，这就完全没有意义（因为无论对象是否相等，结果都是 false）。

因此通常情况下，我们要判断两个对象是否相等，一定要重写 equals 方法，这就是为什么要重写 equals 方法的原因。

Hashcode

java的集合有两类，一类是List，还有一类是Set。前者有序可重复，后者无序不重复。当我们在set中插入的时候怎么判断是否已经存在该元素呢，可以通过equals方法。但是如果元素太多，用这样的方法就会比较满。

于是有人发明了哈希算法来提高集合中查找元素的效率。 这种方式将集合分成若干个存储区域，每个对象可以计算出一个哈希码，可以将哈希码分组，每组分别对应某个存储区域，根据一个对象的哈希码就可以确定该对象应该存储的那个区域。

hashCode方法可以这样理解：它返回的就是根据对象的内存地址换算出的一个值。这样一来，当集合要添加新的元素时，先调用这个元素的hashCode方法，就一下子能定位到它应该放置的物理位置上。

如果这个位置上没有元素，它就可以直接存储在这个位置上，不用再进行任何比较了；如果这个位置上已经有元素了，就调用它的equals方法与新元素进行比较，相同的话就不存了，不相同就散列其它的地址。这样一来实际调用equals方法的次数就大大降低了，几乎只需要一两次。

2、重写 equals 时为什么要重写 hashCode

hashCode 和 equals 两个方法是用来协同判断两个对象是否相等的，采用这种方式的原因是可以提高程序插入和查询的速度，如果在重写 equals 时，不重写 hashCode，就会导致在将对象存储到 HashMap 的 key 或 HashSet 等容器时，重复存储

  • 相等的值 hashCode 一定相同
  • 不同的值 hashCode 也有可能相同

如果只重写了 equals 方法，那么默认情况下，Set 进行去重操作时，会先判断两个对象的 hashCode 是否相同，此时因为没有重写 hashCode 方法，所以会直接执行 Object 中的 hashCode 方法，而 Object 中的 hashCode 方法对比的是两个不同引用地址的对象，所以结果是 false，那么 equals 方法就不用执行了，直接返回的结果就是 false：两个对象不是相等的，于是就在 Set 集合中插入了两个相同的对象。

但是，如果在重写 equals 方法时，也重写了 hashCode 方法，那么在执行判断时会去执行重写的 hashCode 方法，此时对比的是两个对象的所有属性的 hashCode 是否相同，于是调用 hashCode 返回的结果就是 true，再去调用 equals 方法，发现两个对象确实是相等的，于是就返回 true 了，因此 Set 集合就不会存储两个一模一样的数据了

面试
  目录