1、基本类型

Java的基本类型有整型、浮点型、字符型和布尔型。
整型：byte、short、int、long
浮点型：float、double
字符型：char
布尔型：boolean
a. 基本类型不是对象
b. 存储在常量池中
c. 不能为null

2.基本类型的包装类

a. java的8种基本类型都有对应的包装类

整型：Byte、Short、Interger、Long
浮点型：Float、Double
字符型：Character
布尔型：Boolean

b. 拆箱和装箱

装箱：将基本数据类型封装为包装类对象
拆箱：将包装类中包装的基本数据类型数据取出

        Integer i = 12; // 自动装箱
        int j = i; // 自动拆箱

c. 自动装箱的内存复用

自动装箱时，若生成的对象值在-128~127的范围内，生成的Integer实例化对象是由 IntegerCache.cache()方法产生，cache()方法会将位于-128~127范围内产生的Integer对象入池，下次使用的时候，从池中拿去，不会产生新的对象。

        Integer a = 1;
        Integer b = 1;

        Integer c = 211;
        Integer d = 211;

        System.out.println(a == b); // true
        System.out.println(a.equals(b)); // true
        System.out.println(c == d); // false
        System.out.println(c.equals(d)); // true

d. 浮点型精度丢失

计算机是利用二进制计算的，我们输入的十进制的数会转换成二进制，但是有些数字不能完全转换，只能无限接近于原本的值，因此会出现误差

System.out.println(12.3 - 0.1); // 12.200000000000001

e. 精度丢失解决方法

BigDecimal不存在精度丢失的问题，经常被运用在金融方面。

        BigDecimal a = BigDecimal.valueOf(12.3);
        BigDecimal b = BigDecimal.valueOf(0.1);
        System.out.println(a.subtract(b)); // 12.2

        //四舍五入保留两位小数
        double c = 1.3181715;
        BigDecimal d = BigDecimal.valueOf(c);
        System.out.println(d.setScale(2, RoundingMode.HALF_UP)); // 1.32

3. 字符串类型

a. String对象创建方式

        String s = "123"; // 通过字符串常量创建String对象
        String s2 = new String("123"); // 通过构造函数创建String对象

1、通过字符串常量创建String对象时，JVM会首先检查字符串常量池，如果该字符串已存在字符串常量池中，那么就将此字符串对象的引用地址赋给引用地址s；如果字符串常量不在常量池中，则会实例化该字符串并将其置于常量池中并将此字符串对象的地址赋值给引用s。
2、通过构造函数创建对象时，JVM会首先检查字符串常量池，如果该字符串已经存在常量池中，那么不再在字符串常量池创建该字符串对象，而直接堆中复制该对象的副本，然后将堆中对象的地址赋值给引用s2，如果字符串不存在常量池中，就会实例化该字符串并且将其放到常量池中，然后在堆中复制该对象的副本，然后将堆中对象的地址赋值给引用s2。

        String s1 = "a";
        String s2 = "a";

        String s3 = new String("a");
        String s4 = new String("a");

        System.out.println(s1 == s2); // true
        System.out.println(s1.equals(s2)); // true

        System.out.println(s3 == s4); // false
        System.out.println(s3.equals(s4)); // true

        System.out.println(s1 == s3); // false
        System.out.println(s1.equals(s3)); // true

b. intern()方法

interrn函数用于返回常量池中的某个字符串，如果常量池中已存在该字符串，则直接返回常量池中该对象的引用，否则，在常量池中加入该对象，然后返回引用。

        String s5 = new String("b").intern();
        String s6 = new String("b").intern();

        System.out.println(s5 == s6); // true

c. StringBuilder优化字符串拼接

在动态拼接字符串时，字符串+默认会转变为StringBuilder的append()方法，这样做可以减少对象的创建，提高系统性能。
(1) 使用常量字符串拼接

        String s = "1" + "2"; // 常量字符串拼接的字符串也是常量，编译期就能确定，直接入字符串常量池
        String s2 = "12"; // 从常量池引用，所以s和s2指向同一个对象
        System.out.println(s == s2); // true 

(2) 含有变量字符串拼接
当使用“+”连接字符串中含有变量时，在运行期才能确定。下面的字符串c可以看做以下过程获得的
c = new StringBuilder("1").append("2").toString();

        String a = "1";
        String b = "2";
        String c = a + b; // c指向堆中创建的字符串"12"
        String d = "12"; // 指向栈中的常量字符串"12"
        System.out.println(c == d); // false

再来看一个更加复杂的例子

String e = "1" + "2" + new String("3") + "4";

字符串e的创建过程等效于
e = new StringBuilder("12").append(new String("3")).append("4").toString();

若想要更深入的了解可以查看这篇文章 深入理解Java中的String（大坑）

d. 字符串类型不可变、不可被继承

value[]被final修饰，String值不可变
String类被final关键字修饰，不可被继承。
String被设计成不可变和不能被继承的原因：
（1） 保证对象的安全性，不会被恶意修改。
（2）保证hash属性不会频繁变更，确保了唯一值。
（3）可以实现字符串常量值。

e. String、StringBuilder、StringBuffer

String：不可变
StringBuilder：可变、不同步
StringBuffer：可变、同步、相较于 StringBuilder速度较慢（加锁的原因）

3. 面试题

a. 用效率最高的方法计算2 * 8

        int a = 2 << 3; // 16

参考链接
深入理解Java中的String（大坑）