Java基础知识总结（上）

Java中的数据类型

Java的数据类型分为两大类：基本类型和引用类型

• 引用类型：引用类型指向一个对象，不是原始值，指向对象的变量称为引用变量。Java中除了基本类型，其他都是引用类型，如类（String类）、接口、数组、枚举、注解等。将引用存放栈中，实际存放值在堆内存。

• 基本数据类型（也称值类型）：整型（byte/short/int/long）、浮点型（float/double）、字符型（char占两个字节）与布尔型（boolean占一个字节）。直接在栈中存储数值。编程语言内置的最小粒度的数据类型，共有四大类八种基本数据类型。具体如下表：

标识符和关键字的区别是什么？Java关键字？

在我们编写程序的时候，需要大量地为程序、类、变量、方法等取名字，于是就有了标识符，简单来说，标识符就是一个名字。但是有一些标识符，Java 语言已经赋予了其特殊的含义，只能用于特定的地方，这种特殊的标识符就是关键字。因此，关键字是被赋予特殊含义的标识符。比如，在我们的日常生活中 ，“警察局”这个名字已经被赋予了特殊的含义，所以如果你开一家店，店的名字不能叫“警察局”，“警察局”就是我们日常生活中的关键字。

Java中的关键字：

自动拆装箱、发生与实现？

每个基本数据类型都对应一个包装类，除了 int 和 char 对应 Integer 和 Character 外，其余基本数据类型的包装类都是首字母大写即可，比较两个包装类数值要用 equals ，而不能用 == 。

• 自动装箱： 将基本数据类型包装为一个包装类对象，例如向一个泛型为 Integer 的集合添加 int 元素。
  • 使用基础型类给引用类型变量赋值；
  • 具体实现：调用引用类型对应的静态方法valueOf，本质是在该方法内部调用构造函数创建对象。

自动装箱的缓存机制：为了节省内存和提升性能，Java给多个包装类提供了缓存机制，可以在自动装箱过程中，把一部分对象放到缓存中（引用常量池），实现了对象的复用。如Byte、Short、Integer、Long、Character等都支持缓存。

• 自动拆箱： 将一个包装类对象转换为一个基本数据类型，例如将一个包装类对象赋值给一个基本数据类型的变量。
  • 当基础类型与引用类型进行 “==、+、-、×、÷” 运算时，会对引用类型进行自动拆箱；
  • 具体实现：引用类型对象内部包含对应基本类型的成员变量，自动拆箱时返回该成员变量即可；

switch支持哪些类型？

• jdk1.6之前只支持int、char、byte、short这样的整型的基本类型或对应的包装类型Integer、Character、Byte、Short常量，包装类型最终也会经过拆箱为基本类型，本质上还是只支持基本类型；JDK1.5开始支持enum，原理是给枚举值进行了内部的编号，进行编号和枚举值的映射。
• JDK1.7开始支持String，但不允许为null，原理是借助 hashcode( ) 来实现。

注意：null的hashCode()没有，hashmap是人为写到0槽的！

== 与 equals 区别

"=="对比的是栈中的内容：

• 基本数据类型比较的是变量值；
• 引用类型比较的堆中内存对象的地址。

equals 本质上就是 ==，只不过 String 和 Integer 等重写了 equals 方法，把它变成了值（内容）比较。

注：对于"=="中引用类型，除非是同一个new出来的对象，他们的比较后的结果为true，否则比较后结果为false。因为每new一次，都会重新开辟堆内存空间。

String中重写equals方法举例：

public boolean equals(Object anObject) {
    // 1. 如果比较的两个对象的首地址是相同的，那指的肯定是同一个对象
    if (this == anObject) {
        return true;
    }
    // 2. 两个对象的首地址不相同,比较内容是否相同
    // instanceof：判断传入的实参是否为String类型,因为形参类型是固定的(重写的要求),所以需要判断
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        // 判断传入对象长度是否相同
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                //实质比较字符的ascii值，即两个字符串内容的比较！
                if (v1[i] != v2[i])   
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

重写思路：

• 判断两个对象的内存首地址
• 判断传入形参的类型是否为String类型
• 判断传入对象的长度
• 判断字符的ascii码，即比较内容

应用案例分析：

String str1 = "Hello";      // 分配到常量池
String str2 = new String("Hello");   // 在堆中分配内存
String str3 = str2;   // 引用传递

System.out.println(str1 == str2); // false，比较两者栈中的内存地址，显然不同
System.out.println(str1 == str3); // false
System.out.println(str2 == str3); // true

System.out.println(str1.equals(str2)); // true，string重写了equals方法，实际上对比的两个字符串的内容
System.out.println(str1.equals(str3)); // true
System.out.println(str2.equals(str3)); // true

注意：字符串/包装类对象值的比较必须使用equals()，即对比内容。比如下边的Integer缓存-128~127的整型值，如果超过这个范围，就会在堆上创建对象，不会复用已有的对象。

int和Integer的区别（包装类与基本类型的区别）

• Integer是int的包装类，int则是java的一种基本数据类型
• Integer变量必须实例化后才能使用，而int变量不需要
• Integer实际是对象的引用，当new一个Integer时，实际上是生成一个指针指向此对象；而int则是直接存储数据值 。
• Integer的默认值是null，int的默认值是0

Integer a= 127与 Integer b = 127相等吗？（常量池缓存技术）

写在前：Java 基本类型的包装类的大部分都实现了常量池技术。

Byte,Short,Integer,Long 这 4 种整型的包装类默认创建了数值 [-128，127] 的相应类型的缓存数据，Character 创建了数值在[0,127]范围的缓存数据，Boolean 直接返回 True Or False。

注意：一个字节有8位。最大正数二进制是0111 1111 = 64+32+16+8+4+2+1=127；最小负数二进制是1000 0000→ 反码:1111 1111→ 补码: -{（1+2+4+8+16+32+64）+1} =-(127+1)=-128，整形的缓存范围都是[-128，127]。

对于对象引用类型：==比较的是对象的内存地址，对于基本数据类型：==比较的是值。

Integer内部有一个IntegerCache的内部类。对整型值在-128到127之间的对象进行缓存。缓存会在Integer类第一次使用的时候被初始化出来，那么自动装箱时不会new新的Integer对象，而是直接引用常量池中的Integer对象（直接从缓存中取出），超过范围 a1==b1的结果是false。

注：若数值超过缓存范围，则需要在堆中创建新的对象！

public static void main(String[] args) {
    Integer a = new Integer(1);
    Integer b = 1;  // 将1自动装箱成Integer类型，实际是调用静态方法valueOf()
    int c = 1;

    System.out.println(a == b);  // false,引用了不同对象
    System.out.println(a == c);  // true，a自动拆箱与c比较
    System.out.println(b == c);  // true

    Integer a1 = 128;
    Integer b1 = 128;
    System.out.println(a1 == b1);  // false, 自动装箱，new新的Integer对象

    Integer a2 = 127;
    Integer b2 = 127;
    System.out.println(a2 == b2);  // true，字面值介于-128与127, 自动装箱不会new新的Integer对象，直接引用常量池中的对象
}

java有了基本类型，为什么还要设计对应的引用类型？

• 可以使用为该引用类型而编写的方法
• Java集合（map、set、list）等所有集合只能存放引用类型数据，不能存放基本类型数据（容器中实际存放的是对象的引用）。
• 引用类型对象存储在堆上，可以控制其生命周期；而基本类型存储在栈上，会随着代码块运行结束被回收
• Java泛型使用类型擦除法实现，基本类型无法实现泛型。

为什么会设置包装类型？

• Java是一门面向对象的编程语言，但是Java中的基本数据类型却不是面向对象的，并不具有对象的性质，这在实际生活中存在很多的不便。为了让基本类型也具有对象的特征，就出现了包装类型，使得Java具有了对象的性质，并且为其添加了属性和方法，丰富了基本类型的操作，方便涉及到对象的操作。
• 比如，我们在使用集合类型时，就一定要使用包装类型，因为容器都是装object的，基本数据类型显然不适用。
• 逻辑上来讲，java只有包装类就够了，为了运行速度，需要用到基本数据类型。实际上，任何一门语言设计之初，都会优先考虑运行效率的问题，所以二者同时存在是合乎情理的。

java泛型相关问题

在 jdk 1.5 之前没有泛型的情况的下只能通过对类型 Object 的引用来实现参数的任意化，其带来的缺点是要做显式强制类型转换，而这种强制转换编译期是不做检查的，容易把问题留到运行时，会出现“java.lang.ClassCastException”异常。因此，导致此类错误编码过程中不易发现。

import java.util.ArrayList;
import java.util.List;

public class Test001 {

    public static void main(String[] args) {

        List list = new ArrayList();
        list.add("java");
        list.add("非泛型");
        list.add(100);

        // 泛型使用（jdk1.7实例化类型可以自动推断）
        List list1 = new ArrayList<>();
        list1.add("java");
        list1.add("泛型");
        // 想加入一个Integer类型的对象时会出现编译错误
        //list1.add(100);

        for (int i = 0; i < list1.size(); i++) {
            String name1 = list1.get(i);
            System.out.println("name1:" + name1);
        }

        System.out.println();

        for (int i = 0; i < list.size(); i++) {
            // Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
//            String name = (String) list.get(i);
//            System.out.println("name:" + name);
        }

        // 泛型擦除(泛型只存在编译阶段，成功编译过后的class文件中是不包含任何泛型信息的)
        List name = new ArrayList();
        name.add("java");
        List age = new ArrayList(712);

        System.out.println("name class:" + name.getClass());
        System.out.println("age class:" + age.getClass());
        System.out.println(name.getClass() == age.getClass());

        List