9.3JDk内置的基本注解类型

基本介绍：

注解(Annotation)也被称为元数据(Metadata)，用于修饰解释包,类、方法、属性、构造器、局部变量等数据信息
和注释一样，注解不影响程序逻辑，但注解可以被编译或运行，相当于嵌入在代码中的补充信息
在JavaSE中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等。在JavaEE中注解占据了更重要的角色，例如用来配置应用程序的任何切面，代替java EE旧版本中所有遗留的繁冗代码和XML配置

基本Annotation介绍：

@Override：限定某个方法，是重写父类方法，该注解只能用于方法
@Deprecated：用于表示某个程序元素(类，方法等)己过时
@SuppressWarnings：抑制编译器警告

9.3.1@Override

基本介绍：

@Override 表示指定重写父类的方法(从编译层面验证)，如果父类没有方法，则会报错
如果没写 @Override 还是会重写父类
@Override 只能修饰方法，不能修饰其它类，包，属性等等
如果写了@Override 注解，编译器就会去检查该方法是否真的重写了父类的方法，若果没有构成重写则编译错误
查看@Override注解源码@Target(ElementType.MRTHOD)，说明只能修饰方法
@Target 是修饰注解的注解，称为元注解

9.3.2@Deprecated

基本介绍：

用于表示某个程序元素(类，方法等)己过时
可以修饰方法，类，字段，包，参数等等
@Target (value=(CONSTRUCTOR,FIELD,LOCAL_ VARIABLE, METHOD,PACKAGE, PARAMETER, TYPE})
@Deprecated 的作用可以做到新旧版本的兼容和过渡

9.3.3@SuppressWarnings

基本介绍：

抑制编译器警告信息
unchecked 是忽略没有检查的警告
rawtypes 是忽略没有指定泛型的警告
unused 是忽略没有使用某个变量的警告错误
@SuppressWarnings可以修饰的程序元素为，查看@Target
生成@SupperssWarnings 时，不用背，直接点击左侧的黄色提示，就可以选择(注意可以指定生成的位置)

9.4元注解：对注解进行注解

JDK 的元 Annotation 用于修饰其他 Annotation

基本介绍：

四种元注解：

Retention：指定注解的作用范围，三种 SOURCE,CLASS,RUNTIME
Target：指定注解可以在哪些地方使用
Documented：指定该注解是否会在javadoc体现
lnherited：子类会继承父类注解

10 异常

Java语言中，将程序执行中发生的不正常情况称为 “异常”

基本介绍：

执行中异常事件分类：

Error(错误)：Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情況。比如：StackoverflowError[栈溢出]和OOM(out ofmemory)，Error 是严重错误，程序会崩溃
Exception：其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。，例如空指针访问，
试图读取不存在的文件，网络连接中断等等，Exception 分为两大类：运行时异常口和编译时异常口。

10.1异常体系图⭐️

网络异常，图片无法展示
|

异常体系图：

注意事项和细节：

异常分为两大类，运行时异常和编译时异常
运行时异常，编译器不要求强制处置的异常。一般是指编程时的逻辑错误，是程序员应该避免其出现的异常。java.lang.RuntimeException类及它的子类都是运行时异常
运行时异常，可以不作处理，因为这类异常很普遍，若全处理可能会对程序的可读性和运行效率产生影响
编译时异常，是编译器要求必须处置的异常

10.2常见的异常

运行时异常：

NullPointerException：空指针异常
ArithmeticException：数学运算异常
ArrayIndexOutOfBoundsException：数组下标越界异常
ClassCastException：类型转换异常
NumberFormatException：数字格式不正确异常

编译时异常：

SQLException：操作数据库时，查询表可能发生异常
lOException：操作文供时，发生的异常
FileNotFoundException：当操作一个不存在的文件时，发生异常
ClassNotFoundException：加载类，而该类不存在时异常
EOFException：操作文件，到文件末尾，发生异常
illegalArguementException：参数异常

10.3异常处理⭐️

异常处理就是当异常发生时，对异常处理的方式

基本介绍：

10.3.1 try-catch-finally

程序员在代码中捕获发生的异常，自行处理

基本介绍：

网络异常，图片无法展示
|

流程图：

注意事项和细节：

如果异常发生了，则异常发生后面的代码不会执行，直接进入到catch块
如果异常没有发生，则顺序执行try的代码块，不会进入到catch块
如果希望不管是否发生异常，都执行某段代码(比如关闭连接，释放资源等)，则使用如下代码-finally{}
可以有多个catch语句，捕获不同的异常(进行不同的业务处理)，要求父类异常在后，子类异常在前，比如(Exception 在后，NullPointer Exception 在前)，如果发生异常，只会匹配一个catch
try-finally配合，相当于没有捕获异常，程序直接崩溃但执行finally

10.3.2 throws

将发生的异常抛出，交给调用者(方法)来处理，最顶级的处理者就是JVM，默认抛出运行异常

基本介绍：

网络异常，图片无法展示
|

流程图：

注意事项和细节：

对于编译异常，程序中必须处理，比如try-catch 或者 throws
对于运行时异常，程序中如果没有处理，默认就是throws的方式处理
子类重写父类的方法时，对抛出异常的规定：子类重与的方法，所抛出的异常类型要么和父类抛出的异常一致，要么为父类拋出的异常的类型的子类型
在throws 过程中，如果有方法 try-catch，就相当于处理异常，就可以不必throws
在方法声明中用throws语句可以声明抛出异常的列表，throws后面的异常类型可以是方法中产生的异常类型，也可以是它的父类

10.4自定义异常

当程序中出现了某些 “错误〞，但该错误信息并没有在Throwable子类中描述处理，这时可以设计异常类，用于描达该错误信息

基本介绍：

自定义异常步骤：

定义类：自定义异常类名(程序员自己写)继承Exception或Runtime Exception
如果继承Exception，属于编译异常
如果继承RuntimeException，属子运行异常(一般来说，继承RuntimeException)

10.5 throw和throws

网络异常，图片无法展示
|

对比：

11 包装类

11.0包装类(Integer例)

八种基本数据类型相应的引用类型——包装类

网络异常，图片无法展示
|

网络异常，图片无法展示
|

网络异常，图片无法展示
|

网络异常，图片无法展示
|

基本介绍：

装箱和拆箱：

public class Integer01 {
    public static void main(String[] args) {
        //演示int <--> Integer 的装箱和拆箱
        //jdk5前是手动装箱和拆箱
        //手动装箱 int->Integer
        int n1 = 100;
        Integer integer = new Integer(n1);
        Integer integer1 = Integer.valueOf(n1);
        //手动拆箱
        //Integer -> int
        int i = integer.intValue();
        //jdk5后，就可以自动装箱和自动拆箱
        int n2 = 200;
        //自动装箱 int->Integer
        Integer integer2 = n2; //底层使用的是 Integer.valueOf(n2)
        //自动拆箱 Integer->int
        int n3 = integer2; //底层仍然使用的是 intValue()方法
    }
}

包装类方法：

public class WrapperVSString {
    public static void main(String[] args) {
        //包装类(Integer)->String
        Integer i = 100;//自动装箱
        //方式1
        String str1 = i + "";
        //方式2
        String str2 = i.toString();
        //方式3
        String str3 = String.valueOf(i);
        //String -> 包装类(Integer)
        String str4 = "12345";
        Integer i2 = Integer.parseInt(str4);//使用到自动装箱
        Integer i3 = new Integer(str4);//构造器
        System.out.println("ok~~");
    }
}
• 
Integer创建机制：
public class WrapperExercise03 {
    public static void main(String[] args) {
        //示例一
        Integer i1 = new Integer(127);
        Integer i2 = new Integer(127);
        System.out.println(i1 == i2);//F
//示例二
        Integer i3 = new Integer(128);
        Integer i4 = new Integer(128);
        System.out.println(i3 == i4);//F
//示例三
        Integer i5 = 127;//底层Integer.valueOf(127)
        Integer i6 = 127;//-128~127
        System.out.println(i5 == i6); //T
//示例四
        Integer i7 = 128;
        Integer i8 = 128;
        System.out.println(i7 == i8);//F
//示例五
        Integer i9 = 127; //Integer.valueOf(127)
        Integer i10 = new Integer(127);
        System.out.println(i9 == i10);//F
        //示例六
        Integer i11=127;
        int i12=127;
//只有有基本数据类型，判断的是
//值是否相同
        System.out.println(i11==i12); //T
//示例七
        Integer i13=128;
        int i14=128;
        System.out.println(i13==i14);//T
    }
}

11.1 String⭐️

基本介绍：

String 对象用于保存字符串，也就是一组字符序列
字符串常量对象是用双引号括起的字符序列
宇符串的宇符使用Unicode宇符编码，一个字符(不区分字母还是汉字)占两个字节

网络异常，图片无法展示

创建String对象方式：

直接赋值 String s = "hsp";
调用构造器 String s2 = new String("hsp");

两种方式对比：

方式一：先从常量池查看是否有”hsp”数据空间，如果有，直接指向；
如果沒有则重新创建，然后植自。s最终指向的是常量池的空间地址
方式二：先在堆中创建空间，里面维护了value属性，指向常量池的hsp空间。如果常量池没有"hsp’，重新创建，如果有，直接通过value指向，最终指向的是堆中的空间地址

网络异常，图片无法展示

常用构造方法：

String s1 = new String();
String s2 = new String (String original);
String s3 = new String (char[] a);
String s4 = new String (char[] a,int startIndex,int count);

注意事项和细节：

String 是 final类，不能被继承
string 有属性 private final char valve []; 用于存放字符串内容
value 是一个final类型，不可以修改(值可以修改，地址不可修改)
intern方法：返回常量池的地址对象

特性：

相等特性：

equals判断内容
==判断地址

字符串特性：

String c1 =“ab”+"cd”;常量在池中相加
String c1 = a + b;变量在堆中相加

public class StringExercise03 {
    public static void main(String[] args) {
        String a = "hsp"; //a 指向 常量池的 “hsp”
        String b =new String("hsp");//b 指向堆中对象
        System.out.println(a.equals(b)); //T
        System.out.println(a==b); //F
        //b.intern() 方法返回常量池地址
        System.out.println(a==b.intern()); //T //ntern方法：返回常量池的地址对象
        System.out.println(b==b.intern()); //F
    }
}

String s1 = "hello";
s1 = "haha";
//创建了两个对象，s1指向“hello”，
//再在常量池中创建“haha”，s1指向"haha“
public class StringExercise09 {
    public static void main(String[] args) {
        String s1 = "hspedu";  //s1 指向池中的 “hspedu”
        String s2 = "java"; // s2 指向池中的 “java”
        String s5 = "hspedujava"; //s5 指向池中的 “hspedujava”
        String s6 = (s1 + s2).intern();//s6 指向池中的   “hspedujava”
        System.out.println(s5 == s6); //T
        System.out.println(s5.equals(s6));//T
    }
}

综合训练

常用方法：

equals：区分大小写，判断内容是否相等
equalslgnoreCase：忽略大小写的判断内容是否相等
length：获取字符的个数，字符串的长度
indexOf：获取字符在字符串中第1次出现的索引,索引从0开始，如果找不到,返回-1
lastlndexOf：获取宇符在字符串中最后1次出现的索引,索引从0开始，如找不到,返回-1
substring：截取指定范围的子串
trim：去前后空格
charAt：获取某索引处的字符，注意不能使用Str[index]这种方式
toUpperCase：大写字母
toLowerCase：小写字母
concat：拼接
replace：替换字符串中的字符
split：分割字符串
compareTo：比较两个字符串的大小
toCharArray：转换成字符数组
format：格式字符串

//1. equals 前面已经讲过了. 比较内容是否相同，区分大小写
        String str1 = "hello";
        String str2 = "Hello";
        System.out.println(str1.equals(str2));//
        // 2.equalsIgnoreCase 忽略大小写的判断内容是否相等
        String username = "johN";
        if ("john".equalsIgnoreCase(username)) {
            System.out.println("Success!");
        } else {
            System.out.println("Failure!");
        }
        // 3.length 获取字符的个数，字符串的长度
        System.out.println("韩顺平".length());
        // 4.indexOf 获取字符在字符串对象中第一次出现的索引，索引从0开始，如果找不到，返回-1
        String s1 = "wer@terwe@g";
        int index = s1.indexOf('@');
        System.out.println(index);// 3
        System.out.println("weIndex=" + s1.indexOf("we"));//0
        // 5.lastIndexOf 获取字符在字符串中最后一次出现的索引，索引从0开始，如果找不到，返回-1
        s1 = "wer@terwe@g@";
        index = s1.lastIndexOf('@');
        System.out.println(index);//11
        System.out.println("ter的位置=" + s1.lastIndexOf("ter"));//4
        // 6.substring 截取指定范围的子串
        String name = "hello,张三";
        //下面name.substring(6) 从索引6开始截取后面所有的内容
        System.out.println(name.substring(6));//截取后面的字符
        //name.substring(0,5)表示从索引0开始截取，截取到索引 5-1=4位置
        System.out.println(name.substring(2,5));//llo

11.2 StringBuffer⭐️

基本介绍：

java.lang.StringBuffer代表可变的字符序列，可以对字符串内容进行增删。
很多方法与String相同，但StringBuffer是可变长度的。
String Buffer是一个容器。

注意事项和细节：

StringBuffer 的直接父类是 AbstractstringBuilder
StringBuffer 实现了 Serializable，即StringBuffer的对象可以串行化
在父类中 AbstractstringBuilder 有属性 char[] valve,不是final，该 valve 数组存放宁符串内容，引出存放在堆中的
StringBuffer 是一个final类，不能被继承
StringBuffer 字符内容存在 char[] value，所以在变化〔增加/删除)不用每次都更换地址(即不是每次创建新对象)

String和StringBuffer对比：

String保存的是宇符串常量，里面的值不能更改，每次String类的更新实际上就是更改地址
StringBuffer保存的是字符串变量，里面的值可以更改，不用更新地址，效率高

构造器：

//1. 创建一个 大小为 16的 char[] ,用于存放字符内容
StringBuffer stringBuffer = new StringBuffer();
//2 通过构造器指定 char[] 大小
StringBuffer stringBuffer1 = new StringBuffer(100);
//3. 通过 给一个String 创建 StringBuffer, char[] 大小就是 str.length() + 16
StringBuffer hello = new StringBuffer("hello");

String和StringBuffer转换：

// String——>StringBuffer
String str = "hello tom";
//方式1 使用构造器
//注意： 返回的才是StringBuffer对象，对str 本身没有影响
StringBuffer stringBuffer = new StringBuffer(str);
//方式2 使用的是append方法
StringBuffer stringBuffer1 = new StringBuffer();
stringBuffer1 = stringBuffer1.append(str);
// StringBuffer ->String
StringBuffer stringBuffer3 = new StringBuffer("韩顺平教育");
//方式1 使用StringBuffer提供的 toString方法
String s = stringBuffer3.toString();
//方式2: 使用构造器来搞定
String s1 = new String(stringBuffer3);

常用方法：

增：append
删：delete(start,end)
改：replace (start,end,string)
查：indexOf
插：insert
获取长度：length

StringBuffer s = new StringBuffer("hello");
//增
s.append(',');// "hello,"
s.append("张三丰");//"hello,张三丰"
s.append("赵敏").append(100).append(true).append(10.5);//"hello,张三丰赵敏100true10.5"
System.out.println(s);//"hello,张三丰赵敏100true10.5"
//删
/*
* 删除索引为>=start && <end 处的字符
* : 删除 11~14的字符 [11, 14)
*/
s.delete(11, 14);
System.out.println(s);//"hello,张三丰赵敏true10.5"
//改
//，使用 周芷若 替换 索引9-11的字符 [9,11)
s.replace(9, 11, "周芷若");
System.out.println(s);//"hello,张三丰周芷若true10.5"
//查找指定的子串在字符串第一次出现的索引，如果找不到返回-1
int indexOf = s.indexOf("张三丰");
System.out.println(indexOf);//6
//插
//，在索引为9的位置插入 "赵敏",原来索引为9的内容自动后移
s.insert(9, "赵敏");
System.out.println(s);//"hello,张三丰赵敏周芷若true10.5"
//长度
System.out.println(s.length());//22
System.out.println(s);

11.3 StringBulider⭐️

基本介绍：

一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步，
该类被设计用作 String Buffer 的个简易替换，用在字符串缓冲区被单个线程使用的时候
如果可能，建议优先采用该类，因为在大多数实现中，它比StringBuffer 快
在 StringBuilder 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据

注意事项和细节：

StringBuilder 继承 AbstractstringBuilder 类
实现了 Serializable，说明StringBuilder对象是可以串行化(对象可以网络传输，可以保存到文件)
StringBuilder 是final类，不能被继承
StringBuitder对象字符序列仍然足存放在其父类 AbstractstringBuilder的 char [I valve;因此，字符序列是堆中
StringBoilder 的方法，没有做互斥的处理，即没有synchronized 关键字，网此在单线程的情況下使用

常用方法：

和StringBuffer相同

三类对比：

String：不可变字符序列，效率低,但是复用率高
StringBuffer：可变字符序列，效率较高(增删)，线程安全
String Builder：可变字符序列、效率最高、线程不安全
StringBuilder 和 StringBuffer 非常类似，均代表可变的字符序列，且方法相同
String使用注意说明：string s="a”;//创建了一个字符串s+="b";1/实际上原来的"a"字符串对象已经丢奔了，现在又产生了一个字符串S+"b”(也就是”ab")。如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。如果这样的操作放到循环中，会极大影响程序的性能

三类选择：

如果宇符串存在大量的修改操作，一般使用 StringBuffer 或StringBuilder
如果字符串存在大量的修改操作，并在单线程的情況，使用 StringBuilder
如果字符串存在大量的修改操作，并在多线程的情况，使用 String Buffer
如果我们字符串很少修改，被多个对象引用，使用String

11.4 Math

Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数，均为静态方法

基本介绍：

常用方法：

abs：绝对值
pow：求幂
ceil：向上取整
floor：向下取整
round：四舍五入
sqrt：求开方
random：求随机数
max：求两个数的最大值
min：求两个数的最小值

11.5 Date、Calenda、LocalDate

11.5.1 Date

常用方法：

Date：精确到毫秒，代表特定时间
Simple Date Format：格式和解析日期的类SimpleDateFormat 格式化和解析日期的具体类
它允许进行格式化（日期一＞文本）解析（文本-＞日期）和规范化

11.5.2 Calenda

是一个抽象类，并且构造器是private，可以通过 getInstance()来获得实例，提供大量的方法和字段

基本介绍：

常用方法：

getInstance()：获取实例
get.XXXX：获取字段

11.5.3 LocalDate

常用方法：

LocalDateTime ldt = LocalDateTime.now()：获取时间
get.Xxxx()：获取字段
DateTimeFormatter.format()：格式化
DateTimeFormatter.ofPattern()：定制格式化
Date date = Date.from(instant);：Instant转换Date
Instant instant = date.tolnstant();：Date转换Instant

//1. 使用now() 返回表示当前日期时间的 对象
LocalDateTime ldt = LocalDateTime.now(); //LocalDate.now();//LocalTime.now()
System.out.println(ldt);
//2. 使用DateTimeFormatter 对象来进行格式化
// 创建 DateTimeFormatter对象
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String format = dateTimeFormatter.format(ldt);
System.out.println("格式化的日期=" + format);
System.out.println("年=" + ldt.getYear());
System.out.println("月=" + ldt.getMonth());
System.out.println("月=" + ldt.getMonthValue());
System.out.println("日=" + ldt.getDayOfMonth());
System.out.println("时=" + ldt.getHour());
System.out.println("分=" + ldt.getMinute());
System.out.println("秒=" + ldt.getSecond());
LocalDate now = LocalDate.now(); //可以获取年月日
LocalTime now2 = LocalTime.now();//获取到时分秒
//提供 plus 和 minus方法可以对当前时间进行加或者减
//看看890天后，是什么时候 把 年月日-时分秒
LocalDateTime localDateTime = ldt.plusDays(890);
System.out.println("890天后=" + dateTimeFormatter.format(localDateTime));
//看看在 3456分钟前是什么时候，把 年月日-时分秒输出
LocalDateTime localDateTime2 = ldt.minusMinutes(3456);
System.out.println("3456分钟前 日期=" + dateTimeFormatter.format(localDateTime2));

11.6 System

常用方法：

exit：退出当前程序
arraycopy：复制数组元素，比较适合底层调用，一般使用Arrays.copyOf完成复制数组
int[] src={1,2.3}:
int[] dest = new int[3];
System.arraycopy (src, 0, dest, 0, 3);
currentTimeMillens：返回当前时间距离1970-1-1的毫秒数
gc()：运行垃圾回收机制

11.7 Arrays

Arrays里面包含了一系列静态方法，用于管理或操作数组(比如排序和搜索)

基本介绍：

常用方法：

toString：返回数组的字符串形式：
Arrays.toString (arr)
sort：排序(自然排序和定制排序)：
Arrays.sout(arr)
binarySearch：通过二分搜索法进行查找，必须是有排序的数组：
int index = Arrays.binarySearch (arr, 需要查找的数)
copyOf：数组元素的复制：
Integer[] newArr = Arrays.copyOf(arr, arr.length)
fill：数组元素的填充
Integer[] num = new Integer[]{9,3,2}
Arrays.fill (num, 99);
equals：比较两个数组元素内容是否完全一
boolean equals = Arrays.equals(arr. arr2)
aslist：将一组值，转换成list
List asList = Arrays.asList(2,3,4,5,6,1)

Integer[] arr = {1, 2, 90, 123, 567};
// binarySearch 通过二分搜索法进行查找，要求必须排好
// 
//1. 使用 binarySearch 二叉查找
//2. 要求该数组是有序的. 如果该数组是无序的，不能使用binarySearch
//3. 如果数组中不存在该元素，就返回 return -(low + 1);  // key not found.
int index = Arrays.binarySearch(arr, 567);
System.out.println("index=" + index);
//copyOf 数组元素的复制
// 
//1. 从 arr 数组中，拷贝 arr.length个元素到 newArr数组中
//2. 如果拷贝的长度 > arr.length 就在新数组的后面 增加 null
//3. 如果拷贝长度 < 0 就抛出异常NegativeArraySizeException
//4. 该方法的底层使用的是 System.arraycopy()
Integer[] newArr = Arrays.copyOf(arr, arr.length);
System.out.println("==拷贝执行完毕后==");
System.out.println(Arrays.toString(newArr));
//ill 数组元素的填充
Integer[] num = new Integer[]{9,3,2};
//
//1. 使用 99 去填充 num数组，可以理解成是替换原理的元素
Arrays.fill(num, 99);
System.out.println("==num数组填充后==");
System.out.println(Arrays.toString(num));
//equals 比较两个数组元素内容是否完全一致
Integer[] arr2 = {1, 2, 90, 123};
//
//1. 如果arr 和 arr2 数组的元素一样，则方法true;
//2. 如果不是完全一样，就返回 false
boolean equals = Arrays.equals(arr, arr2);
System.out.println("equals=" + equals);
//asList 将一组值，转换成list
//
//1. asList方法，会将 (2,3,4,5,6,1)数据转成一个List集合
//2. 返回的 asList 编译类型 List(接口)
//3. asList 运行类型 java.util.Arrays#ArrayList, 是Arrays类的
//   静态内部类 private static class ArrayList<E> extends AbstractList<E>
//              implements RandomAccess, java.io.Serializable
List asList = Arrays.asList(2,3,4,5,6,1);
System.out.println("asList=" + asList);
System.out.println("asList的运行类型" + asList.getClass());

11.8 BigInteger BigDecimal

基本介绍：

Biglnteger适合保存比较大的整型
BigDecimal适合保存精度更高的浮点型（小数）

常用方法：

add：加
subtract：减
multiply：乘
divide：除

12 集合

基本介绍：

可以动态保存任意多个对象
提供了一系列方便的操作对象的方法
使用集合添加、删除新元素的示意代码更简洁

12.1 集合框架体系⭐️

网络异常，图片无法展示
|

网络异常，图片无法展示
|

框架图：

12.2 Collection

基本介绍：

Collection实现子类可以存放多个元素，每个元素可以是Object
Collection的实现类，有些可以存放重复的元素，有些不可以
Collection的实现类，有些是有序的(List)，有些不是有序(Set)
Collection接口没有直接的实现子类，是通过它的子接口Set 和 List 来实现的

接口常用方法：

add：添加单个元素
remove：删除指定元素
contains：查找元素是否存在
size：获取元素个数
isEmpty：判断是否为空
clear：清空
addAll：添加多个元素
containsAll：查找多个元素是否都存在
removeAll：删除多个元素

List list = new ArrayList();
//        add:添加单个元素
        list.add("jack");
        list.add(10);//list.add(new Integer(10))
        list.add(true);
        System.out.println("list=" + list);
//        remove:删除指定元素
        //list.remove(0);//删除第一个元素
        list.remove(true);//指定删除某个元素
        System.out.println("list=" + list);
//        contains:查找元素是否存在
        System.out.println(list.contains("jack"));//T
//        size:获取元素个数
        System.out.println(list.size());//2
//        isEmpty:判断是否为空
        System.out.println(list.isEmpty());//F
//        clear:清空
        list.clear();
        System.out.println("list=" + list);
//        addAll:添加多个元素
        ArrayList list2 = new ArrayList();
        list2.add("红楼梦");
        list2.add("三国演义");
        list.addAll(list2);
        System.out.println("list=" + list);
//        containsAll:查找多个元素是否都存在
        System.out.println(list.containsAll(list2));//T
//        removeAll：删除多个元素
        list.add("聊斋");
        list.removeAll(list2);
        System.out.println("list=" + list);//[聊斋]
//        说明：以ArrayList实现类来演示.

12.2.1 List

基本介绍：

List集合类中元素有序（即添加顺序和取出顺序一致）、且可重复
List集合中的每个元素都有其对应的顺序索引，即支持索引
List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器元素
常用： ArrayList、LinkedList、Vector

常用方法：

void add(int index, Object ele)：在index位置插入ele元素
boolean addAll(int index, Collection eles)：从index位置开始将eles中的所有元素添加进来
Object get(int index)：获取指定index位置的元素
int indexOf(Object obj)：返回obj在集合中首次出现的位置
int lastindexOf(Object obj)：返回obj在当前集合中末次出现的位置
Object remove(int index)：移除指定index位置的元素，井返回此元素
Object set(int index, Object ele)：设置指定index位置的元素为ele，相当于是替换
List sublist(int fromlndex, int tolndex)：返回从fromlndex到tolndex位置的子集合

List list = new ArrayList();
        list.add("张三丰");
        list.add("贾宝玉");
//        void add(int index, Object ele):在index位置插入ele元素
        //在index = 1的位置插入一个对象
        list.add(1, "韩顺平");
        System.out.println("list=" + list);
//        boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
        List list2 = new ArrayList();
        list2.add("jack");
        list2.add("tom");
        list.addAll(1, list2);
        System.out.println("list=" + list);
//        Object get(int index):获取指定index位置的元素
//        int indexOf(Object obj):返回obj在集合中首次出现的位置
        System.out.println(list.indexOf("tom"));//2
//        int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
        list.add("韩顺平");
        System.out.println("list=" + list);
        System.out.println(list.lastIndexOf("韩顺平"));
//        Object remove(int index):移除指定index位置的元素，并返回此元素
        list.remove(0);
        System.out.println("list=" + list);
//        Object set(int index, Object ele):设置指定index位置的元素为ele , 相当于是替换.
        list.set(1, "玛丽");
        System.out.println("list=" + list);
//        List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
        // 注意返回的子集合 fromIndex <= subList < toIndex
        List returnlist = list.subList(0, 2);
        System.out.println("returnlist=" + returnlist);

12.2.1.1 迭代器

基本介绍：

lterator对象称为迭代器，主要用于遍历 Collection 集合中的元素
实现了Collection接口的集合都有一个iterator()方法，用以返回一个实现了lterator接口的对象，即可以返回一个迭代器
lterator 仅用于遍历集合，lterator 本身并不存放对象
在调用it.next()方法之前必须要调用it.hasNext()进行检测。若不调用，且下一条记录无效，直接调用it.next()会抛出NoSuchElementException异常

网络异常，图片无法展示
|

public class CollectionIterator {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        Collection col = new ArrayList();
        col.add(new Book("三国演义", "罗贯中", 10.1));
        col.add(new Book("小李飞刀", "古龙", 5.1));
        col.add(new Book("红楼梦", "曹雪芹", 34.6));
        //System.out.println("col=" + col);
        //现在老师希望能够遍历 col集合
        //1. 先得到 col 对应的 迭代器
        Iterator iterator = col.iterator();
        //2. 使用while循环遍历
//        while (iterator.hasNext()) {//判断是否还有数据
//            //返回下一个元素，类型是Object
//            Object obj = iterator.next();
//            System.out.println("obj=" + obj);
//        }
        //老师教大家一个快捷键，快速生成 while => itit
        //显示所有的快捷键的的快捷键 ctrl + j
        while (iterator.hasNext()) {
            Object obj = iterator.next();
            System.out.println("obj=" + obj);
        }
        //3. 当退出while循环后 , 这时iterator迭代器，指向最后的元素
        //   iterator.next();//NoSuchElementException
        //4. 如果希望再次遍历，需要重置我们的迭代器
        iterator = col.iterator();
        System.out.println("===第二次遍历===");
        while (iterator.hasNext()) {
            Object obj = iterator.next();
            System.out.println("obj=" + obj);
        }
    }
}
class Book {
    private String name;
    private String author;
    private double price;
    public Book(String name, String author, double price) {
        this.name = name;
        this.author = author;
        this.price = price;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getAuthor() {
        return author;
    }
    public void setAuthor(String author) {
        this.author = author;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                '}';
    }
}

12.2.1.2 for增强循环

增强for循环，可以代替iterator迭代器，特点：增强for就是简化版的iterator，本质一样，只能用于遍历集合或数组

基本介绍：

基本语法：

for(元素类型 元素名: 集合名或数组名){
  访问元素;
}

12.2.1.3 普通遍历循环

12.2.1.4 ArrayList⭐️

注意事项和细节：

允许所有元素包括null加入
ArrayList 是由数组来实现数据存储的
ArrayList 基本等同于Vector，除了 ArrayList是线程不安全（执行效率高），在多线程情况下，不建议使用ArrayList

底层结构和源码分析：

ArrayList中维护了一个Object类型的数组elementData，transient Object[] elementData;
transient 表示瞬间,短暂的，表示该属性不会被序列化
创建ArrayList对象时，如果使用的是无参构造器，则初始elementData容量为0，第1次添加，则扩容elementData为10，如需要再次扩容，则扩容elementData 为1.5倍
如果使用的是指定大小的构造器，则初始elementData容量为指定大小，如果需要扩容，则直接扩容elementData为1.5倍

网络异常，图片无法展示
|

网络异常，图片无法展示
|

12.2.1.5 Vector⭐️

注意事项和细节：

Vector底层是一个对象数组， protected Object[] elementData;
Vector 是线程同步的，即线程安全，Vector类的操作方法带有synchronized

底层机制和源码分析：

public class Vector_ {
    public static void main(String[] args) {
        //无参构造器
        //有参数的构造
        Vector vector = new Vector(8);
        for (int i = 0; i < 10; i++) {
            vector.add(i);
        }
        vector.add(100);
        System.out.println("vector=" + vector);
        //老韩解读源码
        //1. new Vector() 底层
        /*
            public Vector() {
                this(10);
            }
         补充：如果是  Vector vector = new Vector(8);
            走的方法:
            public Vector(int initialCapacity) {
                this(initialCapacity, 0);
            }
         2. vector.add(i)
         2.1  //下面这个方法就添加数据到vector集合
            public synchronized boolean add(E e) {
                modCount++;
                ensureCapacityHelper(elementCount + 1);
                elementData[elementCount++] = e;
                return true;
            }
          2.2  //确定是否需要扩容 条件 ： minCapacity - elementData.length>0
            private void ensureCapacityHelper(int minCapacity) {
                // overflow-conscious code
                if (minCapacity - elementData.length > 0)
                    grow(minCapacity);
            }
          2.3 //如果 需要的数组大小 不够用，就扩容 , 扩容的算法
              //newCapacity = oldCapacity + ((capacityIncrement > 0) ?
              //                             capacityIncrement : oldCapacity);
              //就是扩容两倍.
            private void grow(int minCapacity) {
                // overflow-conscious code
                int oldCapacity = elementData.length;
                int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                                 capacityIncrement : oldCapacity);
                if (newCapacity - minCapacity < 0)
                    newCapacity = minCapacity;
                if (newCapacity - MAX_ARRAY_SIZE > 0)
                    newCapacity = hugeCapacity(minCapacity);
                elementData = Arrays.copyOf(elementData, newCapacity);
            }
         */
    }
}

网络异常，图片无法展示
|

ArrayList和Vector：

12.2.1.6 LinkedList

注意事项和细节：

LinkedList底层实现了双向链表和双端队列特点
可以添加任意元素包括null
线程不安全，没有实现同步

底层机制：

Linkedlist底层维护了一个双向链表
Linkedlist中维护了两个属性first和last分别指向首节点和尾节点
每个节点（Node对象），里面又维护了prev、next.item三个属性，其中通过
prev指向前一个，通过next指向后一个节点。最终实现双向链表
所以LinkedList的元素的添加和删除，不是通过数组完成的，相对来说效率较高

网络异常，图片无法展示
|

ArrayList和LinkedList：

如果我们改查的操作多，选择ArrayList
如果我们增删的操作多，选择LinkedList
一般来说，在程序中，80%-90%都是查询，因此大部分情况下会选择ArrayList

网络异常，图片无法展示
|

12.2.2 Set

基本介绍：

无序（添加和取出的顺序不一致），没有索引
不允许重复元素，所以最多包含一个null
JDK API中Set接口的实现类有：

网络异常，图片无法展示
|

常用方法：

add：添加单个元素
remove：删除指定元素
contains：查找元素是否存在
size：获取元素个数
isEmpty：判断是否为空
clear：清空
addAll：添加多个元素
containsAll：查找多个元素是否都存在
removeAll：删除多个元素

public class SetMethod {
    public static void main(String[] args) {
        //老韩解读
        //1. 以Set 接口的实现类 HashSet 来讲解Set 接口的方法
        //2. set 接口的实现类的对象(Set接口对象), 不能存放重复的元素, 可以添加一个null
        //3. set 接口对象存放数据是无序(即添加的顺序和取出的顺序不一致)
        //4. 注意：取出的顺序的顺序虽然不是添加的顺序，但是他的固定.
        Set set = new HashSet();
        set.add("john");
        set.add("lucy");
        set.add("john");//重复
        set.add("jack");
        set.add("hsp");
        set.add("mary");
        set.add(null);//
        set.add(null);//再次添加null
        for(int i = 0; i <10;i ++) {
            System.out.println("set=" + set);
        }
        //遍历
        //方式1： 使用迭代器
        System.out.println("=====使用迭代器====");
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            Object obj =  iterator.next();
            System.out.println("obj=" + obj);
        }
        set.remove(null);
        //方式2: 增强for
        System.out.println("=====增强for====");
        for (Object o : set) {
            System.out.println("o=" + o);
        }
        //set 接口对象，不能通过索引来获取
    }
}

遍历方式：

迭代器
增强for
不能使用索引方式获取（普通遍历循环）

12.2.2.1 HashSet⭐️

注意事项和细节：

Hashset实现了Set接口
Hashset实际上是HashMap
可以存放null值，但是只能有一个null
Hashset不保证元素是有序的,取决于hash后，再确定索引的结果
不能有重复元素/对象

底层机制和源码分析：

HashSet 底层是 HashMap
添加一个元素时，先得到hash值会转成索引值
找到存储数据表table，看这个素引位置是否己经存放的有元素如果没有，直接加入
如果有调用equals 比较，如果相同，就放奔添加，如果不相同，则添加到最后
在Java8中，如果一条链表的元素个数超过 TREEIFY THRESHOLD（默认是8），井且table的大小＞=MIN TREEIFY CAPACITY（默认64)就会进行树化(红黑树）

网络异常，图片无法展示
|

public class HashSetSource {

public static void main(String[] args) {
        HashSet hashSet = new HashSet();
        hashSet.add("java");//到此位置，第1次add分析完毕.
        hashSet.add("php");//到此位置，第2次add分析完毕
        hashSet.add("java");
        System.out.println("set=" + hashSet);
        /*
        HashSet 的源码解读
        1. 执行 HashSet()
            public HashSet() {
                map = new HashMap<>();
            }
        2. 执行 add()
           public boolean add(E e) {//e = "java"
                return map.put(e, PRESENT)==null;//(static) PRESENT = new Object();
           }
         3.执行 put() , 该方法会执行 hash(key) 得到key对应的hash值 算法h = key.hashCode()) ^ (h >>> 16)
             public V put(K key, V value) {//key = "java" value = PRESENT 共享
                return putVal(hash(key), key, value, false, true);
            }
         4.执行 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 就是 HashMap 的一个数组，类型是 Node[]
                //if 语句表示如果当前table 是null, 或者 大小=0
                //就是第一次扩容，到16个空间.
                if ((tab = table) == null || (n = tab.length) == 0)
                    n = (tab = resize()).length;
                //(1)根据key，得到hash 去计算该key应该存放到table表的哪个索引位置
                //并把这个位置的对象，赋给 p
                //(2)判断p 是否为null
                //(2.1) 如果p 为null, 表示还没有存放元素, 就创建一个Node (key="java",value=PRESENT)
                //(2.2) 就放在该位置 tab[i] = newNode(hash, key, value, null)
                if ((p = tab[i = (n - 1) & hash]) == null)
                    tab[i] = newNode(hash, key, value, null);
                else {
                    //一个开发技巧提示： 在需要局部变量(辅助变量)时候，在创建
                    Node<K,V> e; K k; //
                    //如果当前索引位置对应的链表的第一个元素和准备添加的key的hash值一样
                    //并且满足 下面两个条件之一:
                    //(1) 准备加入的key 和 p 指向的Node 结点的 key 是同一个对象
                    //(2)  p 指向的Node 结点的 key 的equals() 和准备加入的key比较后相同
                    //就不能加入
                    if (p.hash == hash &&
                        ((k = p.key) == key || (key != null && key.equals(k))))
                        e = p;
                    //再判断 p 是不是一颗红黑树,
                    //如果是一颗红黑树，就调用 putTreeVal , 来进行添加
                    else if (p instanceof TreeNode)
                        e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
                    else {//如果table对应索引位置，已经是一个链表, 就使用for循环比较
                          //(1) 依次和该链表的每一个元素比较后，都不相同, 则加入到该链表的最后
                          //    注意在把元素添加到链表后，立即判断 该链表是否已经达到8个结点
                          //    , 就调用 treeifyBin() 对当前这个链表进行树化(转成红黑树)
                          //    注意，在转成红黑树时，要进行判断, 判断条件
                          //    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY(64))
                          //            resize();
                          //    如果上面条件成立，先table扩容.
                          //    只有上面条件不成立时，才进行转成红黑树
                          //(2) 依次和该链表的每一个元素比较过程中，如果有相同情况,就直接break
                        for (int binCount = 0; ; ++binCount) {
                            if ((e = p.next) == null) {
                                p.next = newNode(hash, key, value, null);
                                if (binCount >= TREEIFY_THRESHOLD(8) - 1) // -1 for 1st
                                    treeifyBin(tab, hash);
                                break;
                            }
                            if (e.hash == hash &&
                                ((k = e.key) == key || (key != null && key.equals(k))))
                                break;
                            p = e;
                        }
                    }
                    if (e != null) { // existing mapping for key
                        V oldValue = e.value;
                        if (!onlyIfAbsent || oldValue == null)
                            e.value = value;
                        afterNodeAccess(e);
                        return oldValue;
                    }
                }
                ++modCount;
                //size 就是我们每加入一个结点Node(k,v,h,next), size++
                if (++size > threshold)
                    resize();//扩容
                afterNodeInsertion(evict);
                return null;
            }
         */
    }
}

扩容和红黑树机制：

HashSet底层是HashMap
第一次添加时，table 数组扩容到 16，临界值(threshold)是 16*加载因子(loadFactor)是0.75= 12
每加入一个节点，size就会++，到达临界值就会扩容
如果table 数组使用到了临界值 12,就会扩容到16*2=32,新的临界值就是32*0.75=24，依次类推
在Java8中，如果一条链表的元素个数到达 TREEIFY_ THRESHOLD(默认是 8）井且table的大小＞=MIN TREEIFY CAPACITY (默认64),就会进行树化(红黑树），否则仍然采用数组扩容机制

去重机制对比：

HashSet去重机制: hashCode() + equals()，底层先通过存入对象，通过运算hash值得到对应的索引，如果table索引所在的位置没有数据就直接存放；如果有数据就进行equals（注意重写情况）比较[遍历比较]，如果比较后，不相同就加入，否则就不加入
TreeSet的去重机制：如果你传入了一个Comparator匿名对象，就使用实现的compare去重，如果方法返回0,就是相同的元素/数据，就不添加，如果你没有传入一个Comparator匿名对象，则以你添加的对象实现的Compareable接口的compareTo去重

例：

public class Homework06 {
    public static void main(String[] args) {
        HashSet set = new HashSet();//ok
        Person p1 = new Person(1001,"AA");//ok
        Person p2 = new Person(1002,"BB");//ok
        set.add(p1);//ok
        set.add(p2);//ok
        p1.name = "CC";
        set.remove(p1);
        System.out.println(set);//2
        set.add(new Person(1001,"CC"));
        System.out.println(set);//3
        set.add(new Person(1001,"AA"));
        System.out.println(set);//4
    }
}
class Person {
    public String name;
    public int id;
    public Person(int id, String name) {
        this.name = name;
        this.id = id;
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return id == person.id &&
                Objects.equals(name, person.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, id);
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", id=" + id +
                '}';
    }
}

网络异常，图片无法展示

12.2.2.2 LinkedHashSet

注意事项和细节：

LinkedHashset 是Hashset 的子类
LinkedHashSet 底层是一个 LinkedHashMap，底层维护了一个数组＋双向链表
LinkedHashSet 根据元素的 hashCode 值来决定元素的存储位置，同时使用链表维护元素的次序(图)，这使得元素看起来是以插入顺序保存的
LinkedHashSet 不允许添重复元素

网络异常，图片无法展示
|

底层机制和源代码分析：

LinkedHashSet 加入顺序和取出元素/数据的顺序一致
LinkedHashSet 底层维护的是一个LinkedHashMap(是HashMap的子类)
LinkedHashSet 底层结构 (数组table+双向链表)
添加第一次时，直接将数组table 扩容到 16 ,存放的结点类型是 LinkedHashMap$Entry
数组是 HashMap

网络异常，图片无法展示
|

Entry类型

public class LinkedHashSetSource {
    public static void main(String[] args) {
        //分析一下LinkedHashSet的底层机制
        Set set = new LinkedHashSet();
        set.add(new String("AA"));
        set.add(456);
        set.add(456);
        set.add(new Customer("刘", 1001));
        set.add(123);
        set.add("HSP");
        System.out.println("set=" + set);
        //1. LinkedHashSet 加入顺序和取出元素/数据的顺序一致
        //2. LinkedHashSet 底层维护的是一个LinkedHashMap(是HashMap的子类)
        //3. LinkedHashSet 底层结构 (数组table+双向链表)
        //4. 添加第一次时，直接将 数组table 扩容到 16 ,存放的结点类型是 LinkedHashMap$Entry
        //5. 数组是 HashMap$Node[] 存放的元素/数据是 LinkedHashMap$Entry类型
        /*
                //继承关系是在内部类完成.
                static class Entry<K,V> extends HashMap.Node<K,V> {
                    Entry<K,V> before, after;
                    Entry(int hash, K key, V value, Node<K,V> next) {
                        super(hash, key, value, next);
                    }
                }
         */
    }
}
class Customer {
    private String name;
    private int no;
    public Customer(String name, int no) {
        this.name = name;
        this.no = no;
    }
}

12.2.2.3 TreeSet

底层机制：

TreeSet()构造器需传入Comparator接口的匿名内部类，因为底层 Comparable<? super K> k = (Comparator<? super K>) key;
若没有传入，则需要把传入的类实现Comparable接口
若按照compare方法比较value相同则无法加入value

public class TreeSet_ {
    public static void main(String[] args) {
        //1. 当我们使用无参构造器，创建TreeSet时，默认按字母排序
        //2. 老师希望添加的元素，按照字符串大小来排序
        //3. 使用TreeSet 提供的一个构造器，可以传入一个比较器(匿名内部类)
        //   并指定排序规则
        //4. 简单看看源码
        /*
        1. 构造器把传入的比较器对象，赋给了 TreeSet的底层的 TreeMap的属性this.comparator
         public TreeMap(Comparator<? super K> comparator) {
                this.comparator = comparator;
            }
         2. 在 调用 treeSet.add("tom"), 在底层会执行到
             if (cpr != null) {//cpr 就是我们的匿名内部类(对象)
                do {
                    parent = t;
                    //动态绑定到我们的匿名内部类(对象)compare
                    cmp = cpr.compare(key, t.key);
                    if (cmp < 0)
                        t = t.left;
                    else if (cmp > 0)
                        t = t.right;
                    else //如果相等，即返回0,这个Key就没有加入
                        return t.setValue(value);
                } while (t != null);
            }
         */
//        TreeSet treeSet = new TreeSet();
        TreeSet treeSet = new TreeSet(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                //下面 调用String的 compareTo方法进行字符串大小比较
                //如果老韩要求加入的元素，按照长度大小排序
                //return ((String) o2).compareTo((String) o1);
                return ((String) o1).length() - ((String) o2).length();
            }
        });
        //添加数据.
        treeSet.add("jack");
        treeSet.add("tom");//3
        treeSet.add("sp");
        treeSet.add("a");
        treeSet.add("abc");//3
        System.out.println("treeSet=" + treeSet);
    }
}

12.3 Map

注意事项和细节：

Map与Collection井列存在，用于保存具有映射关系的数据
Map 中的key 和 value 可以是任何引用类型的数据，会封装到HashMap$Node对象中
Map 中的key 不允许重复，原因和HashSet 一样
Map 中的value 可以重复
Map 的key可以为null，value也可以为null，key为null只有能有一个，value为null可以为多个
常用String类作为Map的key
key 和 value 之间存在单向一对一关系，即通过指定的 key 总能找到对应的 value
Map存放数据的key-value示意图，一对 k-y是放在一个Node中的，有因为Node 实现了 Entry 接口

网络异常，图片无法展示
|

常用方法：

put：添加
remove：根据键删除映射关系
get：根据键获取值
size：获取元素个数
isEmpty：判断个数是否为0
clear：清除
containskey：查找键是否存在

public class MapMethod {
    public static void main(String[] args) {
        //演示map接口常用方法
        Map map = new HashMap();
        map.put("邓超", new Book("", 100));//OK
        map.put("邓超", "孙俪");//替换-> 一会分析源码
        map.put("王宝强", "马蓉");//OK
        map.put("宋喆", "马蓉");//OK
        map.put("刘令博", null);//OK
        map.put(null, "刘亦菲");//OK
        map.put("鹿晗", "关晓彤");//OK
        map.put("hsp", "hsp的老婆");
        System.out.println("map=" + map);
//        remove:根据键删除映射关系
        map.remove(null);
        System.out.println("map=" + map);
//        get：根据键获取值
        Object val = map.get("鹿晗");
        System.out.println("val=" + val);
//        size:获取元素个数
        System.out.println("k-v=" + map.size());
//        isEmpty:判断个数是否为0
        System.out.println(map.isEmpty());//F
//        clear:清除k-v
        //map.clear();
        System.out.println("map=" + map);
//        containsKey:查找键是否存在
        System.out.println("结果=" + map.containsKey("hsp"));//T
    }
}
class Book {
    private String name;
    private int num;
    public Book(String name, int num) {
        this.name = name;
        this.num = num;
    }
}

遍历方式：

先取出所有的Key , 通过Key 取出对应的Value
把所有的values取出
通过 EntrySet 来获取 k-v

public class MapFor {
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put("邓超", "孙俪");
        map.put("王宝强", "马蓉");
        map.put("宋喆", "马蓉");
        map.put("刘令博", null);
        map.put(null, "刘亦菲");
        map.put("鹿晗", "关晓彤");
        //第一组: 先取出 所有的Key , 通过Key 取出对应的Value
        Set keyset = map.keySet();
        //(1) 增强for
        System.out.println("---第一种方式-------");
        for (Object key : keyset) {
            System.out.println(key + "-" + map.get(key));
        }
        //(2) 迭代器
        System.out.println("----第二种方式--------");
        Iterator iterator = keyset.iterator();
        while (iterator.hasNext()) {
            Object key =  iterator.next();
            System.out.println(key + "-" + map.get(key));
        }
        //第二组: 把所有的values取出
        Collection values = map.values();
        //这里可以使用所有的Collections使用的遍历方法
        //(1) 增强for
        System.out.println("---取出所有的value 增强for----");
        for (Object value : values) {
            System.out.println(value);
        }
        //(2) 迭代器
        System.out.println("---取出所有的value 迭代器----");
        Iterator iterator2 = values.iterator();
        while (iterator2.hasNext()) {
            Object value =  iterator2.next();
            System.out.println(value);
        }
        //第三组: 通过EntrySet 来获取 k-v
        Set entrySet = map.entrySet();// EntrySet<Map.Entry<K,V>>
        //(1) 增强for
        System.out.println("----使用EntrySet 的 for增强(第3种)----");
        for (Object entry : entrySet) {
            //将entry 转成 Map.Entry
            Map.Entry m = (Map.Entry) entry;
            System.out.println(m.getKey() + "-" + m.getValue());
        }
        //(2) 迭代器
        System.out.println("----使用EntrySet 的 迭代器(第4种)----");
        Iterator iterator3 = entrySet.iterator();
        while (iterator3.hasNext()) {
            Object entry =  iterator3.next();
            //System.out.println(next.getClass());//HashMap$Node -实现-> Map.Entry (getKey,getValue)
            //向下转型 Map.Entry
            Map.Entry m = (Map.Entry) entry;
            System.out.println(m.getKey() + "-" + m.getValue());
        }
    }
}

12.3.1 HashMap⭐️

注意事项和细节：

HashMap是Map 接口使用频率最高的实现类
Hashap 是以 key-val 对的方式来存储数据(HashMap$Node类型）
key 不能重复，但是值可以重复，允许使用null和null值
如果添加相同的key，则会覆盖原来的key-val ，等同于修改（key不会替换，val会替换）
与HashSet一样，不保证映射的顺序，因为底层是以hash表的方式来存储的(jdk8的hashMap 底层数组＋链表＋红黑树）
HashMap没有实现同步，因此是线程不安全的，方法没有做同步互斥的操作，没有synchronized

底层机制和源码剖析：

扩容机制和Hashset相同
HashMap底层维护了Node类型的数组table，默认为null
当创建对象时，将加载因子(loadfactor)初始化为0.75
当添加key-val时，通过key的哈希值得到在table的索引。然后判断该索引处是否有元素，如果没有元素直接添加。如果该索引处有元素，继续判断该元素的key是否和准备加入的key相等，如果相等，则直接替换val：如果不相等需要判断是树结构还是链表结构，做出相应处理。如果添加时发现容量不够，则需要扩容
第1次添加，则需要扩容table容量为16，临界值(threshold)为12
以后再扩容，则需要扩容table容量为原来的2倍，临界值为原来的2倍,即24，依次类推
在Java8中，如果一条链表的元素个数超过 TREEIFY THRESHOLD（默认是8），并且
table的大小＞=MIN TREEIFY CAPACITY（默认64),就会进行树化（红黑树）

网络异常，图片无法展示
|

public class HashMapSource1 {
    public static void main(String[] args) {
        HashMap map = new HashMap();
        map.put("java", 10);//ok
        map.put("php", 10);//ok
        map.put("java", 20);//替换value
        System.out.println("map=" + map);//
        /*老韩解读HashMap的源码+图解
        1. 执行构造器 new HashMap()
           初始化加载因子 loadfactor = 0.75
           HashMap$Node[] table = null
        2. 执行put 调用 hash方法，计算 key的 hash值 (h = key.hashCode()) ^ (h >>> 16)
            public V put(K key, V value) {//K = "java" value = 10
                return putVal(hash(key), key, value, false, true);
            }
        3. 执行 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 数组为null, 或者 length =0 , 就扩容到16
                if ((tab = table) == null || (n = tab.length) == 0)
                    n = (tab = resize()).length;
                //取出hash值对应的table的索引位置的Node, 如果为null, 就直接把加入的k-v
                //, 创建成一个 Node ,加入该位置即可
                if ((p = tab[i = (n - 1) & hash]) == null)
                    tab[i] = newNode(hash, key, value, null);
                else {
                    Node<K,V> e; K k;//辅助变量
                // 如果table的索引位置的key的hash相同和新的key的hash值相同，
                 // 并 满足(table现有的结点的key和准备添加的key是同一个对象  || equals返回真)
                 // 就认为不能加入新的k-v
                    if (p.hash == hash &&
                        ((k = p.key) == key || (key != null && key.equals(k))))
                        e = p;
                    else if (p instanceof TreeNode)//如果当前的table的已有的Node 是红黑树，就按照红黑树的方式处理
                        e = ((TreeNode<K,V>)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个，到8个，后
                                //就调用 treeifyBin 方法进行红黑树的转换
                                if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                                    treeifyBin(tab, hash);
                                break;
                            }
                            if (e.hash == hash && //如果在循环比较过程中，发现有相同,就break,就只是替换value
                                ((k = e.key) == key || (key != null && key.equals(k))))
                                break;
                            p = e;
                        }
                    }
                    if (e != null) { // existing mapping for key
                        V oldValue = e.value;
                        if (!onlyIfAbsent || oldValue == null)
                            e.value = value; //替换，key对应value
                        afterNodeAccess(e);
                        return oldValue;
                    }
                }
                ++modCount;//每增加一个Node ,就size++
                if (++size > threshold[12-24-48])//如size > 临界值，就扩容
                    resize();
                afterNodeInsertion(evict);
                return null;
            }

5. 关于树化(转成红黑树)

//如果table 为null ,或者大小还没有到 64，暂时不树化，而是进行扩容.
              //否则才会真正的树化 -> 剪枝
              final void treeifyBin(Node<K,V>[] tab, int hash) {
                int n, index; Node<K,V> e;
                if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
                    resize();
            }
         */
    }
}

12.3.2 Hashtable

注意事项和细节：

存放的元素是键值对：即K-V
hashtable的键和值都不能为null，否则会抛出NulPointerException
hashTable 使用方法基本上和HashMap一样
hashTable 是线程安全的(synchronized)，hashmap 是线程不安全的

底层机制：

底层有数组 Hashtable$Entry[] 初始化大小为 11
临界值 threshold 8 = 11 * 0.75
扩容: 按照自己的扩容机制来进行即可
执行方法 addEntry(hash, key, value, index); 添加K-V 封装到Entry
当 if (count >= threshold) 满足时，就进行扩容
按照 int newCapacity = (oldCapacity << 1) + 1;的大小扩容

网络异常，图片无法展示
|

JavaSE笔记--韩顺平(入门详细版)（二）

9.3JDk内置的基本注解类型

基本介绍：

基本Annotation介绍：

9.3.1@Override

基本介绍：

9.3.2@Deprecated

基本介绍：

9.3.3@SuppressWarnings

基本介绍：

9.4元注解：对注解进行注解

基本介绍：

四种元注解：

10 异常

基本介绍：

执行中异常事件分类：

10.1异常体系图⭐️

异常体系图：

注意事项和细节：

10.2常见的异常

运行时异常：

编译时异常：

10.3异常处理⭐️

基本介绍：

10.3.1 try-catch-finally

基本介绍：

流程图：

注意事项和细节：

10.3.2 throws

基本介绍：

流程图：

注意事项和细节：

10.4自定义异常

基本介绍：

自定义异常步骤：

10.5 throw和throws

对比：

11 包装类

11.0包装类(Integer例)

基本介绍：

装箱和拆箱：

包装类方法：

11.1 String⭐️

基本介绍：

创建String对象方式：

两种方式对比：

常用构造方法：

注意事项和细节：

特性：

相等特性：

字符串特性：

综合训练

常用方法：

11.2 StringBuffer⭐️

基本介绍：

注意事项和细节：

String和StringBuffer对比：

构造器：

String和StringBuffer转换：

常用方法：

11.3 StringBulider⭐️

基本介绍：

注意事项和细节：

常用方法：

三类对比：

三类选择：

11.4 Math

基本介绍：

常用方法：

11.5 Date、Calenda、LocalDate

11.5.1 Date

常用方法：

11.5.2 Calenda

基本介绍：

常用方法：

11.5.3 LocalDate

常用方法：

11.6 System

常用方法：

11.7 Arrays