java-基础类型和字符串

一、基础类型

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是只读字符串，String类被final修饰，无法被继承，并且存储数据的是一个final类型的字符数组，所引用的字符串不能被改变，一经定义，无法再增删改。每次对String的操作都会生成新的String对象。

public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
    private final char value[];
  //...
}

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

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

char[] value;

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

字符串拼接用“+” 还是 StringBuilder?

Java 语言本身并不支持运算符重载，“+”和“+=”是专门为 String 类重载过的运算符，也是 Java 中仅有的两个重载过的运算符。

字符串对象通过“+”的字符串拼接方式，实际上是通过 StringBuilder 调用 append() 方法实现的，拼接完成之后调用 toString() 得到一个 String 对象 。

不过，在循环内使用“+”进行字符串的拼接的话，存在比较明显的缺陷：编译器不会创建单个 StringBuilder 以复用，会导致创建过多的 StringBuilder 对象。

3、intern

String.intern() 是一个 native (本地) 方法，用来处理字符串常量池中的字符串对象引用。它的工作流程可以概括为以下两种情况：

1. 常量池中已有相同内容的字符串对象：如果字符串常量池中已经有一个与调用 intern() 方法的字符串内容相同的 String 对象，intern() 方法会直接返回常量池中该对象的引用。
2. 常量池中没有相同内容的字符串对象：如果字符串常量池中还没有一个与调用 intern() 方法的字符串内容相同的对象，intern() 方法会将当前字符串对象的引用添加到字符串常量池中，并返回该引用。

String s1 = new String("abc");这句话创建了几个字符串对象？

先说答案：会创建 1 或 2 个字符串对象。

1. 字符串常量池中不存在 “abc”：会创建 2 个 字符串对象。一个在字符串常量池中，由 ldc 指令触发创建。一个在堆中，由 new String() 创建，并使用常量池中的 “abc” 进行初始化。
2. 字符串常量池中已存在 “abc”：会创建 1 个 字符串对象。该对象在堆中，由 new String() 创建，并使用常量池中的 “abc” 进行初始化。

4、编译器字符串常量折叠

对于编译期可以确定值的字符串，也就是常量字符串 ，jvm 会将其存入字符串常量池。并且，字符串常量拼接得到的字符串常量在编译阶段就已经被存放字符串常量池，这个得益于编译器的优化。

在编译过程中，Javac 编译器（下文中统称为编译器）会进行一个叫做 常量折叠(Constant Folding) 的代码优化。

常量折叠会把常量表达式的值求出来作为常量嵌在最终生成的代码中，这是 Javac 编译器会对源代码做的极少量优化措施之一(代码优化几乎都在即时编译器中进行)。

对于 String str3 = "str" + "ing"; 编译器会给你优化成 String str3 = "string"; 。

并不是所有的常量都会进行折叠，只有编译器在程序编译期就可以确定值的常量才可以：

• 基本数据类型( byte、boolean、short、char、int、float、long、double)以及字符串常量。
• final 修饰的基本数据类型和字符串变量
• 字符串通过 “+”拼接得到的字符串、基本数据类型之间算数运算（加减乘除）、基本数据类型的位运算（<<、>>、>>> ）

被 final 关键字修饰之后的 String 会被编译器当做常量来处理，编译器在程序编译期就可以确定它的值，其效果就相当于访问常量。

如果 ，编译器在运行时才能知道其确切值的话，就无法对其优化。

// 常量池中的对象,编译器优化,编译期可确定值,故发生了字符串常量折叠
// 优化后实际执行代码: String c = "string";
String c = "str" + "ing";

final String str1 = "str";
final String str2 = "ing";
// 被 final 关键字修饰之后的 String 会被编译器当做常量来处理, 相当于上面c
String d = str1 + str2; // 常量池中的对象
System.out.println(c == d);// true

String str3 = "str";
String str4 = "ing";
// 未被 final 关键字修饰的 String 为变量,此时不会进行优化
String e = str3 + str4;//非常量池中的
System.out.println(c == e);// false

String f = e.intern();//手动进入字符串常量池
System.out.println(c == f);// true

三、对象

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 集合就不会存储两个一模一样的数据了