## 1. Java的基本数据类型和引用类型,自动装箱和拆箱 - 4 类 8 种基本数据类型。4 整数型,2 浮点型,1 布尔型,1 字符型 | 类型 | 存储 | 取值范围 | 默认值 | 包装类 | | ---------- | ---- | ------------------------------------------------------------ | --------------- | --------- | | **整数型** | | | | | | byte | 8 | 最大存储数据量是 255,最小 -2<sup>7</sup>,最大 2<sup>7</sup>-1,<br />[-128~127] | (byte) 0 | Byte | | short | 16 | 最大数据存储量是 65536,[-2<sup>15</sup>,2<sup>15</sup>-1],<br />[-32768,32767],±3万 | (short) 0 | Short | | int | 32 | 最大数据存储容量是 2<sup>31</sup>-1,<br />[-2<sup>31</sup>,2<sup>31</sup>-1],±21亿,[ -2147483648, 2147483647] | 0 | Integer | | long | 64 | 最大数据存储容量是 2<sup>64</sup>-1,<br />[-2<sup>63</sup>,2<sup>63</sup>-1], ±922亿亿(±(922+16个零)) | 0L | Long | | **浮点型** | | | | | | float | 32 | 数据范围在 3.4e-45~1.4e38,直接赋值时必须在数字后加上 f 或 F | 0.0f | Float | | double | 64 | 数据范围在 4.9e-324~1.8e308,赋值时可以加 d 或 D 也可以不加 | 0.0d | Double | | **布尔型** | | | | | | boolean | 1 | true / flase | false | Boolean | | **字符型** | | | | | | char | 16 | 存储 Unicode 码,用单引号赋值 | '\u0000' (null) | Character | - 引用数据类型 - 类(class)、接口(interface)、数组 - 自动装箱和拆箱 - 基本数据类型和它对应的封装类型之间可以相互转换。自动拆装箱是 `jdk5.0` 提供的新特特性,它可以自动实现类型的转换 - **装箱**:从**基本数据类型**到**封装类型**叫做装箱 - **拆箱**:从**封装类型**到**基本数据类型**叫拆箱 ```java // jdk 1.5 public class TestDemo { public static void main(String[] args) { Integer m =10; int i = m; } } ```   上面的代码在 jdk1.4 以后的版本都不会报错,它实现了自动拆装箱的功能,如果是 jdk1.4,就得这样写了 ```java // jdk 1.4 public class TestDemo { public static void main(String[] args) { Integer b = new Integer(210); int c = b.intValue(); } } ``` ## 2. ValueOf缓存池   new Integer(123) 与 Integer.valueOf(123) 的区别在于,new Integer(123) 每次都会新建一个对象,而 Integer.valueOf(123) 可能会使用缓存对象,因此多次使用 Integer.valueOf(123) 会取得同一个对象的引用。 ```java Integer x = new Integer(123); Integer y = new Integer(123); System.out.println(x == y); // false Integer z = Integer.valueOf(123); Integer k = Integer.valueOf(123); System.out.println(z == k); // true ```   编译器会在自动装箱过程调用 valueOf() 方法,因此多个 Integer 实例使用自动装箱来创建并且值相同,那么就会引用相同的对象。 ```java Integer m = 123; Integer n = 123; System.out.println(m == n); // true ``` valueOf() 方法的实现比较简单,就是先判断值是否在缓存池中,如果在的话就直接使用缓存池的内容。 ```java // valueOf 源码实现 public static Integer valueOf(int i) { if (i >= IntegerCache.low && i <= IntegerCache.high) return IntegerCache.cache[i + (-IntegerCache.low)]; return new Integer(i); } ``` 在 Java 8 中,Integer 缓存池的大小默认为 -128\~127。 ```java 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; } ``` Java 还将一些其它基本类型的值放在缓冲池中,包含以下这些: - boolean values true and false - all byte values - short values between -128 and 127 - int values between -128 and 127 - char in the range \u0000 to \u007F 因此在使用这些基本类型对应的包装类型时,就可以直接使用缓冲池中的对象。 参考资料: - [StackOverflow : Differences between new Integer(123), Integer.valueOf(123) and just 123](https://stackoverflow.com/questions/9030817/differences-between-new-integer123-integer-valueof123-and-just-123) ## 3. i++和++i有什么区别 ### i++ i++ 是在程序执行完毕后进行自增,而 ++i 是在程序开始执行前进行自增。 **i++ 的操作分三步** 1. 栈中取出 i 2. i 自增 1 3. 将 i 存到栈 三个阶段:内存到寄存器,寄存器自增,写回内存(这三个阶段中间都可以被中断分离开) 所以 i++ 不是原子操作,上面的三个步骤中任何一个步骤同时操作,都可能导致 i 的值不正确自增 ### ++i 在多核的机器上,CPU 在读取内存 i 时也会可能发生同时读取到同一值,这就导致两次自增,实际只增加了一次。 i++ 和 ++i 都不是原子操作 **原子性**:指的是一个操作是不可中断的。即使是在多个线程一起执行的时候,一个操作一旦开始,就不会被其他线程打断。 JMM 三大特性:原子性,可见性,有序性。详情请阅读 Github 仓库:[Java 并发编程](03%20Java%20并发编程.md) 一文。 ## 4. 位运算符 Java 定义了位运算符,应用于整数类型 (int),长整型 (long),短整型 (short),字符型 (char),和字节型 (byte)等类型。 下表列出了位运算符的基本运算,假设整数变量A的值为60和变量B的值为13 A(60):0011 1100 B(13):0000 1101 | 操作符 | 名称 | 描述 | 例子 | | ------ | ---------- | ------------------------------------------------------------ | ----------------------------- | | & | 与 | 如果相对应位都是 1,则结果为 1,否则为 0 | (A&B)得到 12,即 0000 1100 | | \| | 或 | 如果相对应位都是 0,则结果为 0,否则为 1 | (A\|B)得到 61,即 0011 1101 | | ^ | 异或 | 如果相对应位值相同,则结果为 0,否则为 1 | (A^B)得到49,即 0011 0001 | | 〜 | 非 | 按位取反运算符翻转操作数的每一位,即 0 变成 1,1 变成 0 | (〜A)得到-61,即1100 0011 | | << | 左移 | (左移一位乘2)按位左移运算符。左操作数按位左移右操作数指定的位数。左移 n 位表示原来的值乘 2<sup>n</sup> | A << 2得到240,即 1111 0000 | | >> | | (右移一位除2)有符号右移,按位右移运算符。左操作数按位右移右操作数指定的位数 | A >> 2得到15即 1111 | | >>> | 无符号右移 | 无符号右移,按位右移补零操作符。左操作数的值按右操作数指定的位数右移,移动得到的空位以零填充 | A>>>2得到15即0000 1111 | ## 5. 原码、补码、反码是什么 ### 机器数   一个数在计算机中的二进制表示形式,叫做这个数的机器数。机器数是带符号的,在计算机用一个数的最高位存放符号,正数为 0,负数为 1。   比如,十进制中的数 +3 ,计算机字长为 8 位,转换成二进制就是 00000011。如果是 -3 ,就是 10000011 。那么,这里的 00000011 和 10000011 就是机器数。 ### 真值   因为第一位是符号位,所以机器数的形式值就不等于真正的数值。例如上面的有符号数 10000011,其最高位 1 代表负,其真正数值是 -3 而不是形式值 131(10000011 转换成十进制等于 131)。所以,为区别起见,将带符号位的机器数对应的真正数值称为机器数的真值。 例:0000 0001 的真值 = +000 0001 = +1,1000 0001 的真值 = –000 0001 = –1 ### 原码   原码就是符号位加上真值的绝对值,即用第一位表示符号,其余位表示值。比如如果是 8 位二进制:   [+1]<sub>原</sub> = 0000 0001   [-1]<sub>原</sub> = 1000 0001   第一位是符号位。因为第一位是符号位,所以 8 位二进制数的取值范围就是:[1111 1111 , 0111 1111],即:[-127 , 127]   原码是人脑最容易理解和计算的表示方式 ### 反码 反码的表示方法是: - **正数**的反码是其本身; - **负数**的反码是在其原码的基础上,**符号位不变,其余各个位取反**。 [+1] = [00000001]<sub>原</sub> = [00000001]<sub>反</sub> [-1] = [10000001]<sub>原</sub>= [11111110]<sub>反</sub> 可见如果一个反码表示的是负数, 人脑无法直观的看出来它的数值. 通常要将其转换成原码再计算。 ### 补码 补码的表示方法是: - **正数**的补码就是其本身; - **负数**的补码是在其原码的基础上,符号位不变,其余各位取反, 最后+1。(**反码的基础上 +1**) [+1] = [0000 0001]<sub>原</sub> = [0000 0001]<sub>反</sub> = [0000 0001]<sub>补</sub> [-1] = [1000 0001]<sub>原</sub> = [1111 1110]<sub>反</sub> = [1111 1111]<sub>补</sub> 对于负数,补码表示方式也是人脑无法直观看出其数值的。 通常也需要转换成原码在计算其数值。 参考资料: - [原码, 反码, 补码 详解 - ziqiu.zhang - 博客园](http://www.cnblogs.com/zhangziqiu/archive/2011/03/30/ComputerCode.html) ## 6. 不用额外变量交换两个整数的值 如果给定整数 a 和 b,用以下三行代码即可交换 a 和b 的值 ```java a = a ^ b; b = a ^ b; a = a ^ b; ``` - 假设 a 异或 b 的结果记为 c,**c 就是 a 整数位信息和 b 整数位信息的所有不同信息**。 - 比如:a = 4 = 100,b = 3 = 011,a^b = c = 111 - a 异或 c 的结果就是 b,比如:a = 4 = 100,c = 111,a^c = 011 = 3 = b - b 异或c 的结果就是 a,比如:b = 3 = 011,c = 111,b^c = 100 = 4 = a 说明:位运算的题目基本上都带有靠经验积累才会做的特征,也就是准备阶段需要做足够多的题,面试时才会有良好的感觉。 ## 7. 不使用运算符进行a+b操作 - a^b; 得到不含进位之和 - (a & b)<<1; 进位 - 只要进位不为零,则迭代;否则返回 ```java #include <stdio.h> int add(int a, int b) { int c = a & b; int r = a ^ b; if(c == 0){ return r; } else{ return add(r, c << 1); } } int main(int argn, char *argv[]) { printf("sum = %d\n", add(-10000, 56789)); return 0; } ``` ## 8. &和&& 、|和||的区别 (1)&& 和 & 都是表示与,区别是 && 只要第一个条件不满足,后面条件就不再判断。而 & 要对所有的条件都进行判断。 ```java // 例如: public static void main(String[] args) { if((23!=23) && (100/0==0)){ System.out.println("运算没有问题。"); }else{ System.out.println("没有报错"); } } // 输出的是“没有报错”。而将 && 改为 & 就会如下错误: // Exception in thread "main" java.lang.ArithmeticException: / by zero ``` - 原因: - &&时判断第一个条件为 false,后面的 100/0==0 这个条件就没有进行判断。 - & 时要对所有的条件进行判断,所以会对后面的条件进行判断,所以会报错。 (2)|| 和 | 都是表示 “或”,区别是 || 只要满足第一个条件,后面的条件就不再判断,而 | 要对所有的条件进行判断。 看下面的程序: ```java public static void main(String[] args) { if((23==23)||(100/0==0)){ System.out.println("运算没有问题。"); }else{ System.out.println("没有报错"); } } // 此时输出“运算没有问题”。若将||改为|则会报错。 ``` - 原因 - || 判断第一个条件为 true,后面的条件就没有进行判断就执行了括号中的代码 - 而 | 要对所有的条件进行判断,所以会报错