栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

[Study]Java

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

[Study]Java

文章目录
  • 一、基础语法
    • 1.1 环境变量配置
    • 1.2 JDK、JRE、JVM
    • 1.3 基本数据类型
    • 1.4 类型转换
    • 1.5 运算符
    • 1.6 保留字
    • 1.7 switch
  • 二、面向对象
    • 2.1 数组
    • 2.2 字符串
    • 2.3 构造器
    • 2.3 对象创建流程
    • 2.4 继承
    • 2.5 Object
    • 2.6 super 和 this
    • 2.7 == 和 equals()
    • 2.8 重写和重载
    • 2.9 可变参数
    • 2.10 动态绑定机制
    • 2.11 字段与方法
    • 2.12 代码块和类加载
    • 2.13 Java 代码执行顺序
    • 2.14 单例设计模式
    • 2.15 final
    • 2.16 抽象类
    • 2.17 接口
    • 2.18 内部类
  • 三、枚举
    • 3.1 自定义枚举类
    • 3.2 enum 枚举类
    • 3.3 Enum 类成员方法
  • 四、注解
    • 4.1 注解介绍
    • 4.2 @Override
    • 4.3 @Deprecated
    • 4.4 @SupressWarning
    • 4.5 四种元注解
  • 五、异常
    • 5.1 异常分类及体系图
    • 5.2 try-catch-finally-return
    • 5.3 自定义异常
    • 5.4 throws 和 throw 的区别
  • 六、常用类
    • 6.1 包装类体系图
    • 6.2 装箱与拆箱
    • 6.3 包装类与 String 间转换
    • 6.4 Integer 的创建机制
    • 6.5 String 的创建机制
    • 6.6 String 的相加
    • 6.7 StringBuffer
    • 6.8 Arrays
    • 6.9 BigDecimal
    • 6.10 第二、三代日期类
  • 七、集合
    • 7.1 集合体系图
    • 7.2 Collection 与 Iterator
    • 7.3 List
    • 7.4 ArrayList
    • 7.5 Vector
    • 7.6 LinkedList
    • 7.7 Set
    • 7.8 HashSet
    • 7.9 LinkedHashSet
    • 7.10 Map
    • 7.11 HashMap
    • 7.12 Hashtable
    • 7.13 TreeMap
    • 7.14 HashMap 和 TreeMap 的去重机制
    • 7.15 集合选择
    • 7.16 Collections 工具类
  • 八、泛型
    • 8.1 泛型介绍
    • 8.2 泛型的类型
    • 8.3 自定义泛型
  • 九、多线程
    • 9.1 进程、线程、并发、并行
    • 9.2 创建线程的两种方式
    • 9.3 start() 与 run()
    • 9.4 Thread 常用 API
    • 9.5 线程插队与礼让
    • 9.6 守护线程
    • 9.7 线程七大状态
    • 9.8 多线卖票问题
    • 9.9 线程同步机制
    • 9.10 线程死锁
    • 9.11 释放锁
  • 十、IO
    • 10.1 File 常用 API
    • 10.2 IO 流的分类
    • 10.3 字节流
    • 10.4 字符流
    • 10.5 节点流与处理流
    • 10.6 对象处理流
    • 10.7 标准输入输出流
    • 10.8 转换流
    • 10.9 打印流
    • 10.10 Properties
  • 十一、网络编程
    • 11.1 IP 与 域名
    • 11.2 端口、协议
    • 11.3 TCP、UDP、Socket
    • 11.4 InetAddress 常用 API
    • 11.5 TCP 字节流编程
    • 11.6 TCP 字符流编程
    • 11.7 TCP 文件上传
    • 11.8 TCP 文件下载
    • 11.9 UDP 字节编程
    • 11.10 netstat 指令
  • 十二、反射
    • 12.1 入门案例
    • 12.2 反射机制
    • 12.3 Java 程序的三个阶段
    • 12.4 Class
    • 12.5 获取 Class 对象
    • 12.6 动态加载和静态加载
    • 12.7 类加载流程
    • 12.8 反射爆破
  • 十三、JDBC
    • 13.1 JDBC 原理
    • 13.2 五种连接方式
    • 13.3 ResultSet
    • 13.4 SQL 注入
    • 13.5 PreparedStatement
    • 13.6 JDBC API
    • 13.7 Java 事务操作
    • 13.8 批处理
    • 13.9 数据库连接池
    • 13.10 C3P0 连接池
    • 13.11 Druid 连接池
    • 13.12 ApacheDBUtils
    • 13.13 BaseDao

一、基础语法 1.1 环境变量配置
  1. JAVA_HOME = D:Javajdk1.8.0_131
  2. Path = %JAVA_HOME%bin
  3. CLASSPATH = .;%JAVA_HOME%libdt.jar;%JAVA_HOME%libtools.jar;
1.2 JDK、JRE、JVM
  1. JDK = JRE + Java 开发工具(java、javac、javap、javadoc ······)
  2. JRE = JVM + Java 核心类库
  3. JVM 是一个虚拟的计算机,具有指令集并使用不同存储区域。负责执行指令,管理数据、内存和寄存器,包含在 JDK 中

1.3 基本数据类型
  1. Java 数据类型中没有无符号类型

  2. Java 浮点类型默认为 double 类型,定义 float 类型时需要在末尾加上 F 或 f。浮点数组成:符号位 + 指数位 + 尾数位

  3. Java语言对布尔类型的存储并没有做规定,因为理论上存储布尔类型只需要 1 bit,但通常 JVM 内部会把 boolean 表示为 4 字节整数

  4. 八大基本数据类型的数据范围

    类型字节数范围
    byte1-128 - 127
    short2-32768 - 32767
    int4-231 - 231-1
    long8-263 - 263-1
    float4-3.403E38 - 3.403E38
    double8-1.798E308 - 1.798E308
    char2ISO 单一字符集
    boolean1true or false
1.4 类型转换
  1. 自动类型转换

    1. 自动类型转换一:char -> int -> long -> float -> double
    2. 自动类型转换二:byte -> short -> int -> long -> float -> double
    3. (byte,short) 和 char 之间不会自动类型转换
  2. byte、char、short 在进行运算时,当作 int 处理

  3. char 类型可以保存 int 类型的常量值,但不能保存 int 型的变量值,需要强转

    char ch = 23;
    int i = 32;
    ch = (char) i;
    
  4. 浮点数运算和整数运算相比,只能进行加减乘除这些数值计算,不能做位运算和移位运算

  5. 整数运算在除数为 0 时会报错,而浮点数运算在除数为 0 时,不会报错,但会返回以下几个特殊值(NaN:Not a Number、Infinity:无穷大、-Infinity:负无穷大)

    // ArithmeticException
    int i = 10 / 0;
    // j = Infinity
    double j = 10.0 / 0;
    
  6. 如果强制类型转换后超过了整型能表示的最大范围,将返回整型的最大值

    double d = Double.MAX_VALUE;
    // max = 2147483647
    int max = (int) d;
    
  7. 如果要进行四舍五入,可以对浮点数加上 0.5 再强制转型

1.5 运算符
  1. 自增、自减运算符

    int i = 1;
    i = i++;
    // output:1
    System.out.println(i);
    
    int i = 1;
    i = ++i;
    // output:2
    System.out.println(i);
    
  2. 三元运算符

    Object object = true ? new Integer(1) : new Double(2.0);
    // 三元运算符需要看作一个整体,故输出 1.0;if - else 分支结构则输出 1
    System.out.println(object);
    
  3. 位运算

    1. 算术右移(>>):低位丢弃,符号位不变,高位补符号位
    2. 算术左移(<<):符号位不变,低位补 0
    3. 无符号右移(>>>):低位丢弃,高位补 0
  4. 运算符优先级,自上而下优先级依次降低

    运算顺序操作符
    . () {} ; ,
    R -> L++ – ~ !
    L -> R* / %
    L -> R+ -
    L -> R<< >> >>>
    L -> R< > <= >= instanceof
    L -> R== !=
    L -> R&
    L -> R^
    L -> R|
    L -> R&&
    L -> R||
    L -> R? :
    R -> L= *= /= %=
    R -> L+= -= <<= >>=
    R -> L>>>= &= ^= |=
1.6 保留字
  1. strictfp:strict float point (精确浮点) ,strictfp 关键字可应用于类、接口、方法。 使用 strictfp 关键字声明一个方法时,该方法中所有的 float 和 double 表达式都严格遵守 FP-strict 的限制,符合 IEEE-754 规范
  2. volatile 是 jvm 提供的轻量级同步机制。作用是:保证可见性、禁止指令重排、不保证原子性

1.7 switch

switch 的 case 后跟常量或常量表达式,switch 中的表达式只能是以下类型中的一种:byte、short、char、int、enum、String

二、面向对象 2.1 数组
  1. 静态初始化方式创建数组

    int[] array = {2,54,3,23};
    
  2. new 方式创建数组,若没有赋值,则有默认值,由此可看出数组是引用类型

    int[] a = new int[3];
    // output: [0, 0, 0]
    System.out.println(Arrays.toString(a));
    
  3. Java 中多维数组每行的元素个数可以不一致

    int[][] array = new int[3][];
    array[0] = new int[3];
    array[1] = new int[2];
    array[2] = new int[6];
    
  4. Arrays 工具类遍历多维数组

    int[][] array =new int[][]{
      {1, 2, 3},
      {2, 3},
      {54, 234, 3, 131, 34}
    };
    System.out.println(Arrays.deepToString(array));
    
2.2 字符串
  1. Java 在内存中总是使用 Unicode 表示字符,所以,一个英文字符和一个中文字符都用一个 char 类型表示,它们都占用 2 个字节

  2. 注意要区分空值 null 和空字符串 “”,空字符串是一个有效的字符串对象,它不等于 null

  3. 使用 printf 输出 ‘%’

    System.out.printf("%%");
    
  4. 常用字符集占用的字节数

    字符集字符占用字节数汉字占用字节数
    ASCII1不支持中文
    Unicode22
    UTF - 813
    GBK12
2.3 构造器
  1. 构造器只负责完成对象的初始化,并不是创建对象。调用构造器时堆中已经分配了对象的空间,构造器只是负责对对象进行初始化
  2. 没有在构造器中对类的字段初始化时,引用类型的字段默认是 null,数值类型的字段用默认值:int类型默认值是 0,布尔类型默认值是 false(类的属性有默认值,局部变量没有默认值)
2.3 对象创建流程
  1. 加载类信息,生成 .class 对象

  2. 在堆中为对象分配空间

    1. 栈:一般存放基本数据类型(局部变量)
    2. 堆:存放对象(数组)
    3. 方法区:常量池(字符串)、类加载信息
  3. 完成对象的默认初始化

  4. 构造器完成对象的初始化

2.4 继承
  1. 继承内存布局

  2. 子类继承了父类所有的方法和属性,但父类的私有属性不能在子类中直接访问

  3. 当创建子类的对象时,无论使用子类的哪个构造器,默认情况下总会去调用父类的无参构造器,如果父类没有提供无参构造器,则必须在子类中使用 super 去显式调用父类的构造器完成父类的初始化工作,否则编译不会通过

  4. super() 和 this() 都只能放在构造器的第一行,因此这两个方法不能同时存在一个构造器中

  5. instanceof 实际上判断一个变量所指向的实例是否是指定类型,或者这个类型的子类

2.5 Object
  1. Object 类的 toString()、equas() 方法

    public String toString() {
            return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }
    public boolean equals(Object obj) {
            return (this == obj);
    }
    
  2. Object 类的所字段与方法

2.6 super 和 this
  1. super 代表父类的引用,用于访问父类的属性、方法、构造器,不能使用 super 访问父类的 private 成员

  2. JVM 会给每个对象分配 this,代表当前对象。谁调用,this 就指向它

  3. this 不能在类定义的外部使用,只能在类定义的方法中使用

  4. this 关键字可以用来调用本类的构造器以及指向当前对象

  5. super 与 this 的对比

    区别点thissuper
    方法访问本类属性,没有则依次查找父类直接依次查找父类属性
    属性访问本类方法,没有则依次查找父类直接依次查找父类方法
    构造器行首调用本类其它构造器行首调用父类指定构造器
    特殊表示当前对象表示子类中访问父类的对象 区别点
2.7 == 和 equals()
作用
==判断基本类型时判断值是否相等;判断引用类型时判断是否引用到同一个对象
equals()只能判断引用类型是否引用到同一个对象,子类往往重写
2.8 重写和重载
  1. 子类重写父类的方法时,返回类型可以是父类或父类的子类
  2. 重写方法时子类不能缩小父类方法的访问权限
  3. 方法重载需保证方法签名不同,返回值不是方法签名的一部分
2.9 可变参数
  1. 可变参数的实参可以是 0 个或是多个,其本质就是数组
  2. 形参列表中可以同时有普通形参和可变参数,但必须保证可变参数是形参列表的最后一个参数
  3. 一个方法的形参列表只能出现一个可变参数
2.10 动态绑定机制
  1. 当调用对象方法时,该方法会和该对象的内存地址(运行类型)动态绑定
  2. 当调用对象属性时,不存在动态绑定
  3. 多态是指:针对某个类型的方法调用,其真正执行的方法取决于运行时期实际类型的方法
2.11 字段与方法
  1. 类变量也即静态变量,类方法也即静态方法
  2. JDK8 以前类变量放在方法区的静态域中,JDK8 以后放在堆的对应类的 class 对象尾部
  3. 当方法中不涉及到与任何对象相关的成员时,则可以将方法设计为静态方法以提高运行效率
  4. 静态代码块、静态方法只能调用静态成员,普通方法和普通代码块可以调用任何成员
  5. 静态方法属于类而不属于类实例,因此在静态方法内部无法访问 this 变量,也无法访问实例字段,只能访问静态字段和静态实例
2.12 代码块和类加载
  1. 代码块可以理解为只有方法体的方法,它没有方法名、返回值、参数,不能通过对象或类显式调用,只有在加载类或是创建对象时隐式调用

  2. 代码块的修饰符只能是 static 或无修饰符,块体中的语句可以是任何正确逻辑语句

  3. 如果只是调用类的静态成员,普通代码块并不会执行,普通代码块可以看作是构造器的一种补充机制,所以在调用类的静态成员但没有创建类的对象时,构造器并未被调用,因而类的普通代码块不会被执行

    class GirlFriend {
       public static final int AGE = 2;
       // 当使用到 GirlFriend.AGE 时,此静态代码块不会执行即此类未加载
       static {
           System.out.println("I am your only girlfriend");
       }
    }
    
  4. 类代码块的执行顺序优先于构造器

  5. 类加载时机:创建该类的对象时、创建子类的对象时父类也会加载、使用类的静态成员时

2.13 Java 代码执行顺序
  1. 父类的静态代码块和静态属性按定义顺序依次执行
  2. 子类的静态代码块和静态属性按定义顺序依次执行
  3. 父类的普通代码块与普通属性按定义顺序依次执行
  4. 父类的构造器
  5. 子类的普通代码块与普通属性按定义顺序依次执行
  6. 子类的构造器
2.14 单例设计模式
  1. 设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格以及解决问题的思考方式。设计模式好比经典的棋谱,不同的棋局采用不同的棋谱,免去再次思考和摸索的过程

  2. 类的单例设计模式:采取一定的方法使得在整个软件系统中,某个类有且仅有一个对象实例,并且该类只提供一个取得该对象的方法

  3. 单例设计模式分为饿汉式和懒汉式,饿汉式与懒汉式的区别:饿汉式在类加载时就创建实例而懒汉式在使用到对象时才创建。饿汉式不存在线程安全问题,懒汉式存在线程安全问题

  4. 单例模式的实现

    1. 构造器私有化
    2. 在类的内部创建对象
    3. 向外部提供一个静态的公共方法取得该对象
    // 单例设计模式饿汉式
    class GirlFriend {
       private GirlFriend() {}
       private static final GirlFriend girlFriend = new GirlFriend();
       public static GirlFriend getGirlFriend() {
           return girlFriend;
       }
    }
    
    // 单例设计模式懒汉式
    class GirlFriend {
       private GirlFriend() {}
       private static GirlFriend girlFriend;
       public static GirlFriend getGirlFriend() {
           if (girlFriend == null) {
               girlFriend = new GirlFriend();
           }
           return girlFriend;
       }
    }
    
  5. java.lang.Runtime 类就是经典的懒汉式单例模式

    public class Runtime {
       private static Runtime currentRuntime = new Runtime();
    
       
       public static Runtime getRuntime() {
           return currentRuntime;
       }
    
       
       private Runtime() {}
    }
    
2.15 final
  1. final 的使用场景:不希望某个类被继承、不希望父类的方法被子类重写、不希望类的成员值被修改、不希望局部变量的值被修改

  2. final 修饰的属性必须初始化,此后无法更改。初始化可在三个地方进行:定义时初始化、构造器中初始化、代码块中初始化(如果 final 修饰的属性同时是 static 的,那么只能在两个地方初始化:定义时初始化、静态代码块中初始化)

    public static final int MAX = 9;
    public static final int MIN;
    
    static {
        MIN = -1;
    }
    
  3. 如果非 final 类中含有 final 修饰的方法,则该方法可以被继承但不能被重写

  4. final 往往和 static 搭配使用,效率更高,因为底层编译器做了优化处理,不会导致类的加载

2.16 抽象类
  1. 当父类的某些方法需要被声明,但又不确定如何实现时,可以将其声明为抽象方法,那么这个类就是抽象类

  2. 有抽象方法的类一定是抽象类,抽象类不一定有抽象方法,abstract 只可以修饰类和方法

    public abstract class Node {
        public int getMax() {
            return 100;
        }
    }
    
  3. 如果一个类继承自抽象类,则必须实现父类的所有抽象方法,除非它也是一个抽象类

  4. 抽象方法不能使用 private、final、static 来修饰,因为这些修饰符与重写相违背

2.17 接口
  1. JDK8 之前的版本,接口中所有的方法都没有方法体即全是抽象方法。JDK8 及之后的版本,接口中可以有静态字段(默认是 static final)、默认方法

    public interface Study{
       default public void english() {
           System.out.println("Study english");
       }
       public static void math() {
           System.out.println("Study math");
       }
    }
    
  2. 抽象类实现接口可以不用实现方法、接口继承接口时可以不用实现方法

  3. 继承与接口对比:继承解决代码的复用性与可维护性,而接口用来设计规范方法,一定程度上实现代码解耦

  4. Java 的接口特指 interface 的定义,表示一个接口类型和一组方法签名,而编程接口泛指接口规范,如方法签名,数据格式,网络协议等

2.18 内部类
  1. 局部内部类:定义在外部类的局部位置且有类名,比如方法或代码块中,具有以下特点

    1. 内部类可以直接访问外部类的所有成员,包括私有的
    2. 不可以添加访问修饰符,可以添加 final
    3. 局部内部类可以理解为方法的局部变量
    4. 如果外部类和局部内部类的成员重名时,默认遵循就近原则。若想访问外部类的成员,可以使用 外部类名.this.成员 的方式去访问
    class Outer {
       private String name = "Spring-_-Bear";
       public void m1() {
           class Inner {
               private String name = "springbear";
               private void test() {
                   // 调用局部内部类的成员
                   System.out.println(name);
                   // 调用外部类的成员
                   System.out.println(Outer.this.name);
               }
           }
           // 调用局部内部类的方法
           new Inner().test();
       }
    }
    
  2. 匿名内部类:定义在外部类的局部位置,比如方法中且没有类名,同时还是一个对象

    1. 匿名内部类本身既是一个类的定义同时也是一个对象,因而从语法层面看,它既有类的特征也有对象的特征
    2. 只能定义在方法或代码块中,匿名内部类的地位就好比一个没有名字的局部变量
    3. 经典使用场景:在方法参数位置直接实现接口当作实参传递,简洁高效不冗余
    public class C02 {
       public static void main(String[] args) {
           // 方式1
           I03 i03 = new I03() {
               @Override
               public void cry() {
                   System.out.println("呜呜呜~~~");
               }
           };
           i03.cry();
           // 匿名内部类的类名:I03
           System.out.println(i03.getClass());
       }
    
       // 方式2
       new I03() {
               @Override
               public void cry() {
                   System.out.println("呜呜呜~~~");
               }
       }.cry();
    }
    
    interface I03{
       void cry();
    }
    
  3. 成员内部类:成员内部类可以理解为类的成员

    public class C02 {
       public static void main(String[] args) {
           new Outer().new Inner().m();
       }
    }
    
    class Outer {
       private String name = "Spring-_-Bear";
       // 成员内部类
       public class Inner {
           public void m() {
               System.out.println(name);
           }
       }
    }
    
  4. 静态内部类:静态内部类可以理解类的静态成员,可以直接访问外部类的所有静态成员,但不能访问非静态成员

三、枚举 3.1 自定义枚举类
  1. 枚举定义:枚举是一组常量的集合,属于一种特殊的类,里面只包含一组有限的特定对象

  2. 自定义枚举类:构造器私有化、不提供 setXxx() 方法、对枚举属性使用 statc + final 修饰以实现底层优化

    class Season {
       private final String name;
       private final String description;
    
       public static final Season SPRING = new Season("春天", "温暖");
       public static final Season SUMMER = new Season("夏天", "炎热");
       public static final Season AUTUMN = new Season("秋天", "凉爽");
       public static final Season WINTER = new Season("冬天", "寒冷");
    
       private Season(String name, String description) {
           this.name = name;
           this.description = description;
       }
    }
    
3.2 enum 枚举类
  1. enum 作为一个特殊的类已经继承了 Enum 类,所以不能继承其它类,但可以实现接口

    public enum Season {
       // 必须位于行首且以逗号间隔,分号结尾,如果使用的是无参构造器创建枚举对象,则括号可以省略
       SPRING("春天", "温暖"),
       SUMMER("夏天", "炎热"),
       AUTUMN("秋天", "凉爽"),
       WINTER("冬天", "寒冷");
    
       private final String name;
       private final String description;
    
       private Season(String name, String description) {
           this.name = name;
           this.description = description;
       }
    }
    
  2. 使用 enum 关键字开发一个枚举类时,该类是一个 final 类并且默认继承 Enum 类

3.3 Enum 类成员方法
方法名功能
toString()返回当前对象名,子类可重写
name()返回当前对象常量名,子类不可重写
ordinal()返回当前对象的索引号,默认从 0 开始
values()返回当前枚举类中的所有常量
valueOf()将字符串转换枚举对象
compareTo()比较两个枚举常量的索引号
四、注解 4.1 注解介绍
  1. 注解(Annotation)也称为元数据(Metadata),用于修饰解释包、类、方法、属性、构造器、局部变量等数据信息
  2. 与注释一样,注解不影响程序逻辑,但注解可以被编译或运行,相当于嵌入在代码中的补充信息
  3. 在 Java SE 中,注解的使用目的比较简单,例如标记过时的方法、忽略警告等。但注解在 Java EE 中注解占据重要角色,例如用来配置应用程序的任何切面、代替 Java EE 旧版中所遗留的冗杂代码和 XML 配置等
4.2 @Override

重写方法时如果添加了 @Override 注解,则编译器就会检查是否真的重写了父类的方法,如果未重写则编译报错

// @Target(ElementType.METHOD) 是修饰注解的注解,称为元注解,用于说明此注解作用位置
@Target(ElementType.METHOD)
// @Retention(RetentionPolicy.SOURCE) 也是元注解,说明此注解的作用域(源码、运行时···)
@Retention(RetentionPolicy.SOURCE)
// @interface 并不指此类是接口,而是说明此类是注解类,在 JDK1.5 之后加入
public @interface Override {
}
4.3 @Deprecated
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE})
public @interface Deprecated {
}
4.4 @SupressWarning
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.SOURCE)
public @interface SuppressWarnings {
   String[] value();
}
4.5 四种元注解
// 指定注解的作用域:SOURCE、CLASS、RUNTIME
@Retention	

// 指定注解使用的使用位置	      
@Target	

// 指定注解在 javadoc 中体现,使用 @Documented 元注解的注解 @Retention 作用域必须为 RUNTIME
@Documented

// 指定子类可以继承父类的注解	
@Inherited		       
五、异常 5.1 异常分类及体系图
  1. Error(错误):Java 虚拟机无法解决的严重问题,如 JVM 系统内部错误、资源耗尽等严重情况
  2. Exception(异常):其它因编程错误或偶然的外在因素导致的一般性问题,可以使用针对性的代码进行处理。分为编译时异常和运行时异常

5.2 try-catch-finally-return
  1. 如果出现异常,则 try 块中发生异常语句后的语句不再执行。若有可能抛出异常而未处理,则由 JVM 打印异常信息后退出程序

  2. 若在 finally 块中返回,则 try 或 catch 块中的 return 动作必定不会执行

    public int method() {
       int i = 1;
       try {
    	       i++;
    	       String[] names = new String[3];
    	       if (names[i].equals("lcx")) {
    	       }
    	       return i;
       } catch (NullPointerException e) {
           return ++i;
       } finally {
           // return result: 4
           return ++i;
       }
    }
    
    public int method1() {
       int i = 1;
       try {
           i++;
           String[] names = new String[3];
           if (names[i].equals("lcx")) {
           }
           return i;
       } catch (NullPointerException e) {
           // return result: 3
           return ++i;
       } finally {
           ++i;
       }
    }
    
5.3 自定义异常
  1. 如果继承 Exception,则属于编译异常,必须显式处理或抛出
  2. 如果继承 RuntimeException,则属于运行时异常,可以默认 throws 处理,较为方便
5.4 throws 和 throw 的区别
  1. 如果一个方法中的语句执行时可能生成某种异常,但不能确定如何处理这种异常,则可以在方法声明处显式地抛出异常,由调用者自行处理

  2. 编译异常必须处理,对于运行时异常,如不处理则默认 throws

  3. 子类重写父类的方法时,子类抛出的异常需小于等于父类定义的异常类型

  4. throws 和 throw 的比较

    意义位置抛出内容
    throws异常处理的一种方式方法声明处异常类型
    throw手动生成异常对象方法体中异常对象
六、常用类 6.1 包装类体系图

八大包装类都是 final 类型的。除 Boolean 和 Character 外,其余包装类均继承父类 Number

6.2 装箱与拆箱

jdk5 以前是手动装箱和拆箱。自动装箱底层调用的是对应包装类的 valueOf() 方法

// 手动装箱
Integer integer = Integer.valueOf(i);
// 手动拆箱
int ii = integer.intValue();
6.3 包装类与 String 间转换
  1. 包装类转 String

    Integer i = 100;
    // 方式 1
    String str = i + "";
    // 方式 2
    String str = i.toString();
    // 方式 3
    String str = String.valueOf(i);
    
  2. String 转包装类

    String str = "123";
    // 方式 1
    Integer i = Integer.parseInt(str);
    // 方式 2 
    Integer i = new Integer(str);
    
6.4 Integer 的创建机制

自动装箱机制,在 [-128,127] 范围内直接返回,否则 new Integer(i)

// JDK 装箱源码说明
public static Integer valueOf(int i) {
   if (i >= IntegerCache.low && i <= IntegerCache.high)
       return IntegerCache.cache[i + (-IntegerCache.low)];
   return new Integer(i);
}

// 经典例题
Integer i = new Integer(1);
Integer ii = new Integer(1);
// false
System.out.println(i == ii);

Integer j = 1;
Integer jj = 1;
// true
System.out.println(j == jj);

Integer k = 128;
Integer kk = 128;
// false
System.out.println(k == kk);


Integer i = 127;
int ii = 127;
// true
System.out.println(i == ii);

Integer j = 128;
int jj = 128;
// true
System.out.println(j == jj);
6.5 String 的创建机制
  1. 创建方式一:String s1 = "lcx"; 先从常量池查找是否有 “lcx” 数据空间,如果有,直接将 s1 指向 “lcx”;没有则新建后指向,s1 最终指向的是常量池的空间地址

  2. 创建方式二:String s2 = new String("lcx"); 先在堆中创建空间,维护了 String 的字段 value[] 属性,然后判断常量池中是否有 “lcx” 的数据空间。如果常量池没有 “lcx”,则新建后使用 value 指向;如果有,则 value 直接指向。s2 最终指向的是堆中 value 的地址

  3. 两种创建方式的内存布局图

  4. 经典面试题说明 String 的创建机制

    // Test 1
    String a = "lcx";
    String b = new String("lcx");
    // true:a 指向常量池中 "lcx" 的地址,b.intern() 返回常量池中 "lcx" 的地址
    System.out.println(a == b.intern());
    // false:b 返回 String 类的字段 value[] 的地址
    System.out.println(b == b.intern());
    
    // Test 2
    String s1 = new String("abc");
    String s2 = new String("abc");
    // false:s1,s2 -> 不同的 value[]
    System.out.println(s1 == s2);
    // true:引用到常量池的同一个地址
    System.out.println(s1.intern() == s2.intern());
    
6.6 String 的相加

常量相加看池,变量相加看堆

// Test 1
// 只创建了一个字符串常量 "hello123"
String a = "hello" + "123";
// b -> 常量池的 "hello"
String b = "hello";
// c -> 常量池的 "123"
String c = "123";
// d -> 堆中 value,value 指向常量池中的 "hello123"
// b + c 的底层实现:调用 StringBuilder 的 append 方法连接两次,然后再 new String() 返回
String d = b + c;

// Test 2
public class Test {
    // str 指向堆中的 value,value 指向常量池中的 "lcx"
    String str = new String("lcx");
    // 字符数组对象存放于堆中
    final char[] ch = {'j','a','v','a'};
    
    // change 方法中的 str 指向常量池空间中的字符串
    public void change(String str, char[] ch) {
       // 在常量池中新建 "java" 的数据空间,栈中的 str 指向 "java"
       str = "java";
       // 栈中的 ch 指向队中的 final char[] ch
       ch[0] = 'h';
    }
    public static void main(String[] args) {
       Test test = new Test();
       test.change(test.str, test.ch);
       // Output result: lcx and hava
       System.out.print(test.str + " and " + test.ch);
    }
}

6.7 StringBuffer
  1. StringBuffer 是一个线程安全的 final 类,其字段 value[] 不是 final 类型的
  2. String 保存的是字符串常量,value 引用到常量池。而 StringBuffer 保存的是字符串变量,数据存放在堆中
  3. StringBuffer value[] 无参构造器默认初始化容量为 16。若构造器传入的是字符串,则初始化容量为字符串长度加上 16
  4. StringBuilder 线程不安全,与 StringBuffer 使用方法基本一致

  1. StringBuffer 的 append() 方法

    String str = null;
    
    StringBuffer stringBuffer = new StringBuffer();
    // append 方法可以追加空串
    stringBuffer.append(str);
    // Output:null
    System.out.println(stringBuffer);
    
    // 构造器不允许传入空,否则抛出 NullPointerException
    StringBuffer stringBuffer1 = new StringBuffer(str);
    System.out.println(stringBuffer1);
    
6.8 Arrays
  1. 使用 Arrays.binarySearch() 方法对有序数组进行二分查找时,若不存在该元素,则返回该元素应在数组中位置下标的负值

  2. Arrays.asList() 可以将数组转换为 List 类型的集合,运行类型为 Arrays$ArrayList,即 Arrays 类中的静态内部类 ArrayList

  3. 模拟 Arrays.sort(int[], Comparator) 排序

    import java.util.Arrays;
    import java.util.Comparator;
    
    
    public class Test {
       public static void main(String[] args) {
           Integer[] arrays = new Integer[]{1, 31, 523, 452, 13, 64, 23, 75};
           Test test = new Test();
           // 面向接口编程 + 动态绑定(多态)
           test.bubble(arrays, new Comparator() {
               @Override
               public int compare(Integer o1, Integer o2) {
                   return o1 - o2;
               }
           });
           System.out.println(Arrays.toString(arrays));
       }
    
       public void bubble(Integer[] arrays, Comparator comparator) {
           int len = arrays.length;
           for (int i = 0; i < len - 1; i++) {
               for (int j = 0; j < len - 1 - i; j++) {
                   if (comparator.compare(arrays[j], arrays[j + 1]) > 0) {
                       int temp = arrays[j];
                       arrays[j] = arrays[j + 1];
                       arrays[j + 1] = temp;
                   }
               }
           }
       }
    }
    
6.9 BigDecimal
BigDecimal bigDecimal = new BigDecimal("242131.24321335243234123");
// 为避免结果为无限循环小数,可对结果指定精度以解决 ArithmeticException
BigDecimal res = bigDecimal.divide(new BigDecimal(1.1), BigDecimal.ROUND_CEILING);
System.out.println(res);
6.10 第二、三代日期类
  1. JDK1.0 中出现的 java.util.Date 类,大多数方法在 jdk 1.1 引入的 Calendar 类中已被弃用,第二代日期类 Calendar 也存在着以下一些问题

    1. 可变性:像日期和时间这样的类应该是不可变的
    2. 偏移性:年份从 1900 开始,月份从 0 开始
    3. 格式化:不能对 Calendar 进行格式化
    4. 线程不安全,不能处理闰秒(每隔两天,多出 1s)
  2. JDK8 引入了第三代日期类:LocalDate(日期)、LocalTime(时间)、LocalDateTime(日期时间)

    LocalDateTime now = LocalDateTime.now();
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy:MM:dd HH:mm:ss");
    System.out.println(formatter.format(now));
    
七、集合 7.1 集合体系图
  1. Collection 集合体系图

  2. Map 集合体系图

7.2 Collection 与 Iterator
  1. Collection 接口没有直接的实现子类,是通过它的子接口 Set 和 List 的实现类功能的

    // 只要是 Collection 接口的实现类都可以做实参
    boolean addAll(Collection c);
    boolean removeAll(Collection c);
    boolean containsAll(Collection c);
    
  2. Iterator 对象称为迭代器,主要用于遍历 Collection 集合中的元素。所有实现了 Collection 接口的集合类都有一个 iterator() 方法,用以返回一个实现了 Iterator 接口的对象即返回一个迭代器

    // 得到某个集合的迭代器
    Iterator iterator = collection.iterator();
    // 判断是否还有下一个元素
    while(iterator.hasNext()){
       System.out.println(iterator.next());
    }
    
  3. Iterator 对象仅用于遍历集合,本身并不存放数据对象。使用增强 for 循环遍历集合时,底层仍然使用的 Iterator 进行遍历

7.3 List

实现 List 的集合类中的元素有序(加入顺序与取出顺序一致),允许存在重复,支持使用对应的索引值直接获取元素的值(与数组使用方式类似,优点是可动态扩充大小)

// 在索引为 index 的位置插入 element,后续元素后移
void add(int index, E element);
// 指定起始索引的子集合 [fromIndex,toIndex)
List subList(int fromIndex, int toIndex);
7.4 ArrayList
  1. ArrayList 底层维护了一个 Object 类型的数组transient Object[] elementData;

  2. ArrayList 扩容机制:创建对象时使用无参构造器,则 elementData 初始容量为 0,第 1 次添加后设置容量为 10,此后按照 elementData 容量的 1.5 倍进行扩容。创建对象时指定了容量,则 elementData 的初始容量为指定大小,需要扩容时按照 1.5 进行扩容

    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);
    }
    
  3. ArrayList 可以添加多个 null 元素,用法基本等同于 Vector,但 ArrayList 线程不安全而 Vector 线程安全

7.5 Vector
  1. Vector 底层存维护了一个对象数组即 protected Object[] elementData;,Vectory 同 ArrayList 一样也允许添加多个 null 元素且操作线程安全

  2. Vector 的扩容机制:创建 Vector 的对象时若使用无参构造器,则默认初始化容量为 0,当第 1 次添加元素时设置容量大小为 10,此后按 2 倍扩容;若使用了有参构造器,则初始容量为指定大小,此后按照 2 倍扩容

    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);
    }
    
7.6 LinkedList
  1. LinkedList 具有双向链表和双端队列特点,线程不安全。同 ArrayList、Vectory 一样,LinkedList 允许元素重复且可以添加多个 null 元素

  2. LinkedList 底层维护了一个双向链表,类中有两个属性 transient Node first 和 transient Node last 分别指向头节点和尾节点。每个节点中又维护了 prev、next、item 三个属性,所以 LinkedList 元素的增加与删除效率较高

    public class LinkedList ...... {
        // 头指针和尾指针
        transient Node first;
        transient Node last;
        
        // LinkedList 的静态内部类 Node
        private static class Node {
            E item;
            Node next;
            Node prev;
    
            Node(Node prev, E element, Node next) {
                this.item = element;
                this.next = next;
                this.prev = prev;
            }
        }
    }
    
  3. LinkedList 尾添加元素操作

    // 添加新节点到表尾
    void linkLast(E e) {
       // 先获取到尾指针
       final Node l = last;
        // 新添加的节点
       final Node newNode = new Node<>(l, e, null);
       // 尾指针指向新加入的节点
       last = newNode;
       // 将新节点连接到链表尾
       if (l == null)
           first = newNode;
       else
           l.next = newNode;
       size++;
       modCount++;
    }
    
  4. LinkedList 头移除元素操作

    // 移除头节点
    private E unlinkFirst(Node f) {
       // assert f == first && f != null;
       // 头节点元素
       final E element = f.item;
       // 第二个节点
       final Node next = f.next;
       f.item = null;
       f.next = null; // help GC
       // 头指针指向当前头节点 element 的下一个节点 next
       first = next;
       if (next == null)
           last = null;
       else
           next.prev = null;
       size--;
       modCount++;
       return element;
    }
    
7.7 Set

Set 中的元素无序(hash 后确定存储位置),不存在索引,因而只有两种遍历方式(Interator 与 增强 for)。Set 不允许重复元素,故最多只包含一个 null

// 1. 增强 for 遍历 Set
for (Integer integer : set) {
    System.out.println(integer);
}

// 2. Iterator 遍历 Set
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}
7.8 HashSet
  1. HashSet 的底层使用的是 HashMap,JDK1.8 版本的 HashMap 底层是【数组 + 链表 + 红黑树】,而 JDK1.7 版本的 HashMap 底层是【数组 + 链表】。默认初始化大小为 16,扩容加载因子为 0.75

    public HashSet() {
       map = new HashMap<>();
    }
    
  2. HashMap 存储形式为键值对,所以在 HashSet 采用 HaspMap 实现存储时,value 为系统给定的 PRESENT

    // Dummy value to associate with an Object in the backing Map
    private static final Object PRESENT = new Object();
    
  3. HashMap 元素的存放过程

    1. 先通过 HashMap 类的静态方法 hash(Object) 获得本次元素的 hash 值
    // 确定元素 hash 值的算法
    static final int hash(Object key) {
       int h;
       // key 的 hashCode 与 key 的 hashCode 无符号右移 16 位的值做按位异或运算得到元素的 hash 值
       return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }
    
    1. 将 hash 值与本次哈希表大小 -1 的值进行按位与运算获得本次添加的元素在哈希表中的位置号,若该位置上没有其它元素则直接存放
    // 用本次哈希表长度减 1 与本次元素的 hash 值进行按位与运算获得元素在哈希表中的位置号
    if ((p = tab[i = (n - 1) & hash]) == null)
     // 位置号上未存储元素则直接存放
     tab[i] = newNode(hash, key, value, null);
    
    1. 位置上已经存在元素,则遍历该条链表判断是否已经存在相同元素,若已存在则不添加并且返回元素值,否则创建新的节点连接到链表尾。完整存放过程如下
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
       Node[] tab; Node p; int n, i;
       // 第一次扩容:table 为 HashMap 的静态内部类 Node 类型的数组 transient Node[] table;
       if ((tab = table) == null || (n = tab.length) == 0)
           n = (tab = resize()).length; 
    
       // 用本次哈希表长度减 1 与本次元素的 hash 值进行按位与运算获得元素在哈希表中的位置号
       if ((p = tab[i = (n - 1) & hash]) == null)
           // 位置号上未存储元素则直接存放
           tab[i] = newNode(hash, key, value, null);
       else {
           // 位置号上已经存放元素,判断当前要添加的元素是否存在相同元素
           Node e; K k;
           // 如果当前元素的 hash 值与哈希表位置号上元素的 hash 值相同且值相同(引用相同)或者要添加的元素不为空且 equals 比较相同,则要添加的元素与当前位置号上的元素相同
           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个,是则进行树化条件判断
                       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;
               }
           }
           // 当前要添加的元素已存在,则不添加,返回旧值(新旧交替)
           if (e != null) { // existing mapping for key
               V oldValue = e.value;
               if (!onlyIfAbsent || oldValue == null)
                   e.value = value;
               afterNodeAccess(e);
               return oldValue;
           }
       }
       ++modCount;
       // size 为哈希表中的元素个数,判断加入的元素个数是否不小于临界值,是则对哈希表进行扩容
       if (++size > threshold)
           resize();
       // HashMap 的空方法,留给子类实现以扩展功能	
       afterNodeInsertion(evict);
       // 返回 null 代表元素添加成功
       return null;
    }
    
  4. HashMap 的扩容机制:第一次添加时 transient Node[] table; 扩容到 DEFAULT_INITIAL_CAPACITY 16,加载因子为 loadFactor 0.75,临界值为 threshold 12,如果 table 已添加元素个数 size 不小于 threshold,则 table 按照 2 倍方式扩容到 32,临界值为 24,依次类推

  5. 树化条件:在 Java8 中,如果哈希表的大小 >= 64 且某条链表的长度 >= 8 则将该条链表树化为红黑树

    static final int MIN_TREEIFY_CAPACITY = 64;
    static final int TREEIFY_THRESHOLD = 8;
    
7.9 LinkedHashSet
  1. LinkedHashSet 继承自 HashSet,底层使用了 LinkedHashMap。LinkedHashMap 底层维护了一个【数组 + 双向链表】,数组的类型是 HashMap$Node[],其中存放的元素是 LinkedHashMap$Entry 类型,在 HashMap 的数据结构基础之上,增加了一个双向链表用来记录元素的添加顺序,使得元素看起来是以插入顺序保存的

    // LinkedHashMap$Entry
    static class Entry extends HashMap.Node {
        Entry before, after;
        Entry(int hash, K key, V value, Node next) {
            super(hash, key, value, next);
        }
    }
    
  2. LinkedHashMap 有 head 和 tail 指针,使用使用头尾指针遍历 linkedHashSet 时取出元素的顺序与插入元素的顺序一致

    transient LinkedHashMap.Entry head;
    transient LinkedHashMap.Entry tail;
    
  3. 元素插入、取出过程与 HashMap 基本一致,额外增加了维护双向链表的过程

7.10 Map
  1. Map 与 Collection 接口并列存在,用于保存具有映射关系的键值对:key - value,Map 中的 key 和 value 可以是任何引用类型

  2. Map 中的 key 不允许重复,value 可以重复。key 最多有一个 null,而 value 可以有多个 null。当 key 相同而 value 不同时,用新的 value 替换旧的 value

  3. key 和 value 的单独遍历:key - value 的值实际存放到 HashMap$Node 中,为方便单独遍历 key 或 value,使用 KeySet(Set 类型) 引用到 Node 中所有的 key,使用 Values (Collection 类型)引用到所有的 value

    // HashMap$Node
    static class Node implements Map.Entry
    // KeySet
    final class KeySet extends AbstractSet
    //  Values
    final class Values extends AbstractCollection
        
    // 通过 KeySet 遍历所有的 key
    Set keySet = hashMap.keySet();
    for (Object object : keySet) {
       System.out.println("key = " + object);
    }
    // 通过 Values 遍历所有的 value
    Collection values = hashMap.values();
    for (Object value : values) {
       System.out.println(value);
    }
     

  4. 使用 EntrySet> 遍历 Map 集合:key - value 的值实际存放到 HashMap$Node 中,而 HashMap$Node 实现了 Map.Entry 接口,所以可通过 EntrySet 拿到每一个 Entry,再从 Entry 中依次取出 key 和 value

    // HashMap$Node
    static class Node implements Map.Entry
    // HashMap$EntrySet
    final class EntrySet extends AbstractSet>
        
    // 通过 Entry 遍历
    Set> entries = hashMap.entrySet();
    for (Map.Entry entry : entries) {
       System.out.println(entry);
       System.out.println("key = " + entry.getKey());
       System.out.println("value = " + entry.getValue());
    }
    
  5. 7.11 HashMap

    HashMap 是线程不安全的 key-value 键值对集合,数据 key-value 封装在 HashMap$Node 中。JDK8 版本以下的 HashMap 底层实现是【哈希表 + 链表】,JDK8.0 版本及以上是【哈希表 + 链表 + 红黑树】,树化条件是哈希表长度不小于 64 且某颗链表的长度不小于 8 就将该颗链表树化为红黑树。当然,若某颗红黑树元素个数较少,则会触发剪枝行为即将红黑树重新转换为链表

    7.12 Hashtable
    1. Hashtable 的键和值都不能为 null,为 null 则抛出 NullPointerException,使用方法与 HashMap 基本一致。Hashtable 线程安全,而 HashMap 线程不安全

    2. Hashtable 扩容机制:初始化容量大小为 11,数组类型为 Hashtable$Entry,加载因子 loadFactor 0.75,按原有容量的 2 倍加 1 的机制进行扩容

      // overflow-conscious code
      int newCapacity = (oldCapacity << 1) + 1;
      
    7.13 TreeMap
    1. TreeSet 的底层使用 TreeMap,TreeMap 实现了 SortedMap 接口,即 TreeMap 中插入的元素是有顺序的
    2. 使用TreeMap时,放入的 Key 必须实现Comparable接口以自定义元素比较规则从而实现元素排序
    7.14 HashMap 和 TreeMap 的去重机制
    1. HashSet 的去重机制:获得对象的 hashCode 值,经过 return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); 运算得到该对象的 hash 值,用 if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) 判断是否添加
    2. TreeMap 的去重机制:如果传入了 Comparator 匿名对象,则使用实现的 compare 方法中的比较方式去重,compare 方法返回 0 则认为是相同的元素。如果没有传入匿名比较器对象,则以所要添加的对象实现的 Comparaeable 接口的 compareTo 方法比较机制去重
    7.15 集合选择
    1. 单个对象且允许重复选择 List

    应用场景集合选择底层结构备注
    改查多ArrayListObject[]默认 size = 0,第一次添加 size = 10,按 1.5 倍扩容
    增删多LinkedList双向链表
    多线程VectorObject[]默认 size = 0,第一次添加 size = 10,按 2 倍扩容,键值均不允许为 null
    1. 单个对象且不允许重复选择 Set

    应用场景集合选择底层使用备注
    无顺序要求HashSetHashMap
    添加、取出顺序一致LinkedHashSetLinkedHashMap继承自 HashSet
    元素有序排列TreeSetTreeMap
    1. 键值对 key-value 选择 Map

    应用场景集合选择底层结构备注
    键顺序无要求HashMap数组+链表+红黑树size = 16,loadFactor = 0.75,按 2 倍扩容
    插入、取出顺序一致LinkedHashMap数组 + 双向链表继承自 HashMap
    多线程Hashtable数组+链表+红黑树size = 11,loadFactor = 0.75,按 2倍 + 1 扩容,不允许 null
    配置文件Properties数组+链表+红黑树继承自 Hashtable
    键有序存放TreeMap红黑树?
    7.16 Collections 工具类

    Collections 是一个操作 Set、List、Map 等集合的工具类,提供了一系列的静态方法对集合进行操作

    方法名功能
    reverse(List)反转 List 中的元素顺序
    shuffle(List)对 List 中的元素进行随机排序
    sort(List)按元素自然顺序方式对 List 中的元素排序
    sort(List,Comparator)根据 Comparator 的顺序对 List 中的元素排序
    swap(List,int,int)对 List 中的两个元素交换顺序
    max(Collection)自然顺序找出集合中的最大元素
    max(Collection,Comparator)指定排序找出集合中的最大元素
    frequency(Collection, Object)某个元素在集合中的出现次数
    copy(List,List)List 拷贝
    replaceAll(List,Object,Object)用新的 Object 替换指定的 Object
    八、泛型 8.1 泛型介绍
    1. 泛型使用与否:不使用泛型的弊端:不能对加入到集合中的数据类型进行约束(不安全)、遍历集合时需要进行显式类型转换;使用泛型的好处:编译时检查元素的类型,提高了安全性、减少了类型转换的次数,提高了运行效率
    2. 泛型又称参数化类型,是 jdk5.0 出现的新特性,解决数据类型的安全性问题,只需在类声明或实例化时指定具体需要的类型即可,编译期即可确定类型
    3. Java 泛型保证在编译期没有发出警告的代码,在运行阶段就不会发生类转换异常,使得代码更加简洁与健壮
    4. 泛型的使用规则:可以在类声明时通过一个标识符表示类中某个属性的类型、或者是某个方法的返回值类型、或者是参数类型。指定泛型类型时只能是引用类型。在给泛型指定具体类型后,可以传入该类型或其子类类型。省略指定泛型类型时,默认填充 Object
    8.2 泛型的类型
    1. :支持任意泛型类型
    2. :支持 A 类以及 A 的子类,规定了泛型的上限
    3. :支持 A 类以及 A 的父类,不限定于直接父类,规定了泛型的下限
    8.3 自定义泛型
    1. 自定义泛型的注意事项:

      1. 静态方法、静态字段中不能使用类的泛型

      2. 使用泛型的数组,不能进行初始化

      3. 泛型不具备继承性,即以下代码语法错误 // List lists = new ArrayList();

      4. 泛型方法可以定义在普通类中、也可以定义在泛型类中;泛型接口的类型,在继承接口或是实现接口时确定

        public class Generic {
            private R r;
        
            public R getR() {
                return r;
            }
        
            // 泛型方法
            public  T getT(T t) {
                return t;
            }
        }
        
        interface IGeneric {
            T getT();
        }
        
        // 实现接口时指定接口的泛型
        class GenericImpl implements IGeneric {
            @Override
            public Integer getT() {
                return 3;
            }
        }
        
        // 继承接口时指定接口的泛型
        interface IGeneric2 extends IGeneric {
        }
        
      5. 九、多线程 9.1 进程、线程、并发、并行
        1. 进程是程序的一次执行过程,或是正在进行的一个程序。是动态过程,有其自身的产生、存在和消亡过程

        2. 线程是由进程创建的,是进程的一个实体,一个进程可以拥有多个线程

        3. 并发:同一个时刻,多个任务交替执行,造成一种 “貌似同时” 的错觉。简单地说,单核 CPU 实现的多任务就是并发

        4. 并行:同一个时刻,多个任务同时执行,多核 CPU 实现的多任务就是并行

        5. Java 获取系统的处理器个数

          // 获取 JVM 可用处理器个数
          Runtime runTime = Runtime.getRuntime();
          System.out.println(runTime.availableProcessors());
          
        9.2 创建线程的两种方式
        1. 继承 Thread 类创建线程

          public class ThreadEx extends Thread {
              // 当启动程序时理解为开启了一个进程,进程开启了 main 线程
              public static void main(String[] args) {
              // 在 main 线程中可以开启其它线程,只有当所有线程都消亡时,进程才结束
                  new Dog().start();
                  for (int i = 1; i <= 10; i++) {
                      try {
                          System.out.println(Thread.currentThread().getName() + i);
                          sleep(1000);
                      } catch (InterruptedException e) {
                          e.printStackTrace();
                      }
                  }
              }
          }
          
          class Dog extends Thread {
              @Override
              public void run() {
                  while (true) {
                      try {
                          System.out.println(Thread.currentThread().getName() + ":汪汪汪~~~");
                          sleep(1000);
                      } catch (InterruptedException e) {
                          e.printStackTrace();
                      }
                  }
              }
          }
          
        2. 实现 Runnable 接口创建线程

          1. Java 是单继承机制,若某个类已经存在父类,这时只能通过实现 Runnable 接口实现线程
          2. 实现 Runnable 接口的类不能直接调用 start() 方法,可以将对象作为 Thread(Runnable) 的参数,从而调用 start() 方法(静态代理设计模式)
          3. 实现 Runnable 接口方式更加适合多个线程共享某个资源的情况,并且避免了单继承的局限
          public class Thread02 {
              public static void main(String[] args) {
              // 静态代理设计模式
                  new Thread(new Cat()).start();
              }
          }
          
          class Cat implements Runnable {
              @Override
              public void run() {
                  while (true) {
                      System.out.println("喵喵喵~~~");
                      try {
                          Thread.sleep(1000);
                      } catch (InterruptedException e) {
                          e.printStackTrace();
                      }
                  }
              }
          }
          
        9.3 start() 与 run()
        1. new Dog().run() 与 new Dog().start() 的区别:前者只是单纯地调用 run() 方法,而后者启动了线程,在 start() 方法中实际调用了 start0() 方法,这是个 native 修饰的方法,真正实现了线程启动
        2. start() 方法调用了 start0() 方法后,该线程并不一定会马上执行,只是将线程变成了可运行状态,具体什么时候执行,取决于操作系统
        9.4 Thread 常用 API
        方法名功能
        setName(String)设置线程名
        getName()获取线程名
        start()启动线程
        run()调用线程对象的 run() 方法
        setPriority(int)设置线程优先级(1,5,10)
        getPriority()获得线程优先级
        sleep(long)休眠线程
        interrupt()中断线程,线程并未消亡
        public final static int MIN_PRIORITY = 1;
        
        
        public final static int NORM_PRIORITY = 5;
        
        
        public final static int MAX_PRIORITY = 10;
        
        9.5 线程插队与礼让
        方法名功能
        yield()线程礼让,让出 CPU 资源,但礼让时间不确定,是否礼让成功不确定,取决于 OS
        join()线程插队,一旦插队成功,则必须执行完插入线程的所有任务
        public class ThreadJoin {
            public static void main(String[] args) throws InterruptedException {
                Thread task = new Thread(new Task());
                task.start();
        
                for (int i = 1; i <= 20; i++) {
                    System.out.println(Thread.currentThread().getName() + ":" + i);
                    Thread.sleep(1000);
                    if (i == 3) {
                        // task 线程插队,一旦插队成功则需先执行完所有 task 任务
                        // task.join();
                        // main 线程礼让,不一定礼让成功
                        Thread.yield();
                    }
                }
            }
        }
        
        class Task implements Runnable {
            @Override
            public void run() {
                for (int i = 1; i <= 20; i++) {
                    System.out.println(Thread.currentThread().getName() + ":" + i);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
        
        9.6 守护线程
        1. 用户线程:也叫工作线程,当线程的任务执行完成后结束或以通知方式结束

        2. 守护线程:一般是为工作线程服务的,当所有的用户线程结束,守护线程自动结束(经典守护线程:垃圾回收机制)

        3. 守护线程案例

          public class ThreadDaemon {
              public static void main(String[] args) throws InterruptedException {
                  Thread task = new Thread(new Task());
                  // 设置为 main 线程的守护线程
                  task.setDaemon(true);
                  task.start();
                  Thread.sleep(5000);
                  // 工作线程结束,守护线程自动终止
                  System.out.println("妈妈回家了,小明结束写作业!");
              }
          }
          
          class Task implements Runnable {
              @Override
              public void run() {
                  while (true) {
                      System.out.println("小明写作业中···");
                      try {
                          Thread.sleep(1000);
                      } catch (InterruptedException e) {
                          e.printStackTrace();
                      }
                  }
              }
          }
          
        9.7 线程七大状态
        状态说明
        NEW尚未启动的线程处于此状态。 该状态线程对象被创建,但还未调用 start 方法
        RUNNABLE可运行线程的线程状态,细分为 Running 和 Ready 两个状态。处于可运行状态的线程可能正在 Java 虚拟机中执行,也可能正在等待来自操作系统的其他资源
        BLOCKED被阻塞等待监视器锁的线程处于此状态。处于该状态的线程正在等待获取一个监视器锁进入同步代码或方法;也可能是在调用了 Object.wait 后等待一个监视器锁重新进入同步代码或方法
        WAITING线程处于等待状态;处于该状态的线程可能是因为调用了Object.wait()、Thread.join()、LockSupport.park() 中的某一个方法;处于该状态的线程正在等待其他线程完成一些特定的操作
        TIMED_WAITING正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。线程处于定时等待状态,这个等待是有具有指定时间的;处于这个状态的线程可能是调用了具有指定时间的 Thread.sleep(long)、Object.wait(long)、Thread.join(long)、LockSupport.parkNanos()、LockSupport.parkUntil()
        TERMINATED已退出的线程处于此状态

        9.8 多线卖票问题
        1. 未使用同步锁出现超卖现象

          public class Ticket {
              public static void main(String[] args) {
                  // 共享总票数这一资源
                  SellTicket sellTicket = new SellTicket();
                  Thread thread = new Thread(sellTicket);
                  Thread thread1 = new Thread(sellTicket);
                  Thread thread2 = new Thread(sellTicket);
                  thread.start();
                  thread1.start();
                  thread2.start();
                  
              }
          }
          
          class SellTicket implements Runnable {
              private int ticketNum = 10;
          
              @Override
              public void run() {
                  while (true) {
                      if (ticketNum <= 0) {
                          System.out.println("售票结束···");
                          break;
                      }
                      try {
                          Thread.sleep(100);
                      } catch (InterruptedException e) {
                          e.printStackTrace();
                      }
                      System.out.println("窗口 " + Thread.currentThread().getName() + "售出一张票,余票:" + (--ticketNum));
                  }
              }
          }
          
        2. 锁方法,抱着锁睡觉,未均匀卖票,Why?执行任意一行输出即可均匀卖票?

          package edu.whut.bear.java.ticket.ticket2;
          
          
          public class Ticket {
              public static void main(String[] args) {
                  SellTicket sellTicket = new SellTicket();
                  new Thread(sellTicket).start();
                  new Thread(sellTicket).start();
                  new Thread(sellTicket).start();
                  new Thread(sellTicket).start();
                  new Thread(sellTicket).start();
                  new Thread(sellTicket).start();
                  new Thread(sellTicket).start();
                  new Thread(sellTicket).start();
                  new Thread(sellTicket).start();
                  new Thread(sellTicket).start();
              }
          }
          
          class SellTicket implements Runnable {
              private int ticketNum = 100;
              private boolean hasTicket = true;
          
              public synchronized void sell() {
                  if (ticketNum <= 0) {
                      System.out.println(Thread.currentThread().getName() + " 售票结束...");
                      hasTicket = false;
                      return;
                  }
                  System.out.println(Thread.currentThread().getName() + " 售出一张票" + ",余票 = " + (--ticketNum));
                  try {
                      Thread.sleep(10);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              }
          
              @Override
              public void run() {
                  while (hasTicket) {
                      // System.out.println(Thread.currentThread().getName());
                      sell();
                  }
              }
          }
          
        3. 锁代码块,线程不抱着锁睡觉,10 个线程均匀售票

          package edu.whut.bear.java.ticket.ticket1;
          
          
          public class Ticket {
              public static void main(String[] args) {
                  SellTicket sellTicket = new SellTicket();
                  new Thread(sellTicket).start();
                  new Thread(sellTicket).start();
                  new Thread(sellTicket).start();
                  new Thread(sellTicket).start();
                  new Thread(sellTicket).start();
                  new Thread(sellTicket).start();
                  new Thread(sellTicket).start();
                  new Thread(sellTicket).start();
                  new Thread(sellTicket).start();
                  new Thread(sellTicket).start();
              }
          }
          
          class SellTicket implements Runnable {
              private int ticketNum = 100;
              private boolean hasTicket = true;
          
              public void sell() {
                  synchronized (this) {
                      if (ticketNum <= 0) {
                          System.out.println(Thread.currentThread().getName() + " 售票结束...");
                          hasTicket = false;
                          return;
                      }
                      System.out.println(Thread.currentThread().getName() + " 售出一张票" + ",余票 = " + (--ticketNum));
                  }
                  // 释放锁后再睡觉
                  try {
                      Thread.sleep(10);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              }
          
              @Override
              public void run() {
                  while (hasTicket) {
                      sell();
                  }
              }
          }
          
        9.9 线程同步机制
        1. 线程同步:当有一个线程正在对内存进行操作时,其它线程都不可以对这个内存进行操作,直到该线程完成操作,其它线程才能对该内存进行操作,也即同一时刻只允许一个线程操作内存

        2. Java 语言中,引入了对象互斥锁的概念,来保证共享数据操作的完整性。每个对象都对应一个可称为 “互斥锁” 的标记,这个标记用来保证在任意时刻,有且仅有一个线程可以访问该对象。用关键字 synchronized 来实现对象的互斥锁

        3. 同步方法:得到对象的锁,才可以操作对象的代码。可以将 synchronized 加在方法声明中,表示整个方法为同步方法,也可以将 synchronized 加在某段代码上,表明此段代码时同步代码

        4. 静态同步方法的锁是当前类本身(ClassName.class)

          // 静态方法中的互斥锁加在类上
          class SellTicket implements Runnable {
             public static void getTicket() {
                 synchronized (SellTicket.class) {
                     System.out.println("售出一张票");
                 }
             }
          }
          
        5. 非静态同步方法的锁可以是它本身 this,也可以是其它对象(要求是同一个对象)

          class SellTicket implements Runnable {
              private int ticketNum = 100;
              private boolean hasTicket = true;
              private final Object object = new Object();
          
              public void sell() {
                  // 锁 this 与锁 object 等价
                  synchronized (object) {
                      if (ticketNum <= 0) {
                          System.out.println(Thread.currentThread().getName() + " 售票结束...");
                          hasTicket = false;
                          return;
                      }
                      System.out.println(Thread.currentThread().getName() + " 售出一张票" + ",余票 = " + (--ticketNum));
                  }
                  // 释放锁后再睡觉
                  try {
                      Thread.sleep(10);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              }
          
              @Override
              public void run() {
                  while (hasTicket) {
                      sell();
                  }
              }
          }
          
        9.10 线程死锁
        public class DeadLockDemo {
            public static void main(String[] args) {
                new DeadLock(true).start();
                new DeadLock(false).start();
            }
        }
        
        class DeadLock extends Thread {
            static final Object object1 = new Object();
            static final Object object2 = new Object();
            boolean flag;
        
            public DeadLock(boolean flag) {
                this.flag = flag;
            }
        
            @Override
            public void run() {
                if (flag) {
                    synchronized (object1) {
                        System.out.println(Thread.currentThread().getName() + " 获得 object1 的锁,尝试获取 object2 的锁···");
                        synchronized (object2) {
                            System.out.println(Thread.currentThread().getName() + " 成功获得 object2 的锁!");
                        }
                    }
                } else {
                    synchronized (object2) {
                        System.out.println(Thread.currentThread().getName() + " 获得 object2 的锁,尝试获取 object1 的锁···");
                        synchronized (object1) {
                            System.out.println(Thread.currentThread().getName() + " 成功获得 object1 的锁!");
                        }
                    }
                }
            }
        }
        
        9.11 释放锁
        1. 当前线程的同步方法、同步代码块执行结束会释放锁
        2. 当前线程在同步方法、同步代码块中遇到 break、return 会释放锁
        3. 当前线程在同步方法、同步代码块中出现了未处理的 Error 或 Exception 导致结束会释放锁
        4. 当前线程在同步方法、同步代码块中执行了线程对象的 wait() 方法,当前线程暂停,并释放锁
        5. 当前线程在执行同步代码块、同步方法的过程中调用了 Thread.sleep()、Thread.yield() 方法暂停当前线程的执行,不会释放锁
        6. 线程执行同步代码块时,其它线程调用了该线程的 suspend() 方法将该方法挂起,该线程不会释放锁。suspend()、resume() 方法均已过时,不再推荐使用
        十、IO 10.1 File 常用 API

        流的定义:数据在数据源(文件)和程序(内存)之间经历的路径,以程序(内存)为参照,流入内存为输入流,流出内存为输出流

        方法名功能
        new File(String)根据路径构建一个 File 对象
        new File(File,String)根据父目录文件 + 子路径构建
        new File(String,String)根据父目录 + 子路径构建
        getName()获取文件名,包含文件扩展名
        getAbsolutePath()获取文件绝对路径
        getParent()获取文件父级目录
        length()获取文件大小,以字节为单位
        exists()判断是否存在
        isFile()判断是否是文件
        isDirectory()判断是否是目录
        mkdir()创建一级目录
        mkdirs()创建多级目录
        delete()删除空目录或文件
        10.2 IO 流的分类
        1. 操作数据单位:字节流和字符流
        2. 数据流方向:输入流和输出流
        3. 流的角色:字节流和处理流(包装流)
        4. IO 流的四大抽象基类:InputStream(字节输入流)、 OutputStream(字节输出流)、Reader(字符输入流)、 Writer(字符输出流)

        10.3 字节流
        String src = "C:\Users\Admin\Desktop\BeFree.jpg";
        String dst = "C:\Users\Admin\Desktop\BeFree.png";
        FileInputStream fileInputStream = new FileInputStream(src);
        // 无需追加写入,因为并未再次打开文件
        FileOutputStream fileOutputStream = new FileOutputStream(dst);
        int readLen;
        byte[] buf = new byte[1024];
        while ((readLen = fileInputStream.read(buf)) != -1) {
            fileOutputStream.write(buf, 0, readLen);
        }
        fileOutputStream.close();
        fileInputStream.close();
        
        10.4 字符流
        1. FileWriter 使用后,必须 close() 或 flush(),否则数据只是暂存在缓冲区,并未写入文件
        2. 字符流底层调用字节流实现具体功能
        10.5 节点流与处理流
        1. 节点流是底层流,直接对数据源进行操作,可以从一个特定的数据源读写数据,如 FileReader、FileWriter

        2. 处理流(又称包装流)是 “连接” 在已存在的流,为程序提供了更为强大的读写功能,如 BufferedReader、BufferedWriter。使用处理流时,只需关闭外层流即可,对应的节点流会自动关闭

        3. 使用处理流包装节点流,既可以消除不同节点流的实现差异,也可以提供更加方便的方法来完成文件操作,底层调用节点流实现具体功能。优点主要有以下两点:

          1. 性能提高:主要以增加缓冲的方式来提高输入输出的效率
          2. 操作便捷:提供了一系列便捷的方法来一次输入、输出大批量的数据(比如 BufferedReader 可以一次读取一行,而 FileReader 只能以字符数组形式进行读取)
        4. 处理流设计理念体现了修饰器模式。列表中前 5 行为节点流,其余行对应的流为处理流

          分类字节输入流字节输出流字符输入流字符输出流
          1抽象基类InputStreamOutputStreamReaderWriter
          2访问文件FileInputStreamFileOutputStreamFileReaderFileWriter
          3访问数组ByteArrayInputSteamByteArrayOutputStramCharArrayReaderCharArrayWriter
          4访问管道PipedInputStreamPipedOutputStreamPipedReaderPipedWriter
          5访问字符串StringReaderStringWriter
          缓冲流BufferedInputStreamBufferedOutputStreamBufferedReaderBufferedWriter
          转换流InputStreamReaderOutputStreamWriter
          对象流ObjectInputStreamObjectOutputStream
          抽象基类FilterInputStreamFilterOutputStreamFilterReaderFilterWriter
          打印流PirntStreamPrintWriter
          推回输入流PushbackInputStreamPushbackReader
          特殊流DataInputStreamDataOutputStream
        10.6 对象处理流
        1. 序列化与反序列化:Java 序列化是指把 Java 对象转换为字节序列的过程,而 Java 反序列化是指把字节序列恢复为 Java 对象的过程

        2. 若某个对象需支持序列化机制,则必须让其类是可序列化的,也即必须实现 Serializable 或 Externalizable 接口之一。其中 Serializable 是标记接口,无需实现任何方法,而 Externalizable 继承自 Serializable,需要实现方法

        3. 序列化的类中建议添加 SerialVersionUID 序列化版本 ID 以提高版本的兼容性。private static final long serialVersionUID = 362498820763181265L;

        4. 序列化对象时,默认将除了 static、transient(让某些被修饰的成员不被序列化) 修饰的成员以外的所有成员进行序列化保存,序列化要求类的所有字段类型也需要实现序列化接口

        5. 序列化具备可继承性:子类继承父类而父类已经实现了序列化接口,则子类也可以序列化

        6. 对象序列化示例,对象追加写入文件需要注意的问题:java.io.StreamCorruptedException

          String path = "C:\Users\Admin\Desktop\out.dat";
          ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(path));
          objectOutputStream.writeUTF("Spring-_-Bear");
          objectOutputStream.writeObject(new People(11, "小明"));
          objectOutputStream.close();
          
          // 注意读入顺序应与写入顺序一致
          ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(path));
          String str = objectInputStream.readUTF();
          Object people = objectInputStream.readObject();
          System.out.println(str);
          System.out.println(people);
          objectInputStream.close();
          
        10.7 标准输入输出流
        1. 标准输入:System.in 编译类型是 InputStream,运行类型是 BufferedInputStream,标准输入设备默认为键盘

          public final class System {
              public final static InputStream in = null;
              public final static PrintStream out = null;
          }
          
          public static void main(String[] args) throws IOException {
              // class java.io.BufferedInputStream
          	System.out.println(System.in.getClass());
          }
          
        2. 标准输出:System.out 编译类型是 PrintStream,运行类型也是 PrintStream,标准输出设备默认为屏幕

          public final class System {
              public final static PrintStream out = null;
          }
          
          public static void main(String[] args) throws IOException {
              // class java.io.PrintStream
              System.out.println(System.out.getClass());
          }
          
        10.8 转换流
        1. InputStreamReader -> Reader:可以将 InputStream(字节流输入流)包装成 Reader(字符输入流),同时指定编码

        2. OutputStreamWriter -> Writer:可以将 OutputStream(字节输出流)包装成 Writer (字符输出流),同时指定编码

        3. 转换流使用示例

          // 使用 InputStreamReader 将 InputStream 转换为 BufferedReader
          BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream("c:\users\admin\desktop\temp1.txt"), StandardCharsets.UTF_8));
          String str;
          while ((str = bufferedReader.readLine()) != null) {
             System.out.println(str);
          }
          bufferedReader.close();
          
        10.9 打印流

        涉及字符输出到文件时需要手动 close() 或 flush(),否则内容不会写入到文件

        // 设置打印流为标准输出
        PrintStream printStream = System.out;
        // print 方法底层调用了 write 方法,因此以下两种方式等价
        printStream.print("Hello World!");
        printStream.write("Hello Java!".getBytes(StandardCharsets.UTF_8));
        printStream.close();
        
        // 重定向输出设备为文件
        System.setOut(new PrintStream("C:\Users\Admin\Desktop\printStream.txt"));
        System.out.println("Spring-_-Bear");
        
        10.10 Properties

        配置文件 Properties 的注意事项:键值对不需要有空格,值不需要引号,默认是 String

        方法名功能
        load(InputStream | Reader)加载配置文件的键值对
        list(PrintStream | PrintWriter)将数据显示到指定设备
        getProperty(String)根据键获取值
        setProperty(String,String)设置键值对到 Properties 对象
        store(OutputStream | Writer,String)保存到配置文件,含有中文默认保存 Unicode 码值
        十一、网络编程 11.1 IP 与 域名
        1. IP 作用:用于唯一标识网络中的每台计算机(主机)

        2. Windows 查看本机 IP 地址:ipconfig,Linux 查看 IP 信息:ifconfig

        3. IP 分类:IPV4 用 4 字节共 32 位标识一个 IP 地址(点分十进制),IPV6 用 8 字节共 128 位标识一个 IP 地址

        4. IP 地址的组成:网络地址 + 主机地址,127.0.0.1 表示本机地址

        5. IP 的表示方法

          分类表示方法范围
          A0 + 7 位网络号 + 24 位主机号0.0.0.0 ~ 127.255.255.255
          B10 + 14 位网络号 + 16 位主机号128.0.0.0 ~ 191.255.255.255
          C110 + 21 位网络号 + 8 位主机号192.0.0.0 ~ 223.255.255.255
          D1110 + 28 位多播组号224.0.0.0 ~ 239.255.255.255
          E11110 + 27 位留待后用240.0.0.0 ~ 247.255.255.255
        6. 域名:将 IP 地址映射成域名(http 协议),一个域名与一个 IP 地址唯一对应

        11.2 端口、协议
        1. 端口:用于标识计算机上特定的网络程序,以整数形式表示,范围是 0 ~ 65535,其中 0 ~ 1024 已被一些知名程序占用

        2. TCP / IP(Transmission Control Protocol / Internet Protocol):传输控制协议 / 因特网互联协议,又名网络通讯协议

        3. 五层网络体系结构

          TCP/IP模型对应协议
          应用层http、ftp、telnet、DNS···
          传输层TCP、UDP···
          网络层IP、ICMP、ARP···
          物理 + 数据链路层Link
        11.3 TCP、UDP、Socket
        1. TCP(Transmission Control Protocol):在使用 TCP 协议前,须先建立 TCP 连接(三次握手方式),形成传输数据通道,建立成功后可进行大量数据的传输。数据传输完毕需释放已建立的连接,效率相对较低
        2. UDP(User Data Protocol):将数据、源地址、目的地封装成数据包,数据传输前不需要建立连接,所以传输并不可靠。数据传输完成无需释放资源,因而数据传输速度较 TCP 快、效率高,但每个数据包的大小限制在 64K 以内,多有不便
        3. Socket(套接字)开发网络应用程序时被广泛使用,以至于成为事实上的标准。通信的两端都要有 Socket,实际上就是实现两台机器间通信的端口。Socket 允许程序把网络连接当作是一个流,数据在两个 Socket 间通过 IO 传输。一般发起通信的应用程序为客户端,等待通信请求的为服务端
        11.4 InetAddress 常用 API
        方法名功能
        getLocalHost获取本机 InetAddress 对象
        getByName根据指定主机名 / 域名获取 InetAddress 对象
        getHostName获取 InetAddress 对象的主机名
        getHostAddress获取 InetAddress 对象的 ip 地址
        // 获取本机的 InetAddress 对象
        InetAddress localHost = InetAddress.getLocalHost();
        // Output:DESKTOP-BEAR/10.134.220.95
        System.out.println(localHost);
        // 通过计算机名获取本机的 InetAddress 对象
        InetAddress desktop = InetAddress.getByName("DESKTOP-BEAR");
        // Output:DESKTOP-BEAR/10.134.220.95
        System.out.println(desktop);
        // 获取 InetAddress 对象的主机名
        System.out.println(localHost.getHostName());
        // 获取 InetAddress 对象的 ip 地址
        System.out.println(desktop.getHostAddress());
        
        // 根据指定主机名/域名获取 InetAddress 对象
        InetAddress csdn = InetAddress.getByName("www.csdn.net");
        // Output:www.csdn.net/39.106.226.142
        System.out.println(csdn);
        // Output:www.csdn.net
        System.out.println(csdn.getHostName());
        // Output:39.106.226.142
        System.out.println(csdn.getHostAddress());
        
        11.5 TCP 字节流编程
        1. Server.java

          // 监听端口
          ServerSocket serverSocket = new ServerSocket(5555);
          // 等待连接
          Socket socket = serverSocket.accept();
          
          // 从数据通道读取数据
          InputStream inputStream = socket.getInputStream();
          byte[] buf = new byte[1024];
          int readLen;
          while ((readLen = inputStream.read(buf)) != -1) {
             System.out.println(new String(buf, 0, readLen));
          }
          // 关闭 socket 的输入流
          socket.shutdownInput();
          
          // 写数据到数据通道
          OutputStream outputStream = socket.getOutputStream();
          outputStream.write("Hello,Client!".getBytes(StandardCharsets.UTF_8));
          
          // 关闭资源
          outputStream.close();
          inputStream.close();
          socket.close();
          serverSocket.close();
          
        2. Client.java

          // 建立连接
          Socket socket = new Socket(InetAddress.getLocalHost(), 5555);
          
          // 写数据到数据通道
          OutputStream outputStream = socket.getOutputStream();
          outputStream.write("Hello,Server!".getBytes(StandardCharsets.UTF_8));
          // 关闭 socket 的输出流
          socket.shutdownOutput();
          
          // 从数据通道读取数据
          InputStream inputStream = socket.getInputStream();
          byte[] buf = new byte[1024];
          int readLen;
          while ((readLen = inputStream.read(buf)) != -1) {
             System.out.println(new String(buf, 0, readLen));
          }
          
          // 关闭资源
          inputStream.close();
          outputStream.close();
          socket.close();
          
        11.6 TCP 字符流编程
        1. Server.java

          // 监听端口
          ServerSocket serverSocket = new ServerSocket(6666);
          // 等待连接
          Socket socket = serverSocket.accept();
          
          // 从数据通道读取信息
          InputStream inputStream = socket.getInputStream();
          // 字节输入流转换成字符输入流
          BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
          System.out.println(bufferedReader.readLine());
          
          // 写数据到数据通道
          OutputStream outputStream = socket.getOutputStream();
          // 字节输出流转换成字符输出流
          BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
          bufferedWriter.write("Hello,Client!");
          // 行分隔符,写入结束标志
          bufferedWriter.newLine();
          // 刷新缓冲区,写入数据通道
          bufferedWriter.flush();
          
          // 关闭资源
          bufferedWriter.close();
          bufferedReader.close();
          socket.close();
          serverSocket.close();
          
        2. Client.java

          // 建立连接
          Socket socket = new Socket(InetAddress.getLocalHost(), 6666);
          
          // 写入数据到数据通道
          OutputStream outputStream = socket.getOutputStream();
          // 字符输出流转换从字节输出流
          BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
          bufferedWriter.write("Hello,Server!");
          // 行分隔符,写入结束标记
          bufferedWriter.newLine();
          // 刷新缓冲区,写入数据通道
          bufferedWriter.flush();
          
          // 从数据通道读取数据
          InputStream inputStream = socket.getInputStream();
          // 字节输入流转换成字符输入流
          BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
          System.out.println(bufferedReader.readLine());
          
          // 关闭资源
          bufferedReader.close();
          bufferedWriter.close();
          socket.close();
          
        11.7 TCP 文件上传
        1. Server.java

          package upload;
          
          import java.io.*;
          import java.net.ServerSocket;
          import java.net.Socket;
          
          
          public class Server {
              public static void main(String[] args) {
                  Socket socket = null;
                  InputStream inputStream = null;
                  ServerSocket serverSocket = null;
                  OutputStream outputStream = null;
                  BufferedWriter bufferedWriter = null;
                  ByteArrayOutputStream byteArrayOutputStream = null;
                  BufferedOutputStream bufferedOutputStream = null;
          
                  try {
                      // 监听端口,等待连接
                      serverSocket = new ServerSocket(6666);
                      System.out.println("服务器已启动,等待连接···");
                      socket = serverSocket.accept();
          
                      // 文件大小,单位为字节
                      long fileSize = 0;
                      // 文件保存路径
                      File fileSavePath = new File("C:\Users\Admin\Desktop\temp.jpg");
          
                      // 从数组通道读取文件字节数组
                      int readLen;
                      byte[] buffer = new byte[1024];
                      inputStream = socket.getInputStream();
                      byteArrayOutputStream = new ByteArrayOutputStream();
                      System.out.println("文件读取中···");
                      while ((readLen = inputStream.read(buffer)) != -1) {
                          byteArrayOutputStream.write(buffer, 0, readLen);
                          fileSize += readLen;
                      }
                      System.out.println("文件读取成功,总大小为 " + fileSize + " bytes!");
                      // 将 byteArrayOutputStream 中的数据转换为字节数组(文件二进制数据)
                      byte[] fileByteArray = byteArrayOutputStream.toByteArray();
          
          
                      // 将文件字节数组保存到磁盘
                      System.out.println("文件保存到本地中···");
                      bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(fileSavePath));
                      bufferedOutputStream.write(fileByteArray);
                      System.out.println("文件保存到本地成功!保存路径为:" + fileSavePath);
          
                      // 向客户端反馈文件下载保存成功信息
                      outputStream = socket.getOutputStream();
                      bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
                      System.out.print("发送反馈信息到客户端··· ");
                      bufferedWriter.write("文件接收成功,下载保存完成!");
                      bufferedWriter.newLine();
                      bufferedWriter.flush();
                      System.out.println("消息发送成功!");
                  } catch (IOException e) {
                      e.printStackTrace();
                  } finally {
                      try {
                          bufferedWriter.close();
                          outputStream.close();
                          bufferedOutputStream.close();
                          byteArrayOutputStream.close();
                          inputStream.close();
                          socket.close();
                          serverSocket.close();
                      } catch (IOException e) {
                          e.printStackTrace();
                      }
                  }
              }
          }
          
        2. Client.java

          package upload;
          
          import java.io.*;
          import java.net.InetAddress;
          import java.net.Socket;
          
          
          public class Client {
              public static void main(String[] args) {
                  Socket socket = null;
                  InputStream inputStream = null;
                  OutputStream outputStream = null;
                  BufferedReader bufferedReader = null;
                  BufferedInputStream bufferedInputStream = null;
                  ByteArrayOutputStream byteArrayOutputStream = null;
          
                  try {
                      // 文件大小,以字节为单位
                      int fileSize = 0;
                      // 文件路径
                      File filePath = new File("C:\Users\Admin\Desktop\fishing.jpg");
          
                      // 从磁盘读取文件,并存入文件字节数组
                      int readLen;
                      byte[] buf = new byte[1024];
                      byteArrayOutputStream = new ByteArrayOutputStream();
                      bufferedInputStream = new BufferedInputStream(new FileInputStream(filePath));
                      System.out.println("文件读入中···");
                      while ((readLen = bufferedInputStream.read(buf)) != -1) {
                          // 将从文件读取到的二进制数据写进字节数组输出流(byteArrayOutputStream)
                          byteArrayOutputStream.write(buf, 0, readLen);
                          fileSize += readLen;
                      }
                      System.out.println("文件读入成功,文件大小为:" + fileSize + " bytes!");
                      // 将得到的 byteArrayOutputStream 转换为一个字符数组
                      byte[] fileByteArray = byteArrayOutputStream.toByteArray();
          
                      // 将字节数组写入数据通道
                      socket = new Socket(InetAddress.getLocalHost(), 6666);
                      outputStream = socket.getOutputStream();
                      System.out.println("文件发送到服务器中···");
                      outputStream.write(fileByteArray);
                      socket.shutdownOutput();
                      System.out.println("文件发送到服务器成功!");
          
                      // 接送服务器端发送的反馈信息并打印
                      System.out.print("接收到的服务器信息:");
                      inputStream = socket.getInputStream();
                      bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
                      System.out.println(bufferedReader.readLine());
                  } catch (IOException e) {
                      e.printStackTrace();
                  } finally {
                      try {
                          bufferedReader.close();
                          inputStream.close();
                          outputStream.close();
                          byteArrayOutputStream.close();
                          bufferedInputStream.close();
                          socket.close();
                      } catch (IOException e) {
                          e.printStackTrace();
                      }
                  }
              }
          }
          
        11.8 TCP 文件下载
        1. Server.java

          import java.io.*;
          import java.net.ServerSocket;
          import java.net.Socket;
          import java.util.ArrayList;
          
          
          public class FileServer {
              byte[] fileData = null;
              String requestFileName = null;
              ArrayList fileNameList = new ArrayList<>();
              File filePath = new File("C:\Users\Admin\Desktop\sourceFile");
          
              Socket socket = null;
              ServerSocket serverSocket = null;
              InputStream inputStream = null;
              BufferedInputStream bufferedInputStream = null;
          
              public static void main(String[] args) {
                  FileServer server = new FileServer();
                  server.createAndReadFiles();
                  server.startServer();
                  server.receiveRequestNameFromClient();
                  server.readFileFromDisk();
                  server.transferFileToClient();
                  try {
                      server.socket.close();
                      server.serverSocket.close();
                      server.inputStream.close();
                      server.bufferedInputStream.close();
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
          
              
              public void createAndReadFiles() {
                  System.out.println("正在进行文件夹初始化···");
                  // 若文件夹不存在,则先创建文件夹
                  if (!(filePath.exists() && filePath.isDirectory())) {
                      filePath.mkdirs();
                  }
          
                  // 读取文件夹中的所有文件,并将文件名存进集合
                  File[] files = filePath.listFiles();
                  for (File file : files) {
                      if (file.isFile()) {
                          fileNameList.add(file.getName());
                      }
                  }
                  System.out.println("初始化完成!");
              }
          
              
              public void startServer() {
                  try {
                      serverSocket = new ServerSocket(9999);
                      System.out.println("服务器已启动,等待连接···");
                      socket = serverSocket.accept();
                      System.out.println("服务端 - 客户端建立连接成功!");
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
          
              
              public void receiveRequestNameFromClient() {
                  try {
                      int readLen;
                      byte[] buf = new byte[2048];
                      inputStream = socket.getInputStream();
                      System.out.println("正在接收客户端请求的文件名···");
                      while ((readLen = inputStream.read(buf)) != -1) {
                          requestFileName = new String(buf, 0, readLen);
                      }
                      socket.shutdownInput();
                      System.out.println("成功接收到客户端请求的文件名!");
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
          
              
              public void readFileFromDisk() {
                  try {
                      int readLen = 0;
                      byte[] buf = new byte[1024];
                      File requestFile = new File(filePath + "\" + requestFileName);
                      bufferedInputStream = new BufferedInputStream(new FileInputStream(requestFile));
                      ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
                      System.out.println("正在从磁盘读取文件···");
                      while ((readLen = bufferedInputStream.read(buf)) != -1) {
                          byteArrayOutputStream.write(buf, 0, readLen);
                      }
                      fileData = byteArrayOutputStream.toByteArray();
                      System.out.println("从磁盘读取文件完成!");
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
          
              
              public void transferFileToClient() {
                  try {
                      System.out.println("正在传送文件到客户端···");
                      OutputStream outputStream1 = socket.getOutputStream();
                      outputStream1.write(fileData);
                      System.out.println("文件传输到客户端完成!");
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
          
          //    
          //    public void sendFilesNameToClient() {
          //        System.out.println("正在发送文件目录到客户端···");
          //        outputStream = socket.getOutputStream();
          //        bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
          //        for (String fileName : fileArrayList) {
          //            bufferedWriter.write((fileName));
          //            outputStream.flush();
          //        }
          //        bufferedWriter.newLine();
          //        outputStream.flush();
          //        System.out.println("文件目录发送到客户端成功!");
          //    }
          }
          
        2. Client.java

          import java.io.*;
          import java.net.InetAddress;
          import java.net.Socket;
          import java.nio.charset.StandardCharsets;
          import java.util.Scanner;
          
          
          public class FileClient {
              byte[] fileData = null;
          
              Socket socket = null;
              InputStream inputStream = null;
              OutputStream outputStream = null;
              BufferedOutputStream bufferedOutputStream = null;
              Scanner scanner = new Scanner(System.in);
          
              public static void main(String[] args) {
                  FileClient client = new FileClient();
          
                  try {
                      client.socket = new Socket(InetAddress.getLocalHost(), 9999);
                      client.sendFileNameToServer();
                      client.receiveFileData();
                      client.saveFile();
                  } catch (IOException e) {
                      e.printStackTrace();
                  } finally {
                      try {
                          client.socket.close();
                          client.inputStream.close();
                          client.outputStream.close();
                          client.bufferedOutputStream.close();
                      } catch (IOException e) {
                          e.printStackTrace();
                      }
                  }
              }
          
              
              public void sendFileNameToServer() {
                  try {
                      System.out.print("请输入您想要下载的文件名(含文件拓展名):");
                      String choice = scanner.next();
                      outputStream = socket.getOutputStream();
                      outputStream.write(choice.getBytes(StandardCharsets.UTF_8));
                      socket.shutdownOutput();
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
          
              
              public void receiveFileData() {
                  try {
                      int readLen = 0;
                      byte[] buf = new byte[1024];
                      inputStream = socket.getInputStream();
                      ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
                      System.out.println("正在接收服务器传输的文件···");
                      while ((readLen = inputStream.read(buf)) != -1) {
                          byteArrayOutputStream.write(buf, 0, readLen);
                      }
                      socket.shutdownInput();
                      fileData = byteArrayOutputStream.toByteArray();
                      System.out.println("文件接收成功!");
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
          
              
              public void saveFile() {
                  try {
                      bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("C:\Users\Admin\Desktop\temp.jpg"));
                      System.out.println("正在将文件保存到本地···");
                      bufferedOutputStream.write(fileData);
                      System.out.println("文件保存到本地完成!");
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
          
          //    
          //    public void receiveFilesName() {
          //        bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
          //        System.out.println("正在接收服务端发送的文件目录···");
          //        String fileName = "";
          //        System.out.println(bufferedReader.readLine());
          //        while ((fileName = bufferedReader.readLine()) != null) {
          //            System.out.println(fileName);
          //        }
          //        System.out.println("接收服务端发送的文件目录成功!");
          //    }
          }
          
        11.9 UDP 字节编程
        1. UDP 编程没有明确的服务端和客户端,因此无需建立连接

        2. UDP 数据包通过数据包套接字 DatagramSocket 实现发送和接收,系统不保证 UDP 数据包一定送达目的地,也不确定什么时候可以送达即传输不可靠。DatagramSocket 对象封装了 UDP 数据包,在数据包中封装了数据、发送端和接收端的 IP 地址以及端口信息

        3. Sender.java

          // 监听端口
          DatagramSocket socket = new DatagramSocket(8888);
          
          // 装包,封装数据
          byte[] data = "Hello, receiver!".getBytes(StandardCharsets.UTF_8);
          DatagramPacket packet = new DatagramPacket(data, 0, data.length, InetAddress.getLocalHost(), 7777);
          // 发送包
          socket.send(packet);
          
          // 接收包
          // 用于保存数据包的缓冲区
          byte[] buf = new byte[1024];
          packet = new DatagramPacket(buf, buf.length);
          socket.receive(packet);
          // 拆包,获取数据
          int dataLen = packet.getLength();
          data = packet.getData();
          System.out.println(new String(data, 0, dataLen));
          
          // 关闭资源
          socket.close();
          
        4. Receiver.java

          // 监听端口
          DatagramSocket socket = new DatagramSocket(7777);
          
          // 接收包
          // 用户保存数据包的缓冲区
          byte[] buf = new byte[1024];
          DatagramPacket packet = new DatagramPacket(buf, buf.length);
          socket.receive(packet);
          // 拆包,获取数据
          int dataLen = packet.getLength();
          byte[] data = packet.getData();
          System.out.println(new String(data, 0, dataLen));
          
          // 装包,封装数据
          buf = "Hello, sender!".getBytes(StandardCharsets.UTF_8);
          packet = new DatagramPacket(buf, 0, buf.length, InetAddress.getLocalHost(), 8888);
          // 发送包
          socket.send(packet);
          
          // 关闭资源
          socket.close();
          
        11.10 netstat 指令
        1. netstat -an | more:可以查看当前主机网络情况,包括端口监听和网络连接情况
        2. netstat -anb:以管理员身份运行可以查看监听端口的具体程序
        3. 当客户端与服务端建立连接后,实际上客户端也是通过一个端口与服务端进行通信的,这个端口号是根据 TCP / IP 协议由系统随机分配的
        十二、反射 12.1 入门案例
        // 加载配置文件,读取配置文件中的类信息
        Properties properties = new Properties();
        properties.load(new FileInputStream("reflection.properties"));
        String classPath = properties.getProperty("classPath");
        String methodName = properties.getProperty("method");
        
        // 加载类信息
        Class aClass = Class.forName(classPath);
        // 获得类的一个实例
        Object o = aClass.newInstance();
        // 获得类中方法实例
        Method method = aClass.getMethod(methodName);
        // 调用方法
        method.invoke(o);
        
        12.2 反射机制
        1. 反射机制允许程序在执行期借助于 Reflection API 取得任何类的内部信息(如成员变量、构造器、成员方法等),并能操作对象的属性及方法,反射在设计模式和框架底层使用广泛

        2. 加载完类之后,在堆中就产生了一个 Class 类型(Class 本身也是一个类)的对象(一个类只有一个 Class 对象,因为类只加载一次),这个对象包含了类的完整结构信息,通过这个对象就可以得到类的所有信息

        3. 反射的作用

          1. 在运行时判断任意一个对象所属的类
          2. 在运行时构造任意一个类的对象,获取其属性或调用其方法
          3. 生成动态代理
        4. 反射的优点:可以动态创建和使用对象(框架底层核心),没有反射框架就失去了灵魂

        5. 反射的缺点:使用反射代码基本是解释执行,对执行速度有一定影响

        6. 反射的优化:关闭访问检查(Method、Field、Constructor 类都有一个 setAccessible(boolean) 方法,作用是启动和禁用访问安全检查的开关,传入参数 true 表示反射的对象在使用时取消安全检查,提高反射效率,提高效果并不明显)

        12.3 Java 程序的三个阶段
        1. 代码阶段(编译阶段):将源码 .java 文件通过 javac 编译得到 .class 字节码文件
        2. Class 类阶段(加载阶段):通过类加载器(ClassLoader)将 .class 字节码文件加载到堆中生成 Class 类的对象,该对象记录了 .class 中类的字段 Field[] fields、构造器 Constructor[] constructors、方法 Method[] methods 等信息
        3. Runtime(运行阶段):通过 new 创建出的对象知道自己与哪个 Class 类型的对象相关联 obj.getClass()

        12.4 Class
        1. java.lang.Class 代表一个类,继承自 Object 类,Class 对象代表某个类的字节码文件被类加载器加载后在堆中生成的 Class 类型的对象。加载类在堆里生成 Class 对象的同时也会在方法区生成对应类的字节码的二进制数据,也称为类的元数据,该二进制数据引用到 Class 类型对象

        2. Class 类对象并不是 new 出来的,而是系统创建的,通过 ClassLoader 类的 loadClass 方法创建。对于某个类的 Class 对象,在堆中有且仅有一份,因为类只加载一次。通过一个类对应的 Class 对象,即可获取到该类的完整结构

        3. 哪些类型有Class对象:外部类、内部类、接口、数组、枚举、注解、基本数据类型、void

        4. Class 类的常用 API

          方法功能
          static Class forName(String)获得指定类名的 Class 对象
          Object newInstance()调用缺省构造函数,获得 Class 对象的一个实例
          Class[] getInterfaces获得 Class 对象的接口
          ClassLoder getClassLoder()获得类的加载器
          getName获取全类名
          getSimpleName获取简单类名
          getFields获取所有 public 修饰的字段,本类以及父类
          getDeclaredFidles获取本类中的所有字段
          getMethods获取所有 public 修饰的方法,本类以及父类
          getDeclaredMethods获取本类中的所有方法
          getConstructors获取所有 public 修饰的构造器,只包含本类
          getDeclaredConstructors获取本类中的所有构造器
          getPackage以 Package 形式返回包信息
          getSuperClass以 Class 形式返回父类信息
          getAnnotations以 Annotation[] 形式返回注解信息
          String classPath = "com.springbear.Car";
          
          Class clazz = Class.forName(classPath);
          // 输出此 Class 对象是哪个类的 Class 对象
          System.out.println(clazz);
          // 获得运行类型
          System.out.println(clazz.getClass());
          // 获得包名
          System.out.println(clazz.getPackage().getName());
          // 获得全类名
          System.out.println(clazz.getName());
          // 获得实例
          Object obj = clazz.newInstance();
          System.out.println(obj);
          // 获取公有属性
          Field bland = clazz.getField("bland");
          System.out.println(bland.get(obj));
          // 给属性设置值
          bland.set(obj, "宝马");
          System.out.println(bland.get(obj));
          
        12.5 获取 Class 对象
        1. 编译阶段:Class.forName(String); 多用于配置文件,读取到类的全路径,而后加载类

        2. 类加载阶段:ClassName.class; 多用于参数传递,此方式最为安全可靠,程序性能最高

        3. 运行阶段:object.getClass(); 通过创建好的类的对象来获取 Class 对象也即运行类型

        4. 类加载器:object.getClass().getClassLoader().loadClass("ClassFullPath");

          Car car = new Car();
          // 获得类对应的类加载器
          ClassLoader classLoder = car.getClass().getClassLoader();
          // 获得 Class 对象
          Class aClass = classLoder.loadClass("com.springbear.Car");
          
        5. 八大基本数据类型直接使用:Class clazz = int.class;

        6. 基本数据类型对应的包装类,可以通过 ClassName.TYPE 获得 Class 对象:Class cls = Integer.TYPE;

        12.6 动态加载和静态加载
        1. 静态加载:编译时加载相关的类,如果不存在相关类则报错,依赖性很强

        2. 动态加载:运行过程中在需要时加载该类,如果运行时未使用到该类,则不报错,降低了依赖性。反射机制是 Java 实现动态的关键也即通过反射实现类动态加载

        3. 类加载的时机:

          1. new 创建对象时
          2. 子类被加载时其父类也被加载
          3. 访问到类的静态成员时(非 static final)
          4. 通过反射加载
        12.7 类加载流程
        1. 加载(Loading):将类的 .class 文件读入内存,并为之创建一个 Class 类型的对象,由类加载器完成

        2. 连接(Linking):将类的二进制数据合并到 JRE 中。细分为验证(Verification)、准备(Preparation)、解析(Resolution)三个子阶段

          1. 验证(verification):目的是为了确保 .class 文件的字节流中包含的信息符合当前虚拟机的要求,不会危害到虚拟机自身的安全。验证包括对文件格式验证(是否以魔数 oxcafebabe 开头)、元数据验证、字节码验证和符号引用验证等。可以考虑使用 -Xverify:none 参数来关闭大部分的类验证措施,缩短虚拟机加载时间

          2. 准备(preparation):JVM 会在此阶段给静态变量分配内存并执行默认初始化,这些变量所使用的内存都会在方法区中进行分配

            // 在连接的准备子阶段先默认初始化为 0,后在初始化阶段再显式初始化为 1
            public static int num1 = 1;
            // 在连接的准备子阶段直接初始化为 2
            public static final int num2 = 2;
            
          3. 解析(resolution):JVM 将常量池内的符号引用替换为直接引用的过程

        3. 初始化(Initialization):真正执行类中定义的 Java 代码,此阶段是执行 () 方法的过程。 () 方法的执行过程是由编译器按代码在源文件中的出现顺序,依次收集类中所有的静态变量的赋值动作和静态代码块中的语句,并自动进行合并。JVM 保证一个类的 () 方法在多线程环境中会被正确地加锁、同步

          static {
             System.out.println("静态代码块被执行!");
             num = 300;
          }
          public static int num = 100;
          // 经 () 方法收集合并后如下
          System.out.println("静态代码块被执行!");
          num = 100;
          
        4. 类加载后内存布局情况:

          1. 在方法区存放类的字节码的二进制数据(元数据),元数据引用到对应的 Class 对象
          2. 在堆中存放类的 Class 对象(数据结构)

        12.8 反射爆破
        1. 调用类的指定构造器

          Class userClass = Class.forName("com.springbear.User");
          // 获得指定构造器
          Constructor userConstructor = userClass.getDeclaredConstructor(int.class, String.class);
          // 爆破
          userConstructor.setAccessible(true);
          // 调用构造器
          Object mary = userConstructor.newInstance(10, "mary");
          System.out.println(mary);
          
        2. 操作类的字段:如果获取的是静态属性,则 set 和 get 方法中传入的对象参数可以是 null

          Class userClass = Class.forName("com.springbear.User");
          Object userObject = userClass.newInstance();
          
          // 获得指定字段
          Field name = userClass.getDeclaredField("name");
          // 爆破
          name.setAccessible(true);
          // 获得值
          System.out.println(name.get(userObject));
          // 设置值
          name.set(userObject, "Spring-_-Bear");
          System.out.println(name.get(userObject));
          
        3. 操作类的方法:如果获取的是静态方法,则 invoke 的对象参数可以写成 null

          Class userClass = Class.forName("com.springbear.User");
          Object userObject = userClass.newInstance();
          
          // 获取指定的方法
          Method loginMethod = userClass.getDeclaredMethod("login", String.class, String.class);
          // 爆破
          loginMethod.setAccessible(true);
          // 调用方法
          Object springbear = loginMethod.invoke(userObject, "springbear", "123");
          System.out.println(springbear);
          
        4. 最佳实践:在指定目录下创建文件

          // 加载类信息
          Class fileClass = Class.forName("java.io.File");
          // 获取所有构造器
          Constructor[] declaredConstructors = fileClass.getDeclaredConstructors();
          for (Constructor declaredConstructor : declaredConstructors) {
             declaredConstructor.setAccessible(true);
             System.out.println(declaredConstructor);
          }
          // 获得指定的构造器
          Constructor constructor = fileClass.getConstructor(String.class);
          Object file = constructor.newInstance("d:\aa.txt");
          // 获得指定方法
          Method createNewFile = fileClass.getMethod("createNewFile");
          // 调用方法
          createNewFile.invoke(file);
          
        十三、JDBC 13.1 JDBC 原理
        1. JDBC 为访问不同的数据库定义了统一的接口,具体实现由各数据库厂商完成。Java 程序员使用 JDBC API 可以连接任何提供了 JDBC 驱动程序的数据库系统,从而完成对数据库的各种操作,只需面向这套接口编程即可,相关的接口和类在 java.sql 和 javax.sql 包中

        2. JDBC 程序编写步骤:

          1. 注册驱动:加载 Driver 类
          2. 获取连接:获得 Connection 对象
          3. 执行 SQL:获得 Statement 对象
          4. 释放资源
        13.2 五种连接方式
        1. 静态加载方式连接到数据库

          // 连接到的数据库:jdbc:mysql://ip:port/db
          String url = "jdbc:mysql://localhost:3306/temp";
          // 设置用户名与密码
          Properties properties = new Properties();
          properties.setProperty("user", "springbear");
          properties.setProperty("password", "123");
          
          // 加载驱动: 5.* new com.mysql.jdbc.Driver()
          //          8.* new com.mysql.cj.jdbc.Driver()
          Driver driver = new com.mysql.jdbc.Driver();
          // 获得连接
          Connection connect = driver.connect(url, properties);
          
          // SQL 语句
          String insert = "INSERT INTO actor VALUES (NULL,'张三','男','1970-01-01','10086');";
          
          // 得到一个执行静态 SQL 语句并返回其生成的结果的对象
          Statement statement = connect.createStatement();
          // 返回受影响的行数
          int rows = statement.executeUpdate(insert);
          
          System.out.println("返回受影响的行数 = " + rows);
          
          statement.close();
          connect.close();
          
        2. 使用反射动态加载驱动类 Driver,获取数据库连接

          // 连接到的数据库:jdbc:mysql://主机IP地址:端口/db_name
          String url = "jdbc:mysql://localhost:3306/temp";
          // 设置用户名与密码
          Properties properties = new Properties();
          properties.setProperty("user", "springbear");
          properties.setProperty("password","123");
          
          // 加载类信息
          Class aClass = Class.forName("com.mysql.jdbc.Driver");
          // 获得类实例
          Driver driver = (Driver)aClass.newInstance();
          // 获得连接
          Connection connect = driver.connect(url, properties);
          
        3. 使用 DriverManager 替代 Driver 进行管理,获得数据库连接

          // 加载类信息
          Class aClass = Class.forName("com.mysql.jdbc.Driver");
          // 获得类实例
          Driver driver = (Driver)aClass.newInstance();
          
          String url = "jdbc:mysql://localhost:3306/temp";
          String user = "springbear";
          String pwd = "123";
          
          // 注册驱动
          DriverManager.registerDriver(driver);
          // 获得连接
          Connection connection = DriverManager.getConnection(url, user, pwd);
          
        4. 使用反射加载驱动类 Driver,使用 DriverManager 进行管理

             // 加载类信息,在加载 Driver 的过程中自动完成注册
             Class.forName("com.mysql.jdbc.Driver");
             
             String url = "jdbc:mysql://localhost:3306/temp";
             String user = "springbear";
             String pwd = "123";
          
             // 获得连接
             Connection connection = DriverManager.getConnection(url, user, pwd);
          
        5. 读取配置文件中的数据库信息,获取数据库连接

          // 从配置文件中读取数据库信息
          Properties properties = new Properties();
          properties.load(new FileInputStream("jdbc.properties"));
          String user = properties.getProperty("jdbc.username");
          String password = properties.getProperty("jdbc.password");
          String driver = properties.getProperty("jdbc.driver");
          String url = properties.getProperty("jdbc.url");
          
          
          // 加载类信息,自动注册驱动(可省略)
          // Class.forName(driver);
          Connection connection = DriverManager.getConnection(url, user, password);
          System.out.println(connection);
          
        13.3 ResultSet
        1. ResultSet:表示从数据库读取到的数据表结果集。ResultSet 对象保持一个光标指向当前的数据行。最初,光标位于第一行之前。其有一个 next 方法将光标移动到下一行,并且由于在 ResultSet 对象中没有更多行时返回 false,因此常用 while 循环来遍历结果集

        2. com.mysql.jdbc.JDBC42 ResultSet 类下有一个 RowData(接口) 类型的字段,rowData 中有一个 ArrayList 类型的集合 rows,rows 中又有 byte[] 类型的 internalRowData,数据真正存储的位置

        3. 查询数据库记录示例

          // 从配置文件中读取数据库信息
          Properties properties = new Properties();
          properties.load(new FileInputStream("jdbc.properties"));
          String user = properties.getProperty("jdbc.username");
          String password = properties.getProperty("jdbc.password");
          String driver = properties.getProperty("jdbc.driver");
          String url = properties.getProperty("jdbc.url");
          
          // 加载类信息,自动注册驱动(可省略)
          Class.forName(driver);
          Connection connection = DriverManager.getConnection(url, user, password);
          // Sql 语句
          String sql = "SELECT * from t_user";
          Statement statement = connection.createStatement();
          // 执行 SELECt 语句
          ResultSet resultSet = statement.executeQuery(sql);
          // 遍历结果集
          while (resultSet.next()) {
          System.out.println(resultSet.getString(1));
          System.out.println(resultSet.getString(2));
          }
          statement.close();
          connection.close();
          
        13.4 SQL 注入
        1. SQL 注入是利用某些系统没有对用户输入的数据进行充分的检查,而在用户输入的数据中注入非法的 SQL 语句段或命令,恶意攻击数据库

        2. 在建立数据库连接之后,想要对数据库进行操作,一般有以下三种方式:

          1. Statement:存在 SQL 注入
          2. PreparedStatement:预处理(解决 SQL 注入)
          3. CallableStatement:用于执行数据库存储过程
        3. SQL 注入经典案例

          public class SqlInjection {
             public static void main(String[] args) throws IOException, ClassNotFoundException, SQLException {
                 // 获取用户想要查询的用户名和密码
                 // Input userName = 1' or
                 // Input pwd = or '1' = '1
                 Scanner scanner = new Scanner(System.in);
                 System.out.print("Input the name that you want to query:");
                 String userName = scanner.nextLine();
                 System.out.print("Input the password that you want to query:");
                 String pwd = scanner.nextLine();
          
                 // 加载配置文件
                 Properties properties = new Properties();
                 properties.load(new FileInputStream("config\temp.properties"));
          
                 // 加载驱动类信息,自动注册驱动
                 Class.forName(properties.getProperty("driver"));
                 // 获得连接
                 Connection connection = DriverManager.getConnection(properties.getProperty("url"), properties);
                 Statement statement = connection.createStatement();
          
                 String select = "SELECT * FROM admin WHERe name='" + userName + "' AND pwd= '" + pwd + "'";
                 ResultSet resultSet = statement.executeQuery(select);
                 while (resultSet.next()) {
                     userName = resultSet.getString(1);
                     pwd = resultSet.getString(2);
                     System.out.println(userName + "t" + pwd);
                 }
          
                 resultSet.close();
                 statement.close();
                 connection.close();
             }
          }
          
        13.5 PreparedStatement

        PreparedStatement 执行的 SQL 语句中的参数用问号(?)来表示,调用 PreparedStatement 对象的 setXxx() 方法来设置这些参数。setXxx() 方法有两个参数,第一个参数是要设置的 SQL 语句中的参数的索引,从 1 开始,第二个参数是设置 SQL 语句中的参数的值

        String select = "SELECT * FROM admin WHERe name = ? AND pwd= ?";
        // SQL 语句预处理
        PreparedStatement preparedStatement = connection.prepareStatement(select);
        preparedStatement.setString(1, userName);
        preparedStatement.setString(2, pwd);
        
        // 执行 SQL 语句,得到结果集
        ResultSet resultSet = preparedStatement.executeQuery();
        
        13.6 JDBC API
        接口名方法名功能
        ConnectioncreateStatement()创建执行静态 SQL 语句的对象
        createPreparedStatement(sql)获得 SQL 语句预处理对象
        StatementexecuteUpdate(sql)执行 DML 语句,返回受影响行数
        executeQuery(sql)执行 DQL 语句,返回结果集
        execute(sql)执行任意 SQL 语句,返回布尔值
        PreparedStatementexecuteUpdate(sql)执行 DML 语句,返回受影响行数
        executeQuery(sql)执行 DQL 语句,返回结果集
        execute(sql)执行任意 SQL 语句,返回布尔值
        setXxx(index,value)设置 SQL 语句中的值
        setObject(index,value)设置 SQL 语句中的值
        ResultSetnext()向下移动一行,到表尾返回 false
        previous()向上移动一行,到表头返回 false
        getXxx(index || colLabel)获得指定列的值
        getObject(index || colLabel)获得指定列的值
        13.7 Java 事务操作
        1. JDBC 程序中当一个 Connection 对象被创建时,默认情况下是自动提交事务:每执行一条 SQL 语句时,如果执行成功,就会向数据库自动提交保存,不能进行回滚

        2. 开启事务:可以调用 Connection 接口的 setAutoCommit(false) 方法关闭自动提交事务,在所有的 SQL 语句都执行成功后,调用 commit() 方法提交事务,在其中某个操作失败或出现异常时,调用 rollback() 方法回滚事务

        3. 经典事务操作:打钱

          public void transaction() {
             Connection connection = null;
             PreparedStatement preparedStatement = null;
             String sub = "UPDATE account SET balance = balance - 100 WHERe id = 1";
             String add = "UPDATE account SET balance = balance + 100 WHERe id = 2";
          
             try {
                 // 获得连接
                 connection = JdbcUtils.getConnection();
                 // 关闭自动提交即开启事务
                 connection.setAutoCommit(false);
                 // 执行 SQL
                 preparedStatement = connection.prepareStatement(add);
                 preparedStatement.executeUpdate();
                 int temp = 1 / 0;
                 preparedStatement = connection.prepareStatement(sub);
                 preparedStatement.executeUpdate();
                 // 提交事务
                 connection.commit();
                 System.out.println("所有 SQL 操作成功,提交事务!");
             } catch (SQLException | ArithmeticException e) {
                 try {
                     // 发生异常,撤销操作,事务回滚
                     System.out.println("程序执行发生了异常,回滚所有操作!!!");
                     connection.rollback();
                 } catch (SQLException ex) {
                     ex.printStackTrace();
                 }
                 e.printStackTrace();
             } finally {
                 JdbcUtils.close(null, preparedStatement, connection);
             }
          }
          
        13.8 批处理
        1. 当需要成批插入或者更新记录时,可以采用 Java 的批处理更新机制,这一机制允许多条语句一次性提交给数据库批量处理。通常情况下比单条语句提交处理效率更高

        2. JDBC 连接 MySQL 时,如果需要使用批处理功能,需要在 url 中添加参数:rewriteBatchedStatements=true

          jdbc.url=jdbc:mysql://localhost:3306/temp?rewriteBatchedStatements=true
          
        3. 批处理往往和 PreparedStatement 一起搭配使用,既可以减少编译次数,又可以减少运行次数,效率大大提高

          // 添加需要批量处理的 SQL 语句或参数
          preparedStatement.addBatch(null or String);
          if (i % 1000 == 0) {
             // 批量发送执行
             preparedStatement.executeBatch();
             // 清空批处理包
             preparedStatement.clearBatch();
          }
          
        4. 批处理源码剖析

          public void addBatch() throws SQLException {
             synchronized(this.checkClosed().getConnectionMutex()) {
                 if (this.batchedArgs == null) {
                     this.batchedArgs = new ArrayList();
                 }
          
                 for(int i = 0; i < this.parameterValues.length; ++i) {
                     this.checkAllParametersSet(this.parameterValues[i], this.parameterStreams[i], i);
                 }
          
                 this.batchedArgs.add(new com.mysql.jdbc.PreparedStatement.BatchParams(this.parameterValues, this.parameterStreams, this.isStream, this.streamLengths, this.isNull));
             }
          }
          
        13.9 数据库连接池
        1. 传统的 JDBC 数据库连接使用 DriverManager 来获取,每次向数据库建立连接的时候都需要将 Connection 加载到内存中,再验证 IP 地址、用户名、密码(耗时0.05s ~ 1s)是否正确。需要连接数据库的时候,就向数据库请求一个连接,频繁的请求操作将占用过多的系统资源,容易造成服务器崩溃。每一次数据库连接,使用完后都得及时断开,如果程序出现异常而导致未能正常关闭数据库连接,过多的数据库连接将导致数据库内存泄漏,最终导致数据库崩溃

        2. 数据库连接池原理:预先在缓冲池中放入一定数量的连接,当需要建立数据库连接时,只需从 “缓冲池” 中取出一个,使用完毕归还给缓冲池(并不断开与数据库的连接)。数据库连接池负责分配、管理和释放数据库连接,它允许应用程序重复使用一个现有的数据库连接,而不是重新建立一个,大大减轻了数据库的压力

        3. 数据库连接池控制创建数据库连接的数量,当应用程序向连接池请求的连接数超过最大连接数量时,这些请求将被加入到等待队列

        4. JDBC 的数据库连接池使用 javax.sql.DataSource 来表示,DataSource 只是一个接口,该接口具体实现留给第三方

        5. 各种数据库连接池之间的比较

          连接池特点
          C3P0速度相对较慢,稳定性不错(Hibernate、Spring 底层均采用)
          Druid阿里巴巴提供的数据库连接池,集 DBCP、C3P0、Proxool 优点于一身
          Proxool有监控连接池状态的功能,稳定性较 C3P0 略差
          BoneCP速度快
          DBCP速度较 C3P0 快,但不稳定
        13.10 C3P0 连接池
        1. 引入 mysql-connector-java-8.0.27.jar 和 c3p0-0.9.1.2.jar

        2. 给定数据库连接信息(也可用 properties 配置文件替代)

          // 创建数据源对象
          ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();
          // 设置相关信息
          comboPooledDataSource.setDriverClass("com.mysql.cj.jdbc.Driver");
          comboPooledDataSource.setJdbcUrl("jdbc:mysql://localhost:3306/temp");
          comboPooledDataSource.setUser("admin");
          comboPooledDataSource.setPassword("admin");
          comboPooledDataSource.setInitialPoolSize(10);
          comboPooledDataSource.setMaxPoolSize(50);
          // 获取一个数据库连接
          Connection connection = comboPooledDataSource.getConnection();
          System.out.println(connection);
          connection.close();
          
        3. c3p0-config.xml 配置文件方式

          1. c3p0-config.xml
          
          
              
                  com.mysql.cj.jdbc.Driver
                  
                  admin
                  admin
                  10
                  30
                  100
                  10
              
          
          
          1. 获取数据库连接
          // 将数据库配置信息写入到 c3p0-config.xml 配置文件中,并将配置文件拷贝到类路径下,C3P0 将会自动加载并读取此配置文件
          ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();
          Connection connection = comboPooledDataSource.getConnection();
          System.out.println(connection);
          connection.close();
          
        13.11 Druid 连接池
        1. 引入 mysql-connector-java-8.0.27.jar 和 druid-1.1.10.jar

        2. 通过配置文件 properties 加载数据库信息,获取数据库连接

          1. druid.properties
          driverClassName=com.mysql.cj.jdbc.Driver
          url=jdbc:mysql://localhost:3306/temp?useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=UTC
          characterEncoding=utf-8
          username=admin
          password=admin
          initialSize=5
          maxActive=10
          maxWait=3000
          validationQuery=SELECT 1
          testWhileIdle=true
          
          1. 获取数据库连接
          // 加载配置文件
          Properties properties = new Properties();
          properties.load(new FileInputStream("druid.properties"));
          // 创建一个的连接池
          DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);
          // 获得连接
          Connection connection = dataSource.getConnection();
          System.out.println(connection);
          connection.close();
          
        13.12 ApacheDBUtils
        1. 关闭 connection 后,resultSet 结果集无法继续使用,然而很多时候我们希望关闭 connection 连接后仍然可以继续使用查询到的数据;且resultSet 存储查询结果的方式不利于数据管理,从 resultSet 结果集中获取数据时操作方法不够明确,getXxx() 方法容易出错,含义模糊

        2. 定义一个类与数据库表的字段一一对应,这样的类一般称作 JavaBean 或 Domain 或 POJO 或 Entity,将返回的结果集的字段值封装到自定义的类的对象中,将若干个这样的对象放进集合中,就可以直接访问集合从而获得数据库表的查询结果

        3. 在创建 JavaBean 时类的字段的数据类型强制使用八大基本数据类型对应的包装类,因为 MySQL 数据库表中的字段值可能为空,而 Java 只有引用数据类型才有 NULL 值。创建 JavaBean 类的时候一定要给一个无参构造器,以方便通过反射机制获取该类信息

        4. commons-dbutils 是 Apache 组织提供的一个开源 JDBC 工具类,它是对 JDBC 的封装,使用 dbutils 能极大简化 JDBC 编码量。QueryRunner 类封装了 SQL 的执行,是线程安全的 ,可以实现 CRUD 和批处理。RessultSetHandler 接口用于处理 java.sql.ResultSet,将查询到的数据转换为第 2 步中提到的结果集形式

        5. DBUtils 常用 API

          接口名功能
          ArrayHandler将结果集中的第一行数据转换成对象数组
          ArrayListHandler将结果集中的每一行都转换成一个数组,再存放到 List 中
          BeanHandler将结果集中的第一行数据封装到一个对应的 JavaBean 实例中
          BeanListHandler将结果集中的每一行数据封装到对应的 JavaBean 实例中,存放到 List
          ColumnListHandler将结果集中的某一列数据存放到 List 中
          KeyedHandler(name)将每行数据封装到 Map 中,再将 map 存入另一个 Map 中
          MapHandler将结果集的第一行数据封装到 Map 中,key 是列名,value 是对应值
          MapListHandler将结果集中的每一行数据封装到 Map 中,再存放到 List 里
          // 获得连接
          Connection connection = JdbcUtilsByDruid.getConnection();
          // 获得 Apache 实现的查询对象
          QueryRunner queryRunner = new QueryRunner();
          String select = "SELECT * FROM cost WHERe id >= ? AND id <= ?";
          // 执行 SQL 语句获取查询结果
          List fishings = queryRunner.query(connection, select, new BeanListHandler<>(Fishing.class), 1, 10);
          for (Fishing fishing : fishings) {
              System.out.println(fishing);
          }
          JdbcUtilsByDruid.close(null, null, connection);
          
        13.13 BaseDao

        为每张数据库表设计一个 JavaBean ,同时为每一张数据库表设计一个专门操作该表的数据访问对象 Dao(Data Access Object),将所有的具体 Dao 类中的共有部分抽象出父类 BasciDao,以更好地利用多态完成数据库操作

        package com.bear.bookhouse.dao;
        
        
        import com.bear.bookhouse.util.JdbcUtil;
        import org.apache.commons.dbutils.QueryRunner;
        import org.apache.commons.dbutils.handlers.BeanHandler;
        import org.apache.commons.dbutils.handlers.BeanListHandler;
        import org.apache.commons.dbutils.handlers.ScalarHandler;
        
        import java.sql.Connection;
        import java.sql.SQLException;
        import java.util.List;
        
        
        public abstract class BaseDao {
            private final QueryRunner queryRunner = new QueryRunner();
        
            
            public int update(String sql, Object... params) {
                Connection connection = null;
                try {
                    connection = JdbcUtil.getConnection();
                    return queryRunner.update(connection, sql, params);
                } catch (SQLException e) {
                    e.printStackTrace();
                } finally {
                    JdbcUtil.close(connection);
                }
                return -1;
            }
        
            
            public  T getRecord(Class clazz, String sql, Object... params) {
                Connection connection = null;
                try {
                    connection = JdbcUtil.getConnection();
                    return queryRunner.query(connection, sql, new BeanHandler<>(clazz), params);
                } catch (SQLException e) {
                    e.printStackTrace();
                } finally {
                    JdbcUtil.close(connection);
                }
                return null;
            }
        
            
            public  List listRecord(Class clazz, String sql, Object... params) {
                Connection connection = null;
                try {
                    connection = JdbcUtil.getConnection();
                    return queryRunner.query(connection, sql, new BeanListHandler<>(clazz), params);
                } catch (SQLException e) {
                    e.printStackTrace();
                } finally {
                    JdbcUtil.close(connection);
                }
                return null;
            }
        
            
            public Object getSingleValue(String sql, Object... params) {
                Connection connection = null;
                try {
                    connection = JdbcUtil.getConnection();
                    return queryRunner.query(connection, sql, new ScalarHandler(), params);
                } catch (SQLException e) {
                    e.printStackTrace();
                } finally {
                    JdbcUtil.close(connection);
                }
                return null;
            }
        }
        
        转载请注明:文章转载自 www.mshxw.com
        我们一直用心在做
        关于我们 文章归档 网站地图 联系我们

        版权所有 (c)2021-2022 MSHXW.COM

        ICP备案号:晋ICP备2021003244-6号