Java基础

Java基础复习

Java常用快捷键

删除指定行：Ctrl+D

复制当前行到下一行：Ctrl+Alt+向下光标

运行代码：Alt+B

查看类的继承关系：把光标放在类名上，Ctrl+H

补全代码：Alt+/

注释：Ctrl+/

位运算

原码、反码、补码

• 二进制的最高位是符号位，0表示整数，1表示负数
• 正数的原码，反码，补码都一样（三码合一）
• 负数的反码 = 原码的符号不变，其他位取反
• 负数的补码 = 反码 + 1，负数的反码 = 补码 - 1
• 0的反码，补码都是0
• java没有无符号数，即java中的数都是有符号的
• 在计算机运行时，都是以补码的方式运行的
• 当看运行结果时，要看它的原码

位运算符

• &（按位与）与运算
• |（按位或）或运算
• ^（按位异或）：两位一个为0，一个为1，结果为1，否则为0
• ~（按位取反）：取反操作
• >>（算术右移）：低位溢出，符号位不变，并用符号位补溢出的高位（相当于/2）
• <<（算术左移）：符号位不变，低位补零（相当于*2）
• >>>（无符号右移）：低位溢出高位补零

数组

数组的定义

//动态初始化//方式一int[] arr1= new int[5];//方式二int[] arr2;arr2 = new int[10];//静态初始化int[] a = {1,2,3,4,5};

基本数据类型

char

• char的本质是一个整数，在输出时，输出的是unicode编码对应的字符，如果想要直接输出字符对应的数字，可以进行类型转换

char a='A';System.out.println((int)a)

• char类型是可以运算的，相当于一个整数

自动类型转换

转换规则：

char->int->long->float->doublebyte->short->int->long->float->double

细节：

• 当多种数据类型混合运算时，系统首先将所有数据类型转换为容量最大的数据类型，然后进行计算

  int a=1;float f = a + 1.1;  //错误，1.1为double类型float f = a + 1.1F; //正确     
  

• 不可以把容量大的数据类型赋值给容量小的数据类型

• 将一个具体的数字赋给byte类型，只要数字在-128~127就可以

• byte，short和char之间可以进行计算，在计算时首先转换为int类型（赋值操作先对等号右边进行处理）

  byte b1=1,b2=2;byte b3=b2 + b1;  //这样是错误的，只要有byte类型，计算时就会转换为int在计算
  

• boolean不参与类型转换

• byte和short都不能和char进行自动类型转换

• c++和java中区别

  int a = 20;char b = 'A';int c = b + a;  //85char d = b + 20; //U   在c++中这段代码是正确的int a = 20;char b = 'A';int c = b + a;  //85char d = b + 20; //U   在java中就会报错，需要进行强制类型转换
  

强制类型转换

当想要把一个容量大的数据类型赋值给容量小的数据类型，就要进行强制类型转换，会有精度损失

细节：

• 强制转换符号针对最近的操作符有效，往往需要小括号提升优先级
• char可以保存int类型的常量值，但不能保存int类型的变量

基本数据类型->String

在基本数据类型后加一个字符串就可以实现

int a=10;//方式一String str = a + "";//fstr = String.valueOf(a); 

String->基本数据类型

使用包装类提供的方法实现转换

String str = "123";int a = integer.parseInt(str);

String->char

使用String类的charAt()来获取字符串中的字符

字符编码表

• ASCII：表用一个字节，实际上一个字节可以表示256个字符，只用了128个
• Unicode：固定大小的编码，兼容ASCII码，使用两个字节表示字符，字母和汉字统一用两个字节表示（这样会浪费空间）
• UTF-8：大小可变的编码表，字母用一个字节，汉字用三个字节。在互联网中使用最广的对Unicode的改进。
• GBK：可以表示汉字，字母使用一个字节，汉字使用两个字节
• GB2312：可以表示汉字（用的少）
• BIG5：繁体中文，台湾，香港

属性

属性，也可以叫做字段，成员变量。属性如果未赋值默认值为：

• byte 0
• short 0
• int 0
• long 0
• float 0.0
• double 0.0
• char \u000
• boolean false

this指针

• 在每创建一个对象的同时，就会有一个this指针指向当前的对象。所以每创建十个对象就会有十个this指针指向各自的对象

• this在类中可以用来访问该类的成员，包括成员变量，成员函数，构造函数。

Static关键字

static可以修饰：变量，代码块，方法（不能修饰构造方法）

• 静态变量：引用类型初始值为null，基本数据类型初始值为1.（初始值和普通变量相同）
• 静态代码块
• 静态方法：
  • 可以访问静态变量，静态方法。
  • 不可以访问非静态变量，非静态方法。
  • 不能使用与类对象相关的关键字（this，super）

静态代码块：static修饰代码块，属于类。类加载一次，静态代码块执行一次。需要注意的是：因为代码加载顺序的问题，**静态代码块，是不能写在静态方法内部的，只能写在类的内部。同理，静态方法内部也是不能定义静态变量的。**也就是说静态内部不能再有静态

成员代码块：属于对象实例。调用一次构造方法创建一个对象，成员代码块执行一次。先执行成员代码块，再执行构造方法

局部代码块：属于方法，执行一次方法，局部代码块执行一次。方法中的代码顺序执行，不会提前执行。

main()

• main()有虚拟机调用
• 因为虚拟机要调用类中的main()，所以一定要public修饰
• Java虚拟机在执行main()时，不必创建对象就可以调用，所以要用static修饰
• main()的参数是一个String类型的数组，该数组中保存执行java命令时，传递给所运行类的参数

访问权限修饰符

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wZlu1fCP-1632385272609)(D:\document\小林code\小林图片\Java访问权限修饰符.png)]

• 权限修饰符可以修饰构造方法
• 类只能使用public和默认修饰符

继承

继承的基本概念：

（1）Java不支持多继承，也就是说子类至多只能有一个父类。

（2）子类继承了其父类中不是私有的成员变量和成员方法，作为自己的成员变量和方法。

（3）子类中定义的成员变量和父类中定义的成员变量相同时，子类中会有两个同名的变量.

（4）子类中定义的成员方法，并且这个方法的名字，返回类型，以及参数个数和类型与父类的某个成员方法完全相同，则父类的成员方法不能被继承，使用自己的方法。

继承中的成员变量：

• 子类直接继承父类非私有的成员变量，作为自己的变量
• 子类继承了父类所有的方法和属性，但是父类中私有的属性和方法在子类中不能直接访问，要通过父类公共的方法来访问
• 子类如果有和父类完全一样的变量：子类中会有两个完全一样的变量

继承的使用细节：

• 子类必须调用父类的构造器，来完成父类的初始化。
• super使用时，必须放在构造器的第一行（super只能在构造器中使用）。
• this和super，都必须放在构造器的第一行，因此两个方法方法不能在一个构造器中使用
• 父类构造器的调用不限于直接父类，会一直追随到Object类（顶级类）
• 不能滥用继承，父类和子类必须符合is-a的关系
• A继承B，B继承C，可实现类似A继承B，C的效果
• 在继承体系中，按照查找关系来放回属性值：
  • 如果子类中有该属性，就直接放回
  • 如果子类中没有该属性，就到父类中找（如果父类中有该属性，并且可以访问，就返回）
  • 一直早到Object类，如果还没找到就会报错
  • 在查找的过程中，如果找到了该属性，但该类中的该属性时不可访问的，就会直接报错，不会继续往上找

super关键字的作用：super代表父类的引用，可以访问父类非私有的属性，方法和构造器

super的使用细节：

• 调用父类构造器的好处（分工明确，父类初始化父类的属性，子类初始化子类的属性）
• 当子类和父类中有重名的成员（属性和方法），为了访问父类的成员必须通过super。如果没有重名时，使用super，this，直接访问的效果一样

继承体系中的类加载机制：

• 先初始化父类，在初始化子类。即先调用父类构造器，在调用子类构造器

继承中属性和方法访问机制

• 当要访问一个方法或属性时，先在本类中找，找了就返回结果，如果没有找到的话，就到父类中找，如果找到就返回，一直找到Object顶级类。在这个过程中，只要找到可返回的属性或方法就会返回结果，不再继续往下找。如果都没找到就回报错。
• 可以使用super关键字，重当前类的父类的开始找（super关键字的作用）。
• 查找属性和方法唯一不同的点在于：属性在堆中查找，方法在方法中查找

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xVb02PDe-1632385272611)(D:\document\小林code\小林图片\继承内存关系图.png)]

---

编译阶段的过程：

1. 程序员需要在硬盘的某个位置新建一个.Java扩展名的文件，该文件被称为Java源文件，源文件当中编写的是Java源代码/源程序，而这个源程序是不能随意编写的，必须符合Java语法规则

2. Java程序员需要使用JDK当中自带的Javac.exe命令进行Java程序的编译。一个Java源文件可以编译生成多个.class文件（字节码文件）

运行阶段的过程：
1. 打开DOS命令窗口，输入Java A ，Java.exe命令会启动Java虚拟机（JVM），JVM会启动类加载器classLoader，classLoader会去硬盘上搜索A.class文件.
2. 找到该文件将该字节码文件装载到JVM中，JVM将.class字节码文件解释成二进制形式，然后操作系统执行二进制和底层硬件平台进行交互.

---

属性和成员变量的区别

属性的官方定义：SUN官方定义为属性是指get或者set方法名 去掉get或者set后，把剩余的部分首字母改为小写后，即为这个类的属性。

大多数情况下，成员变量和属性的概念是一样的。

---

运行时类型和编译类型

Java的引用变量有两个类型，一个是编译时类型，一个是运行时类型，编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的类型决定。如果编译时类型和运行时类型不一致，会出现所谓的多态。因为子类其实是一种特殊的父类，因此java允许把一个子类对象直接赋值给一个父类引用变量，无须任何类型转换，或者被称为向上转型，由系统自动完成。

//  编译时类型        运行时类型     Animal cat=new Cat();

引用变量在编译阶段只能调用其编译时类型所具有的方法，但运行时则执行它运行时类型所具有的方法（意思是说：编写代码时，只能调用父类中具有的方法，如果子类重写了该方法，运行时实际调用的是运行时类型的该方法。程序在编译时，会在编译类型中检查是否具有所调用的方法，如果编写代码时，使用引用变量调用子类中的特有方法，或者调用重载了父类中的方法，而父类中找不到该方法，则会报编译错误），因此，编写Java代码时，引用变量只能调用声明该变量所用类里包含的方法。与方法不同的是，对象的属性则不具备多态性。通过引用变量来访问其包含的实例属性时，系统总是试图访问它编译时类所定义的属性，而不是它运行时所定义的属性。所以，要访问子类中特有的方法和属性，在编写代码时，则必须进行类型转换。

代码演示：

class Father{    public void method(){        System.out.println("父类方法  "+this.getClass());    }    public static void main(String[] args) {        Father instence =new Son();        instence.method();    }}class Son extends Father{    public void method(){        System.out.println("子类方法  "+this.getClass());    }}结果：子类方法  class reviewInherit.Son

2. 去掉子类的方法：会去执行父类的方法

class Father{    public void method(){        System.out.println("父类方法  "+this.getClass());    }    public static void main(String[] args) {        Father instence =new Son();        instence.method();    }}class Son extends Father{}结果: 父类方法  class reviewInherit.Son

3. 动态绑定只是针对对象的方法，对于属性无效。因为属性不能被重写。

class Father{    private String name="父类";    public static void main(String[] args) {        Father instance =new Son();        System.out.println(instance.name);    }}class Son extends Father{    private String name="子类";}结果：父类

也可通过以下代码证明：

class Father{    private String name="父类";}class Son extends Father{    private String name="子类";    public static void main(String[] args) {        Father instance =new Son();        System.out.println(instance.name);    }}instance.name  处直接报错  'name' has private access in 'reviewInherit.Father'

4.要访问子类中特有的方法和属性，在编写代码时，则必须进行类型转换。

class Father{    private int count=10;}class Son extends Father{    private int count=100;    public static void main(String[] args) {        Son s =new Son();        Son instance=s;        System.out.println(instance.count);    }}结果  100

改为如下代码：

class Father{    private int count=10;}class Son extends Father{    private int count=100;    public static void main(String[] args) {        Son s =new Son();        Father instance=s;        System.out.println(instance.count);    }}instance.count  处直接报错：  'count' has private access in 'reviewInherit.Father'

对于 Class Father 和Class Son来说，Class Son是Class Father的子类，由于子类的变量并不会覆盖父类的变量，所以实际上在class B中是存在来两个count，在这分别记作Father.count 和Son.count ；

虽然在 Class Son中存在A.count 和B.count ，但是究竟输出那一个 count取决于该引用变量的声明时类型

重载和重写区别

方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性。重载发生在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同或者二者都不同）则视为重载；重写发生在子类与父类之间，重写要求子类被重写方法与父类被重写方法有相同的参数列表，有兼容的返回类型，比父类被重写方法更好访问，不能比父类被重写方法声明更多的异常（里氏代换原则）。重载对返回类型可以与父类的放回值类型一样，也可以是父类放回值类型的子类（其他情况报错）。

object中方法

Object 类属于java.lang包，此包下的所有类在使用时无需手动导入，系统会在程序编译期间自动导入

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-z740UJZM-1632385272613)(D:\document\小林code\小林图片\Object类.png)]

toString()

在使用对象直接嗲用toString()的时候，默认输出的是一个对象在堆内存上的地址值；如若要输出该对象的内容，则要覆写toString()方法

在源码中，可以发现通过反射，获取到了当前对象的全限定类名和@十六进制哈希值字符串。这就是不覆写toString()时直接打印输出的内容。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vNEVGe4Z-1632385272619)(D:\document\小林code\小林图片\原始toString方法.png)]

toHexString()用于获取double类型的十六进制数字转换为字符串

public static String toHexString(double value);

equals()

• 只能判断引用类型

• 基本数据类型的比较用 == (如： a == 3，b == 4, a == b，比较的是值是否相等）

• 引用类型数据比较：调用 equals()方法进行比较

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0lRpwhdZ-1632385272622)(D:\document\小林code\小林图片\重写equals方法.png)]

hashcode()

Object 对象的 hashCode() 方法会根据不同的对象生成不同的哈希值，默认情况下为了确保这个哈希值的唯一性，是通过将该对象的内部地址转换成一个整数来实现的。

通过计算，返回对象的hash值。相同的对象一定返回相同的hash值，但不同的对象不一定放回不同的hash值，也就是说，不同的对象可能产生相同hash值（hash冲突）。

/*	a[]中包含的是对象的属性值*/public static int hashCode(Object a[]) {        if (a == null)            return 0;        int result = 1;        for (Object element : a)            result = 31 * result + (element == null ? 0 : element.hashCode());        return result;    }

通常我们在使用Set和Map集合时，不允许在集合有相同对象。这种机制就是使用hashcode()的特性来实现的，但由于hash冲突的存在，就要求在重写了hashcode()后，必须重写equals()。

• 如果对象的hash值不同，就说明这对象不同，可直接加入到集合中。
• 如果对象hash值相同，还需要由equals()方法来进一步判断对象是否相同。

finalize()

当没有任何引用的指向一个对象时，则jvm就认为该对象就是一个垃圾对象，就会使用垃圾回机制来销毁该对象（释放该对象的堆内存空间），在对象销毁前会调用finaliz()。程序员可以在finalize()方法中写入自己的业务逻辑代码（比如释放资源：关闭数据库连接，关闭文件）

clone()

浅拷贝

定义：被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。即对象的浅拷贝会对“主”对象进行拷贝，但不会复制主对象里面的对象。”里面的对象“会在原来的对象和它的副本之间共享。

简而言之，浅拷贝仅仅复制所考虑的对象，而不复制它所引用的对象。

• 使用拷贝构造函数实现浅拷贝：

• 使用clone()实现浅拷贝

深拷贝

定义：深拷贝是一个整个独立的对象拷贝，深拷贝会拷贝所有的属性,并拷贝属性指向的动态分配的内存。当对象和它所引用的对象一起拷贝时即发生深拷贝。深拷贝相比于浅拷贝速度较慢并且花销较大。

简而言之，深拷贝把要复制的对象所引用的对象都复制了一遍。

• 使用clone()实现

• 使用序列化实现深拷贝

clone()为什么必须实现Cloneable接口：

1. Cloneable是标示接口与java.io.Serializable类似，用于告知JVM该对象实现clone。并且super.clone()可以返回一个复制。
2. 很多时候，会把protected的clone方法修改为public，暴露给其他人可以使用.详细信息，建议仔细阅读JDK的文档

多态

方法的重载又被称为：静态多态

方法的重写又被称为：动态多态

多态的细节：

• 一个对象的编译类型和运行类型可以不一致
• 编译类型在定义时已经确定，不能改变
• 运行类型是可以改变的

Animal animal = new Dog();animal= new Cat();

• 在我们编写源代码时（.java文件），只能调用编译时类型中具有的方法
• 代码运行过程中，调用的是运行时类型的方法。如果运行时类型没有该方法，就回到父类中寻找，和继承体系中的方法访问机制一样

向下转型

• 语法：子类类型 引用名 = （子类类型）父类引用

• //编译类型和运行类型都是CatCat cat = (Cat)Animal;
  

• 要求父类引用必须指向的是当前目标类型的对象

instanceof

判断对象的运行时类型是否否为xx类型的类型或xx的子类型

Java动态绑定机制

• 当调用对象方法时，该方法和该对象的运行时类型绑定
• 调用对象的属性时，没有动态绑定机制，哪里声明，那里调用。

多态的引用

• 多态数组：数组的定义类型为父类类型，里面保存的实际类型是子类类型
• 多态参数：方法定义的形参是父类类型，实参允许为子类类型

断点调试

在断点调试过程中，程序处于运行状态。也就是说变量是运行时类型

调试快捷键

• 逐行指向代码 F8
• 跳入方法 F7
• 强制进入方法 Alt+Shift+F7
• 跳出方法 Shift+F8
• 跳到下一个断点 F9

当你在调试的过程中，依然可以断点，使用F9可以跳到下一个断点。但也会根据业务逻辑，来判断是否能到达下一个断点，如果不能，就会跳过。

代码块

• 相当于另一种形式的构造器（对构造器的一种补充机制），可以做初始化操作

• 当我们每创建一个对象时，都会先调用代码块中的内容。代码块中的调用优先于构造器

细节

• 静态代码块，作用就是对类对进行初始化，而且它随着类的加载而执行，并且只会执行一次。
• 如果是普通代码块，每创建一个对象实例，就会执行次。如果只调用静态成员，不会调用普通代码块
• 类声明时候会被加载：
  • 创建对象实例
  • 创建子类对象实例时，父类也会被加载
  • 使用类的静态成员时（静态属性，静态方法）

创建对象时，在一个类中的调用顺序：

1. 调用静态代码块和静态属性初始化（静态代码快和静态属性的调用优先级是一样的，如果有多个静态代码块和静态属性的初始化这按照定义顺序初始化）
2. 调用普通代码块和普通属性（普通代码块和普通属性的）
3. 构造方法

对象的加载流程

1. 在方法区中加载类
2. 属性隐式初始化（给默认值）
3. 属性显示初始化（在创建属性时赋的值）
4. 调用构造器初始化

当你调用一个构造器，为了更好理解，可以认为在构造器中隐藏了两段代码，例如：

public Person(){	super();	//本类的普通代码块和普通属性} 

单例设计模式

饿汉式

public class SingerTon1 {    public static void main(String[] args) {        GirlFriend girlFriend1 = GirlFriend.getGirlFriend();        GirlFriend girlFriend2 = GirlFriend.getGirlFriend();        System.out.println(girlFriend1==girlFriend2);        System.out.println(girlFriend1);    }}class GirlFriend {    private String name;    // static b保证静态方法中返回    private static GirlFriend girlFriend = new GirlFriend("锅盖");    // private 外部不能创建对象    private GirlFriend(String name) {        this.name = name;    }    public static GirlFriend getGirlFriend() {        return girlFriend;    }    @Override    public String toString() {        return "GirlFriend{" +                "name='" + name + '\'' +                '}';    }}

饿汉式：如果类中有静态属性，被调用话。就会调用构造器，产生对象，容易造成资源浪费

懒汉式

public class SingerTon2 {    public static void main(String[] args) {        Dog dog= Dog.getInstance();        System.out.println(dog);    }}class Dog{    private String name;    private static Dog dog;    private Dog(String name){        this.name=name;    }    public static Dog getInstance(){        if(dog==null){            dog=new Dog("元芳");        }        return dog;    }    @Override    public String toString() {        return "Dog{" +                "name='" + name + '\'' +                '}';    }}

• 饿汉式和懒汉式的区别主要在于创建对象的时机不同，饿汉式是在类加载的时候创建，懒汉式是在使用时创建
• 饿汉式存在资源浪费的问题，懒汉式存在线程安全的问题

final

final修饰变量，定义时必须赋值：有如下几种情况

• 定义时
• 代码块
• 构造器

如果final修饰的是静态属性的话，只能在：

• 定义时
• 静态代码块

fina类不能继承，但可以实例化

如果不是final类，但有final属性，属性可以被继承，不能被重写

如果一个类已经是final方法，就没有必要将属性和方法修饰为final了

final不能修饰构造方法

final和static往往搭配使用，效率更高，不会导致类的加载，底层编译器做了优化

包装类String类都是final修饰，不能被继承。

抽象类

• 抽象类不能被实例化
• 抽象不一定包含抽象方法（abstract修饰），即抽象类中可以没有抽象方法
• 一旦有抽象方法，就必须声明抽象类
• 抽象类本质还是类，抽象类可以有任意成员
• 如果一个类继承抽象类，则必须实现抽象类中的所有方法，除非声明自己为抽象类
• 抽象方法不能使用private，static，final修饰的，因为这些关键字是和方法重写相违背的

接口

接口中可以有三种类型的方法：

• 抽象方法
• default修饰的方法
• 静态方法

细节：

• 接口不能被实例化
• 接口中所有的方法都是public abstract方法，这两个关键字可以省略不写
• 一个普通类实现一个接口，必须实现接口中所有的方法
• 抽象类在实现接口时，可以不实现接口中的抽象方法
• 一个类中可以实现多个接口
• 接口中的属性，默认是public static final修饰的
• 接口中属性的访问方式：接口名.属性名
• 接口不能继承其他的类，但可以同时继承多个别的接口
• 接口的修饰符和类的修饰符，只能使用public和默认
• 一个类可以同时继承和实现类
• 接口中也有多态参数和多态数组
• 接口中存在多态传递现象

接口是对java单继承的一种补充

接口中的多态传递

public class C {    public static void main(String[] args) {        A a = new D();        B b = new D();    }}interface A{    void say();}interface B extends A{    void hi();}class D implements B{    @Override    public void hi() {        System.out.println("你好");    }    @Override    public void say() {        System.out.println("憨憨");    }}

继承中的多态传递

public class E extends F{    public static void main(String[] args) {        G g = new E();    }}class F extends G{}class G{}

类的五大成员

• 属性
• 方法
• 构造器
• 代码块
• 内部类

内部类

局部内部类

• 局部内部类本质仍然是一个类，定义在外部类中的局部位置（方法，代码块）
• 可以直接访问外部类的所有成员，包括私有成员
• 不能添加访问修饰符，但可以添加final（相当于一个局部变量）
• 外部类访问局部内部类成员：先创建内部类对象，通过对象访问内部类成员
• 作用域：仅仅在定义局部内部类的方法或代码块中
• 外部其他内部类不能访问局部内部类
• 如果局部内部类和外部类成员重名时，默认遵守就近原则。如果想要在局部内部类中访问外部类重名的属性，可以使用外部类.this.属性名来访问。外部类.this就表示调用该方法的对象

匿名内部类

匿名内部类的本质还是一个类，定义在外部类的局部位置。其实也相当于一个对象。

接口的匿名内部类：

public class AnonInter {    public static void main(String[] args) {        Inner inner = new Inner() {            @Override            public void say() {                System.out.println("hello");            }        };        System.out.println(inner.getClass());  //class anonymous.AnonInter$1    }}interface Inner{    void say();}

编译时类型：Inner

运行时类型：AnonInter$1

其实在JDK的底层是会创建一个类（外部类$1）,该类隐式的实现了Inner接口。创建该类的实例对象，将对象的地址放回。我们可以通过对象名.getClass()来获取匿名内部类的运行时类型

匿名内部类只能使用一次

类的匿名内部类

public class AnonClass {    public static void main(String[] args) {        Father father = new Father(){            @Override            public void say() {                System.out.println("hello");            }        };        System.out.println(father.getClass());  //class anonymous.AnonClass$1    }}class Father{    public void say(){        System.out.println("你好");    }}

当我们在new Father()后加了括号，就不再是创建一个对象了，而是一个匿名内部类，她在底层隐式继承了Father类，所以可重写父类的方法

编译时类型：Father

运行时类型：AnonClass$1

如果使用匿名内部类时，有参数传入的话，会传给Fathe构造器

使用匿名内部类

public class Anon {    public static void main(String[] args) {        Base base=new Base(){            @Override            public void say() {                System.out.println("hello");            }        };        base.say();  //hello        new Base(){            @Override            public void say() {                System.out.println("Hello Word");            }        }.say();  //Hello Word    }}class Base{    public void say(){        System.out.println("你好");    }}

使用细节：

• 可以访问外部类的所有成员，包括私有成员
• 不能添加访问修饰符，因为匿名内部类相当于一个局部成员
• 作用域：仅仅在定义它的方法会代码中
• 当匿名内部类和外部类有同名成员时，遵循就近原则
• 外部其他类不能访问匿名内部类中的成员

成员内部类

• 可以直接访问外部类的所有成员

• 可以使用任意修饰符修饰，因为成员内部类就相当于一个成员属性

• 作用域：外部类中都可以使用，地位相当于成员属性

• 成员内部类访问外部类成员的方式：直接访问

• 外部类访问成员内部类成员的方式：先创建成员内部类对象，通过对象访问成员

• 外部其他类访问成员内部类的方式：

  public class Test {    public static void main(String[] args) {        Out out = new Out();        Out.Inner inner = out.new Inner();        inner.say();        Out.Inner innerInstance = out.getInnerInstance();        innerInstance.say();    }}class Out{    public class Inner{        public void say(){            System.out.println("hello");        }    }    public Inner getInnerInstance(){        return new Inner();    }}
  

  • 如果成员内部类和外部类有重名的成员，遵循就近原则。想要在成员内部类中访问外部类的成员，就需要使用外部类类名.this.属性

静态内部类

• 使用static修饰，放在外部类的成员位置

• 可以直接访问外部类的所有静态成员，包括私有成员

• 可以添加任意访问修饰符

• 作用域：整个外部类类体

• 外部其他类访问静态内部类

  public class Test {    public static void main(String[] args) {        //外部其他类访问静态内部类成员        //1. 使用外部类名创建对象        Out.Inner inner = new Out.Inner();        //2. 返回对象实例        Out out = new Out();        //使用普通方法        Out.Inner innerInstance = out.getInnerInstance();        //使用静态方法        Out.Inner instance = out.getInstance();    }}class Out{    static class Inner{        public void say(){            System.out.println("hello");        }    }    public Inner getInnerInstance(){        return new Inner();    }    public static Inner getInstance(){        return new Inner();    }}
  

• 如果静态内部类和外部类有重名的成员，遵循就近原则。想要在成员内部类中访问外部类的成员，就需要使用外部类类名.属性

注解

元注解

@Target 修饰注解的注解，元注解。表明注解可以修饰那些元素

@Retention可以指定保留的策略

@Documented使用javadoc工具提取成文件，及生成文档时，可以看到该注解

@interface表示一个注解类

@Override表明方法被重写

@Target(ElementType.METHOD)@Retention(RetentionPolicy.SOURCE)public @interface Override {}

@Deprecated表明元素已经过时

@Documented@Retention(RetentionPolicy.RUNTIME)@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE})public @interface Deprecated {}

@SuppressWarnings抑制警告

@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})@Retention(RetentionPolicy.SOURCE)public @interface SuppressWarnings {    /**     * The set of warnings that are to be suppressed by the compiler in the     * annotated element.  Duplicate names are permitted.  The second and     * successive occurrences of a name are ignored.  The presence of     * unrecognized warning names is not an error: Compilers must     * ignore any warning names they do not recognize.  They are, however,     * free to emit a warning if an annotation contains an unrecognized     * warning name.     *     * 
 The string {@code "unchecked"} is used to suppress     * unchecked warnings. Compiler vendors should document the     * additional warning names they support in conjunction with this     * annotation type. They are encouraged to cooperate to ensure     * that the same names work across multiple compilers.     * @return the set of warnings to be suppressed     */    String[] value();}

异常

try–catch快捷键（Ctrl+Alt+T）

异常可以分为两大类：运行时异常和编译时异常

运行时异常

编译器检查不出来。一般是指编程时的逻辑错误，是程序员应该避免的异常。对于运行时异常，可以不做处理，因为这类异常很普遍，若全处理可能会对程序的可读性和运行效率产生影响

• NullPointerException
• ArrayIndexOutOfBoundException
• ClassCastException（出现在引用类型向上转型时）
• NumberFormatException
• ArithmeticException

编译时异常

编译时要求必须处理的异常

try-catch-finally

• try：try中发的是程序员写的可能产生异常的代码
• catch：当异常发送时，系统将异常封装成Exception对象，得到异常对象后可以程序员可以自己处理。当没有异常产生时，catch中的代码不会执行
• finally：不管try块中是否产生了异常，都会执行finally中的代码，一般用于资源的释放

throws

• 将异常抛出给方法的调用者，JVM顶级是顶级调用者。
• 如果没有显示的处理异常，默认就是throws
• 当异常抛给JVM，就会打印异常信息，并中断程序执行
• 子类重写父类的方法，抛出的异常与父类的相同，或是父类抛出异常的子类
• 在使用throws过程中，就没有必要使用try-catch。
• 如果一个方法中有运行时异常抛出，那么该方法的调用者也必须显示的抛出该异常或try-catch，不做处理就会报错。
• 如果一个方法中抛出的是编译时异常，可以不显示的处理，因为有默认的处理机制。

使用细节

• 在try块中，如果异常发生了，则异常后面的代码就不会执行，直接进入到catch块中
• 如果异常没有发生就会顺序执行try块中的代码，不会进入到catch中
• 当try块中可能有多个异常时，可以使用多个catch块来分别捕获。要求子类异常在前，父类异常在后。如果发生异常只会匹配一个catch块
• 可以进行try-finally配合使用，这种用法相当于没有捕获异常，因此程序会直接崩掉。
• 如果catch块中有return语句。程序会先执行catch中的return语句，但不直接返回，而是把catch块中return的结果保存下来。因为finally块是一定要执行的。
  • 如果finally块中也有return语句，就会直接返回finally块中的return，方法执行完毕。
  • 如果finally中没有return语句，就会返回catch块中保留的return结果

使用异常实现输入数字

public class InputInteger {    public static void main(String[] args) {        Scanner scanner = new Scanner(System.in);        int num;        while(true){            System.out.println("请输入一个整数");            try {                num = Integer.parseInt(scanner.next());                break;            } catch (NumberFormatException e) {                System.out.println("你的输入有误");            }        }        System.out.println("你输入的数字为："+ num);    }}

自定义异常

创建一个类继承RuntimeException类即可。我们一般都将其定义为一个运行时异常，可以采用默认的处理机制，使用起来比较方便。

	意义	位置	后跟
throw	手动生成异常对象的关键字	方法体中	异常对象
throws	异常处理的一种方式	方法声明中	异常类型

包装类

继承图

有了包装类对象，就可以使用类的方法

自动装箱和自动拆箱

Integer integer = 20;  //自动装箱  底层调用Integer.Valueof(20)int n = integer;       //自动拆箱  底层调用Integer.intValue(integer)

题目练习

Object obj = true? new Integer(1): new Double(1);//输出  1.0//因为三元运行符是一个整体，会提升优先级

if(true){	System.out.println(new Integer(1));}else{	System.out.println(new Double(1));}//输出1

缓冲池数值比较问题

只要有基本数据类型比较，就是是值的比较

Integer i1 = 128;int i2 =128;System.out.println(i1==i2);  //ture

String

• String对象用于保存字符串，也就是一组字符串序列
• 字符串的字符使用的是Unicode编码，一个字符（不区分字母还是汉字）占两个字节
• String类有很多构造器，构造器的重载
• String类实现了Serializable接口，可以实现串行化，在网络中传输
• String类实现了Comparable接口，可进行字符串的比较
• String类被final修饰，不能被其他类继承
• String类中属性：private final char value[]用于存放字符串内容，value[]被final修饰，value的指向就不可以修改了，但value[]中内容是可以修改的。

创建String对象两种方式的区别

方式一

String str = "hsp";

先看常量池中是否有hsp,如果有，主栈中的str引用变量就直接指向常量池中hsp，如果没有就先创建，再指向

方式二

Sting str = new Integer("hsp");

现在堆中创建一个内存空间，里面维护value属性，指向常量池中的hsp。如果在常量池中没有hsp,先创建，再指向。主栈中的str指向堆中创建的内存空间。

intern（）

当调用intern()方法时，如果包含一个等于此String对象的字符串（用equal()确定），这返回池中字符串的地址。否则将String对象的字符串添加到常量池中，并返回常量池中引用。最终返回的都是常量池中的地址

String-->char[]

String str = "zzh";char[] chars = str.toCharArray();

String的compareTo()

public int compareTo(String anotherString) {        int len1 = value.length;        int len2 = anotherString.value.length;        int lim = Math.min(len1, len2);        char v1[] = value;        char v2[] = anotherString.value;        int k = 0;        while (k < lim) {            char c1 = v1[k];            char c2 = v2[k];            if (c1 != c2) {                return c1 - c2;            }            k++;        }        return len1 - len2;    }

练习题

String str = "a";str = "b"; //常量池中创建了两个对象：改变了str的指向

String a = "hello" + "abc";//创建一个对象：编译器进行了优化//等价于 String a = "helloabc";

String a = "hello";String b ="abc";String c = a + b;/*	1.先创建一个 StringBurder sb = new StringBurder();  空对象	2.执行 sb.append("hello");	3.sb.append("abc");	4.String c = sb.toString();	最后其实c指向的是堆中的(String)对象 value[],value[] ->池中"helloabc"*/

常量相加，看的是池。变量相加，看的是堆。

class Test{    String str = new String("hsp");    final char[] ch = {'j','a','v','a'};    public void change(String str,char[] ch){        str = "java";        ch[0] = 'h';    }}class Test3{    public static void main(String[] args) {        Test test = new Test();        test.change(test.str, test.ch);        System.out.print(test.str + " and ");        System.out.println(test.ch);    }}//只要有一个方法在栈中就会创建一个帧，当该方法用完，就会出栈//最后输出hsp and hava

内存图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZF7mmOrt-1632385272625)(D:\document\小林code\小林图片\字符串内出图.png)]

fromat()

• %s，%d，%.2f，%c 称为占位符，这些占位符有后面的变量替换
• %s 用字符串替换
• %d 用整数替换
• %.2f 用小数来替换，只会保留两位小数（四舍五入）
• %c 用char类型替换

StringBuffer

• StringBuffer的直接父类是AbstractStringBuilder
• StringBuffer实现了Serializable，既StringBuffer的对象可以串行话
• 在父类AbstractStringBuilder有一个属性 char[] value，不是final，该value数组存放字符串内容
• StringBuffer被final修饰，不能被继承

String和StringBuffer的区别

String保存的是字符串常量，里面的值不能修改，每次内容的更新，其实是引用变量指向一个新的引用变量，效率较低

StringBuffer保存的字符串的变量，里面的值可以更改，每次内容的更新，就是value[]数组内容的改变，效率较高

String-->StringBuffer

String str = "hello";//使用构造器  放回的是一个StringBuffer对象，对str本身没有影响StringBuffer sb = new StringBuffer(str);//使用append()StringBuffer sb1 = new StringBuffer();sb1 = sb1.append(str);

StringBuffer-->String

//使用StringBuffer提供的toString()StringBuffer sb2 = new StringBuffer();String str = sb2.toString();//使用构造器String str1 = new String(s)

练习

String str = null;StringBuilder sb = new StringBuilder();sb.append(str);System.out.println(sb.length());  //sb为null，输出4StringBuffer sb1 = new StringBuffer(str);System.out.println(sb1.length());//抛出空指针异常

StringBuffer中有insert(),经常用于插入字符串

StringBuilder

StringBuilder是StringBuffer的一个建议替换，存在线程安全问题，常用于单线程，速度比StringBuufer快

• StringBuilder 继承 AbstractStringBuffer类
• 实现了Serializable，可以实现串行化，在网络中传输
• StringBuilder是final类，不能被继承
• StringBuilder中存放字符序列的，依然是 AbstractStringBuffer类中 char[] value，因此字符序列在堆
• StringBuilder 的方法没有互斥处理，即没有synchronized关键字修饰，因此在单线程情况下使用

String，StringBuffer和StringBuilder的比较

• StringBuffer 和 StringBuilder 都代表可变字符序列，而且方法也一样
• String：不可变字符序列，效率低，但复用率高
• StringBuffer：可变字符序列，效率较高（增删），线程安全
• StringBuilder：可变字符序列，效率最高，线程不安全

结论：如果我们要对字符串进行大量修改，尽量不要使用String

Math

public static void main(String[] args) {	rand(1,10);}//生成[a,b]的随机数public static void rand(int a, int b){    for (int i = 0; i < 10; i++) {        int ran = (int)(Math.random()*(b-a+1)+a);        System.out.println(ran);    }}

Arrays方法

• toString()返回数组的字符串形式

  Arrays.toString(arr)
  

• sort排序（自然排序和定制排序）

  Arrays.sort(arr)Arrays.sort(arr, new Comparator<Integer>() {            @Override            public int compare(Integer o1, Integer o2) {                return o1 - o2;            }        });
  

• binarySearch 通过二分查找索引法进行查找，要求必须排序。

  • 如果存在就返会数字所在索引
  • 如果不存在就返回数字应该在数组中的索引+1，取负数 return -(low + 1)

• copyOf 数组的复制

  int[] newArr = Arrays.copyOf(arr,arr.length);int[] newArr = Arrays.copyOf(arr,arr.length + 1);//如果拷贝的长度 > arr.length 就在新数组中的后面，增加nullint[] newArr = Arrays.copyOf(arr,arr.length - 1);//如果拷贝的长度 < 0 就会抛出异常NegativeArraysSizeException
  

• fill()

  Arrays.fill(num,99);//使用99替换num数组的元素
  

• equals() 比较数组元素内容是否一致

  Arrays.equals(arr1,arr2)
  

• asList() 将数组转为List集合

  List list = Arrays.asList(arr);// 运行时类型java.util.Arrays#ArraysList   /Arrays类中的一个内部类
  

System类

• exit() ： 退出当前程序。参数一般为0，表示正常退出

• arryaycopy()：复制数组元素，比较适合底层调用。一般使用Arrays.copyOf() 来完成数组调用

  /*src – the source array.srcPos – starting position in the source array.dest – the destination array.destPos – starting position in the destination data.length – the number of array elements to be copied*/public static native void arraycopy(Object src,  int  srcPos,                                        Object dest, int destPos,                                        int length);
  

• currentTimeMillens()：放回当前时间距离1970-1-1的毫秒数

• gc(): 运行垃圾回收机制

大数据处理

BigInteger类

BigInteger bigInteger = new BigInteger("29999999999999999999");BigInteger bigInteger1 = new BigInteger("99999");//加法  ：参数类型和放回值都是BigIntegerBigInteger add = bigInteger.add(bigInteger1);//减法BigInteger subtract = bigInteger.subtract(bigInteger1);//乘法BigInteger multiply = bigInteger.multiply(bigInteger1);//除法BigInteger divide = bigInteger.divide(bigInteger1);

BigDecimal类

BigDecimal bigDecimal = new BigDecimal("19.99999999999999999297");BigDecimal bigDecimal1 = new BigDecimal("17");System.out.println(bigDecimal.divide(bigDecimal1));//Non-terminating decimal expansion;  这里肯会抛出异常//处理方法System.out.println(bigDecimal.divide(bigDecimal1, RoundingMode.CEILING));//保留小数位数和分子的小数位数相同

• BigInteger 适合保存比较大的整型
• BigDecimal 适合进度更高的浮点数

时间函数

Data类

public Date(long date) {        fastTime = date;}public Date() {        this(System.currentTimeMillis());}//获取当前系统时间        Date date = new Date();        //得到当前时间的毫秒数        System.out.println(date.getTime());        //设置日期输出的格式        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss");        System.out.println(simpleDateFormat.format(date));  //2021年09月07日 10:22:12        //字符串转为日期格式        Date parse = simpleDateFormat.parse("2021年09月07日 10:22:12");        System.out.println(simpleDateFormat.format(parse));

Calendar类

• Caldedar类是一个抽象类，并且构造器是是私有的

• 可以通过getInstance() 来获取对象实例

• 提供的大量的字段和方法

  Calendar instance = Calendar.getInstance();System.out.println(instance);
  

• Cladedar类在返回月时，是按照0开始编号

• 没有提供日期格式的方法，可以自由灵活的定义日期格式

第三代日期

class TestLocalDate{    public static void main(String[] args) {        LocalDateTime localDateTime = LocalDateTime.now();        System.out.println(localDateTime);        System.out.println(localDateTime.getYear());        System.out.println(localDateTime.getMonth());        System.out.println(localDateTime.getMonthValue());        System.out.println(localDateTime.getDayOfMonth());        System.out.println(localDateTime.getHour());        System.out.println(localDateTime.getMinute());        System.out.println(localDateTime.getSecond());        //只包含年月日        LocalDate localDate = LocalDate.now();        System.out.println(localDate.getYear());        //只包含时分秒        LocalTime localTime = LocalTime.now();        System.out.println(localTime.getHour());        //日期格式化        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 hh:mm:ss");        System.out.println(dateTimeFormatter.format(localDateTime));    }}class TestInstant{    public static void main(String[] args) {        //通过静态方法 now() 获取当前时间戳对象        Instant now = Instant.now();        System.out.println(now);        //通过from  把Instant转为Date        Date date = Date.from(now);        //通过date的toInstant() Date转为Instant        Instant instant = date.toInstant();    }}

集合

集合的优点：

• 可以动态保存任意类型的多个对象，使用比较方便
• 提供了一系列方便操作对象的方法：add，remove，set，get
• 代码简洁

集合主要分为：单例集合，双列集合

Collection（单列集合）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SllO7j4s-1632385272627)(D:\document\小林code\小林图片\Collection继承图.png)]

Iterator接口

• Iterator对象称为迭代器，主要用于遍历Collection集合中元素

• Collection接口继承了Iterator接口，所以每个实现了Collection的集合，都有一个iterator()方法，该方法放回一个Iterator对象，即放回一个迭代器

• Iterator 仅用于遍历集合，Iterator本身不存放对象

• hasnext()判断该是否有下一个元素

• next() ：指针移向下一个元素，并放回该元素。

• 使用Iterator遍历集合

  Iterator iterator = list.iterator();while (iterator.hasNext()) {	Object next = iterator.next();}/*	当退出while时，iterator迭代器，指向最后一个元素，如果想要再次遍历，需要重置*/iterator = list.iterator();
  

• 使用增强for遍历集合（可代替Iterator，简化版的迭代器）

  for (Object o : list) {	System.out.println(o);}
  

List

• List 集合中的元素有顺序（即添加顺序和输出顺序相同），且可重符

• List集合中每个元素都有器对应的顺序索引，及支持索引

  System.out.println(list.get(2));
  

• List 集合还可以使用普通for进行遍历

  for (int i = 0; i < list.size(); i++) {	System.out.println(list.get(i));}
  

ArrayList

• ArrayList 可以存放空，且可以存放多个
• ArrayList 底层使用数组实现的
• ArrayList 基本等同于 Vector，ArrayList的线程不安全（执行效率高），在多线程情况下，不建议使用ArrayList

源码分析

• ArrayList中维护的是一个Object[] elementData

  transient Object[] elementData;
  

• 创建ArrayList对象是，使用无参构造器，初始容量为0，第一次添加时扩容为10，如以后还需要扩容，则扩容为原来的1.5倍

  public ArrayList() {        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;    }
  

• 使用有参构造器，可以指定ArrayList的初始容量，以后需要扩容时，扩容为原来的1.5倍

  public ArrayList(int initialCapacity) {        if (initialCapacity > 0) {            this.elementData = new Object[initialCapacity];        } else if (initialCapacity == 0) {            this.elementData = EMPTY_ELEMENTDATA;        } else {            throw new IllegalArgumentException("Illegal Capacity: "+                                               initialCapacity);        }    }
  

• 扩容机制

  public boolean add(E e) {        ensureCapacityInternal(size + 1);  // Increments modCount!!        elementData[size++] = e;        return true;    }private void ensureCapacityInternal(int minCapacity) {        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));    }    private static int calculateCapacity(Object[] elementData, int minCapacity) {        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {            return Math.max(DEFAULT_CAPACITY, minCapacity);        }        return minCapacity;    }    private void ensureExplicitCapacity(int minCapacity) {        modCount++;        // overflow-conscious code        if (minCapacity - elementData.length > 0)            grow(minCapacity);    }    private void grow(int minCapacity) {        // overflow-conscious code        int oldCapacity = elementData.length;        int newCapacity = oldCapacity + (oldCapacity >> 1);        if (newCapacity - minCapacity < 0)            newCapacity = minCapacity;        if (newCapacity - MAX_ARRAY_SIZE > 0)            newCapacity = hugeCapacity(minCapacity);        // minCapacity is usually close to size, so this is a win:        elementData = Arrays.copyOf(elementData, newCapacity);    }
  

Vector

public class Vector<E>extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, java.io.Serializable

• 底层是一个Object对象数组

  protected Object[] elementData;
  

• Vector是线程安全的，Vector类的操作方法都带有synchronized关键字

LinkedList

• 底层实现了双向链表和双端队列

• 可以添加任何元素，包括null

• 第一个节点的prev = null，最后一个节点的next = null

• 线程不安全

• 常用方法：

  LinkedList linkedList = new LinkedList();linkedList.add(999);linkedList.remove();linkedList.get(1);linkedList.set(0,999);
  

Set

• 无序（添加和取出的顺序不一致），没有索引，所以不能使用普通for遍历
• 不允许有重复元素，所以最多只包含一个null
• 输出的顺序虽然不是添加的顺序，但输出的顺序是固定的

HashSet

• HashSet底层其实是HashMap

  public HashSet() {        map = new HashMap<>();    }
  

源码分析

• 在HashSet的底层有一个HashMap对象private transient HashMap map;

• 成员变量，private static final Object PRESENT = new Object();，该成员变量的作用就是为了HashSet可以使用HashMap，而占位用的

• /*The table, initialized on first use, and resized as necessary. When allocated, length is always a power of two. (We also tolerate length zero in some operations to allow bootstrapping mechanics that are currently not needed.)表，在第一次使用时初始化，并根据需要调整大小。 分配时，长度始终是 2 的幂。 （我们还在某些操作中容忍长度为零，以允许当前不需要的引导机制。）*/transient Node<K,V>[] table;
  

---

putVal()源码分析

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,                   boolean evict) {        Node<K,V>[] tab; Node<K,V> p; int n, i;  //定义了辅助变量    	//table 就是 transient Node[] table;    	//if表示如果当前table 是 null 或容量为0.就进行第一次扩容，容量大小为16        if ((tab = table) == null || (n = tab.length) == 0)            n = (tab = resize()).length;    	/*根据hash值类确定元素应存放在table的那个位置，并把这个位置的地址赋值给p，判断p是否为空    	  如果为空，就表明该位置还没有存放元素，就创建一个节点，这里把hash值也传了进去，用于下一次存		   放元素时，进行比较是否相同    	    	*/        if ((p = tab[i = (n - 1) & hash]) == null)            tab[i] = newNode(hash, key, value, null);    	//当table表中索引位置已经有元素存在，就进入到else块中        else {            Node e; K k;            /*              该对象的hash值和该索引位置的第一个对象的hash值相同&&              (引用变量key相同 || 内容相同）            */            if (p.hash == hash &&                ((k = p.key) == key || (key != null && key.equals(k))))                e = p;            else if (p instanceof TreeNode)                e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);            else {                //这里会让要添加的元素和当前索引下的元素依次进行比较                for (int binCount = 0; ; ++binCount) {                    //如果没有相同的元素，将元素添加进去，退出循环                    if ((e = p.next) == null) {                        p.next = newNode(hash, key, value, null);                        /*                        再把元素添加到链表后，就立即判断是否达到了8个节点，如果达到就调用                        treeifyBin(tab, hash);将链表转换为一个红黑树。                        在treeifyBin(tab, hash)中,还要进行判断：                        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)            				resize();            			即table的长度小于64时，先要对table进行扩容                        */                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st                            treeifyBin(tab, hash);                        break;                    }                    //如果发现有相同的元素，直接退出循环                    if (e.hash == hash &&                        ((k = e.key) == key || (key != null && key.equals(k))))                        break;                    //移向下一个元素，继续进行比较                    p = e;                }            }            //存在相同的key，ji            if (e != null) { // existing mapping for key                V oldValue = e.value;                if (!onlyIfAbsent || oldValue == null)                    e.value = value;                afterNodeAccess(e);                return oldValue;            }        }        ++modCount;        if (++size > threshold)            resize();        afterNodeInsertion(evict);        return null;    }//最后返回的结果如果为null，就代表添加元素成功，否则，添加失败

• resize()源码分析

  final Node<K,V>[] resize() {        Node<K,V>[] oldTab = table;        int oldCap = (oldTab == null) ? 0 : oldTab.length;        int oldThr = threshold;  //临界值：表示当数组的内容个数达到该值，就要扩容        int newCap, newThr = 0;        if (oldCap > 0) {            if (oldCap >= MAXIMUM_CAPACITY) {                threshold = Integer.MAX_VALUE;                return oldTab;            }            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&                     oldCap >= DEFAULT_INITIAL_CAPACITY)                newThr = oldThr << 1; // double threshold        }        else if (oldThr > 0) // initial capacity was placed in threshold            newCap = oldThr;        else {               // zero initial threshold signifies using defaults            //static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;  默认容量大小16            newCap = DEFAULT_INITIAL_CAPACITY;            //static final float DEFAULT_LOAD_FACTOR = 0.75f;   装载因子            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);        }        if (newThr == 0) {            float ft = (float)newCap * loadFactor;            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?                      (int)ft : Integer.MAX_VALUE);        }        threshold = newThr;        @SuppressWarnings({"rawtypes","unchecked"})        Node[] newTab = (Node[])new Node[newCap];        table = newTab;        if (oldTab != null) {            for (int j = 0; j < oldCap; ++j) {                Node e;                if ((e = oldTab[j]) != null) {                    oldTab[j] = null;                    if (e.next == null)                        newTab[e.hash & (newCap - 1)] = e;                    else if (e instanceof TreeNode)                        ((TreeNode)e).split(this, newTab, j, oldCap);                    else { // preserve order                        Node loHead = null, loTail = null;                        Node hiHead = null, hiTail = null;                        Node next;                        do {                            next = e.next;                            if ((e.hash & oldCap) == 0) {                                if (loTail == null)                                    loHead = e;                                else                                    loTail.next = e;                                loTail = e;                            }                            else {                                if (hiTail == null)                                    hiHead = e;                                else                                    hiTail.next = e;                                hiTail = e;                            }                        } while ((e = next) != null);                        if (loTail != null) {                            loTail.next = null;                            newTab[j] = loHead;                        }                        if (hiTail != null) {                            hiTail.next = null;                            newTab[j + oldCap] = hiHead;                        }                    }                }            }        }        return newTab;    }
  

• HashSet底层第一次添加元素时，table数组扩容为16，临界值为16*0.75=12

• 如果数组中的元素个数（不管该元素加在哪里，只要加入到HashSet中就算）到达了临界值，就会扩容为原来的2倍

• 当一条链表的个数达到8，并且table的容量>=64时，才会将链表转换为红黑树。如果一条链表的个数达到了8，但table容量<64，会对table进行扩容，扩容还是按照扩容到原来的二倍。

LinkedHashSet

• LinkedHashSet是HashSet的一个子类

• LinkedHashSet底层是一个LinkedHashMap，维护一个数组（table） + 双向链表

• LinkedHashSet根据元素的hash值来决定元素存储的位置，同时使用链表维护元素的顺序，这使元素看起来是以插入顺序保存的

• LinkedHashSet不允许有重复元素

• 第一次添加元素时，直接将数组table的容量扩容到16，存放的节点类型是：LinkedHash’Map$Entry

• 数组table是 HashMap$Node[]，存放的元素是 LinkedHashMap$Entry类型

  //Entry 是在LinkedHashMap中的一个静态内部类static class Entry extends HashMap.Node {        Entry before, after;        Entry(int hash, K key, V value, Node next) {            super(hash, key, value, next);        }    }
  

Map

• Map用于保存具有映射关系的数据：Key–Value（双列元素）

• Map中的Key和Value可以是任何引用类型的数据，会封装到HashMap$Node 对象中

  transient Node<K,V>[] table;
  

• Map中的可以不允许重复，原因和HashSet一样。当有相同的key是，就会替换原来的Value

• Map中Value是可以重复的

• Map中的Key可以为null，Value也可以为null，当Key为空只能有一个，Value为空可以有多个

• 常用String类做Key值

• 我们总能通过Key找到对应的Value

• HashMap没有首先线程同步，所以线程是不安全的

Key—Value的存放机制

• k-v首先是存放在一个Node中

  //HashMap中的静态内部类 static class Node implements Map.Entry {        final int hash;        final K key;        V value;        Node next;        Node(int hash, K key, V value, Node next) {            this.hash = hash;            this.key = key;            this.value = value;            this.next = next;        }
  

• 通过newNod()返回以Node对象

  Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {        return new Node<>(hash, key, value, next);    }
  

• 放入table数组中

  tab[i] = newNode(hash, key, value, null);
  

• k-v 为了方便程序员的遍历，还会创建entrySet的Set集合，该集合存放的元素类型 Entry

  //HashMap中的一个静态内部类final class EntrySet extends AbstractSet>//Map接口中内部接口interface Entry;//HashMap中成员transient Set> entrySet;//HashMap中方法public Set> entrySet() {        Set> es;        return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;    }
  

• entrySet中定义类型是Map.Entry，但实际存放的还是 HashMap$Node

  static class Node<K,V> implements Map.Entry<K,V>
  

• 当把 HashMap$Node对象存放到entrySet中就会方便我们遍历，因为Map.Entry提供了重要的方法

  K getKey();V getValue();
  

• 需要注意的是：在entrySet只是指向了Node，并没有真正的存放数据

• 我们还可以得到Key和Value的Set集合

  Set set = hashMap.keySet();  //运行时类型：class java.util.HashMap$KeySetCollection values = hashMap.values();  //运行时类型:class java.util.HashMap$Values
  

  final class KeySet extends AbstractSet<K>final class Values extends AbstractCollection<V>
  

Map中的常用方法

HashMap hashMap = new HashMap();hashMap.put("zzh","guogai");hashMap.get("zzh");hashMap.size();hashMap.isEmpty();hashMap.containsKey("zzh");hashMap.containsValue("guogai");hashMap.remove("zzh");hashMap.clear();

Map的遍历方式

• 使用EntrySet（HashMap的内部类） 获取k-v

Set entrySet = hashMap.entrySet();System.out.println(entrySet.getClass());  //class java.util.HashMap$EntrySetfor (Object entry : entrySet) {    Map.Entry m = (Map.Entry) entry;    System.out.println(m.getKey()+" - "+m.getValue());}

• 使用keySet，获取k-v

Set keySet = hashMap.keySet();for (Object key :keySet ) {	System.out.println(key + " - " + hashMap.get(key));}Iterator iterator = keySet.iterator();while (iterator.hasNext()) {    Object next = iterator.next();    System.out.println(next + " - "+ hashMap.get(next));}

只获取value值

• 使用values获取

Collection values = hashMap.values();for (Object value : values) {	System.out.println(value);}Iterator iterator1 = values.iterator();while (iterator1.hasNext()) {    Object next =  iterator1.next();    System.out.println(next);}

HashMap

• hashMap底层维护一个Node类型的数组table，默认为null
• 当创建对象时，将加载因子（loadfactor）初始化为0.75
• 当添加key–value时，通过key的hash值来确定在table中的索引。然后判断该索引处是否有元素，如果没有，则直接添加进去。如果索引处有元素，就判断key值是否重复，如果重复就替换掉原来的value值，没有重复就添加元素
• 第一次添加需要扩容到16，临界值为12
• 当添加的元素个数达到临界值，在需要扩容时，就扩容为原来的两倍
• 在java8中，如果一条链表的元素个数超过8个，并且table的容量>=64，就会将链表转为红黑树

Hashtable

• 存放的元素时键值对：k–v

• Hashtable的键值不能为null，否则或抛出空指针异常

• Hashtable的使用方法，基本和HashMap一样

• Hashtable是线程安全的（synchronized），HashMap是线程不安全的

  public class Hashtable<K,V>    extends Dictionary<K,V>    implements Map<K,V>, Cloneable, java.io.Serializable
  

• 底层有一个数组 private transient Entry[] table;初始容量：11，加载因子：0.75，临界值：8

• 扩容机制

  int newCapacity = (oldCapacity << 1) + 1;
  

Properties

• Properties 继承了 Hashtable，具有Hashtable的特点

• Properties 主要用于读取配置文件

• 常用方法

  Properties properties = new Properties();properties.put("1","zzh");properties.put("2","锅盖");System.out.println(properties.get("1"));properties.remove("1");properties.put("2","guogai");System.out.println(properties);
  

TreeSet

• 底层是TreeMap

• 构造器可传入一个比较器对象，赋值给TreeSet底层TreeMap的属性this.comparator

• 底层比较的执行机制

  Comparator<? super K> cpr = comparator;        if (cpr != null) {            do {                parent = t;                cmp = cpr.compare(key, t.key);                if (cmp < 0)                    t = t.left;                else if (cmp > 0)                    t = t.right;                else                    return t.setValue(value);            } while (t != null);        }
  

• 从底层的代码可以知道：当compareTo()放回0时，就认为这两个数据相同，就不会加入到TreeSet中了

TreeMap

• 底层维护一个private transient Entry root;

• 采用红黑树的数据结构

  static final class Entry<K,V> implements Map.Entry<K,V> {        K key;        V value;        Entry<K,V> left;        Entry<K,V> right;        Entry<K,V> parent;        boolean color = BLACK;        /**         * Make a new cell with given key, value, and parent, and with         * {@code null} child links, and BLACK color.         */        Entry(K key, V value, Entry<K,V> parent) {            this.key = key;            this.value = value;            this.parent = parent;        }
  

• 添加元素机制

  public V put(K key, V value) {        Entry<K,V> t = root;    	//第一次添加元素，直接将元素挂在root上去        if (t == null) {            //这里调compare方法是为了检查第一次传经来的值是否为null，如果为            compare(key, key); // type (and possibly null) check            root = new Entry<>(key, value, null);            size = 1;            modCount++;            return null;        }        int cmp;        Entry parent;        // split comparator and comparable paths        Comparator cpr = comparator;    	//通过循环来确定要加入元素在树中的位置        if (cpr != null) {            do {                parent = t;                cmp = cpr.compare(key, t.key);                if (cmp < 0)                    t = t.left;                else if (cmp > 0)                    t = t.right;                else                    //如果通过compareTO()比较有相同的key值，会发生替换                    return t.setValue(value);            } while (t != null);        }        else {            if (key == null)                throw new NullPointerException();            @SuppressWarnings("unchecked")                Comparable k = (Comparable) key;            do {                parent = t;                cmp = k.compareTo(t.key);                if (cmp < 0)                    t = t.left;                else if (cmp > 0)                    t = t.right;                else                    return t.setValue(value);            } while (t != null);        }        Entry e = new Entry<>(key, value, parent);        if (cmp < 0)            parent.left = e;        else            parent.right = e;        fixAfterInsertion(e);        size++;        modCount++;        return null;    }
  

• 如果通过compareTO()比较有相同的key值，会发生替换

如何选择集合实现类

1. 先判断存储的类型（单列还是双列）
2. 单列：Collection接口
   • 允许重复：List
     • 增删多：LinkedList（底层维护一个双向链表）
     • 改查多：ArrayList（底层维护一个数组）
   • 不允许重复：Set
     • 无序：HashSet（底层是HashMap，维护一个哈希表：数组+链表+红黑树）
     • 排序：TreeSet（）
     • 插入顺序和取出顺序一致：LinkedHashSet（维护数组+双向链表）
3. 双列：Map
   • 键无序：HashMap
   • 键排序：TreeMap
   • 键插入顺序和取出顺序一致：LinkedHashMap
   • 读取文件：Properties

Collections工具类

ArrayList arrayList = new ArrayList();        arrayList.add("zzh");        arrayList.add("erha");        arrayList.add("guogai");        arrayList.add("yuanfang");        //反转list        Collections.reverse(arrayList);        //随机排序        Collections.shuffle(arrayList);        //按照自然排序        Collections.sort(arrayList);        //指定排序规则排序        Collections.sort(arrayList, new Comparator