- 一、基础语法
- 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
- JAVA_HOME = D:Javajdk1.8.0_131
- Path = %JAVA_HOME%bin
- CLASSPATH = .;%JAVA_HOME%libdt.jar;%JAVA_HOME%libtools.jar;
- JDK = JRE + Java 开发工具(java、javac、javap、javadoc ······)
- JRE = JVM + Java 核心类库
- JVM 是一个虚拟的计算机,具有指令集并使用不同存储区域。负责执行指令,管理数据、内存和寄存器,包含在 JDK 中
-
Java 数据类型中没有无符号类型
-
Java 浮点类型默认为 double 类型,定义 float 类型时需要在末尾加上 F 或 f。浮点数组成:符号位 + 指数位 + 尾数位
-
Java语言对布尔类型的存储并没有做规定,因为理论上存储布尔类型只需要 1 bit,但通常 JVM 内部会把 boolean 表示为 4 字节整数
-
八大基本数据类型的数据范围
类型 字节数 范围 byte 1 -128 - 127 short 2 -32768 - 32767 int 4 -231 - 231-1 long 8 -263 - 263-1 float 4 -3.403E38 - 3.403E38 double 8 -1.798E308 - 1.798E308 char 2 ISO 单一字符集 boolean 1 true or false
-
自动类型转换
- 自动类型转换一:char -> int -> long -> float -> double
- 自动类型转换二:byte -> short -> int -> long -> float -> double
- (byte,short) 和 char 之间不会自动类型转换
-
byte、char、short 在进行运算时,当作 int 处理
-
char 类型可以保存 int 类型的常量值,但不能保存 int 型的变量值,需要强转
char ch = 23; int i = 32; ch = (char) i;
-
浮点数运算和整数运算相比,只能进行加减乘除这些数值计算,不能做位运算和移位运算
-
整数运算在除数为 0 时会报错,而浮点数运算在除数为 0 时,不会报错,但会返回以下几个特殊值(NaN:Not a Number、Infinity:无穷大、-Infinity:负无穷大)
// ArithmeticException int i = 10 / 0; // j = Infinity double j = 10.0 / 0;
-
如果强制类型转换后超过了整型能表示的最大范围,将返回整型的最大值
double d = Double.MAX_VALUE; // max = 2147483647 int max = (int) d;
-
如果要进行四舍五入,可以对浮点数加上 0.5 再强制转型
-
自增、自减运算符
int i = 1; i = i++; // output:1 System.out.println(i); int i = 1; i = ++i; // output:2 System.out.println(i);
-
三元运算符
Object object = true ? new Integer(1) : new Double(2.0); // 三元运算符需要看作一个整体,故输出 1.0;if - else 分支结构则输出 1 System.out.println(object);
-
位运算
- 算术右移(>>):低位丢弃,符号位不变,高位补符号位
- 算术左移(<<):符号位不变,低位补 0
- 无符号右移(>>>):低位丢弃,高位补 0
-
运算符优先级,自上而下优先级依次降低
运算顺序 操作符 . () {} ; , 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 >>>= &= ^= |=
- strictfp:strict float point (精确浮点) ,strictfp 关键字可应用于类、接口、方法。 使用 strictfp 关键字声明一个方法时,该方法中所有的 float 和 double 表达式都严格遵守 FP-strict 的限制,符合 IEEE-754 规范
- volatile 是 jvm 提供的轻量级同步机制。作用是:保证可见性、禁止指令重排、不保证原子性
switch 的 case 后跟常量或常量表达式,switch 中的表达式只能是以下类型中的一种:byte、short、char、int、enum、String
二、面向对象 2.1 数组-
静态初始化方式创建数组
int[] array = {2,54,3,23}; -
new 方式创建数组,若没有赋值,则有默认值,由此可看出数组是引用类型
int[] a = new int[3]; // output: [0, 0, 0] System.out.println(Arrays.toString(a));
-
Java 中多维数组每行的元素个数可以不一致
int[][] array = new int[3][]; array[0] = new int[3]; array[1] = new int[2]; array[2] = new int[6];
-
Arrays 工具类遍历多维数组
int[][] array =new int[][]{ {1, 2, 3}, {2, 3}, {54, 234, 3, 131, 34} }; System.out.println(Arrays.deepToString(array));
-
Java 在内存中总是使用 Unicode 表示字符,所以,一个英文字符和一个中文字符都用一个 char 类型表示,它们都占用 2 个字节
-
注意要区分空值 null 和空字符串 “”,空字符串是一个有效的字符串对象,它不等于 null
-
使用 printf 输出 ‘%’
System.out.printf("%%"); -
常用字符集占用的字节数
字符集 字符占用字节数 汉字占用字节数 ASCII 1 不支持中文 Unicode 2 2 UTF - 8 1 3 GBK 1 2
- 构造器只负责完成对象的初始化,并不是创建对象。调用构造器时堆中已经分配了对象的空间,构造器只是负责对对象进行初始化
- 没有在构造器中对类的字段初始化时,引用类型的字段默认是 null,数值类型的字段用默认值:int类型默认值是 0,布尔类型默认值是 false(类的属性有默认值,局部变量没有默认值)
-
加载类信息,生成 .class 对象
-
在堆中为对象分配空间
- 栈:一般存放基本数据类型(局部变量)
- 堆:存放对象(数组)
- 方法区:常量池(字符串)、类加载信息
-
完成对象的默认初始化
-
构造器完成对象的初始化
-
继承内存布局
-
子类继承了父类所有的方法和属性,但父类的私有属性不能在子类中直接访问
-
当创建子类的对象时,无论使用子类的哪个构造器,默认情况下总会去调用父类的无参构造器,如果父类没有提供无参构造器,则必须在子类中使用 super 去显式调用父类的构造器完成父类的初始化工作,否则编译不会通过
-
super() 和 this() 都只能放在构造器的第一行,因此这两个方法不能同时存在一个构造器中
-
instanceof 实际上判断一个变量所指向的实例是否是指定类型,或者这个类型的子类
-
Object 类的 toString()、equas() 方法
public String toString() { return getClass().getName() + "@" + Integer.toHexString(hashCode()); } public boolean equals(Object obj) { return (this == obj); } -
Object 类的所字段与方法
-
super 代表父类的引用,用于访问父类的属性、方法、构造器,不能使用 super 访问父类的 private 成员
-
JVM 会给每个对象分配 this,代表当前对象。谁调用,this 就指向它
-
this 不能在类定义的外部使用,只能在类定义的方法中使用
-
this 关键字可以用来调用本类的构造器以及指向当前对象
-
super 与 this 的对比
区别点 this super 方法 访问本类属性,没有则依次查找父类 直接依次查找父类属性 属性 访问本类方法,没有则依次查找父类 直接依次查找父类方法 构造器 行首调用本类其它构造器 行首调用父类指定构造器 特殊 表示当前对象 表示子类中访问父类的对象 区别点
| 作用 | |
|---|---|
| == | 判断基本类型时判断值是否相等;判断引用类型时判断是否引用到同一个对象 |
| equals() | 只能判断引用类型是否引用到同一个对象,子类往往重写 |
- 子类重写父类的方法时,返回类型可以是父类或父类的子类
- 重写方法时子类不能缩小父类方法的访问权限
- 方法重载需保证方法签名不同,返回值不是方法签名的一部分
- 可变参数的实参可以是 0 个或是多个,其本质就是数组
- 形参列表中可以同时有普通形参和可变参数,但必须保证可变参数是形参列表的最后一个参数
- 一个方法的形参列表只能出现一个可变参数
- 当调用对象方法时,该方法会和该对象的内存地址(运行类型)动态绑定
- 当调用对象属性时,不存在动态绑定
- 多态是指:针对某个类型的方法调用,其真正执行的方法取决于运行时期实际类型的方法
- 类变量也即静态变量,类方法也即静态方法
- JDK8 以前类变量放在方法区的静态域中,JDK8 以后放在堆的对应类的 class 对象尾部
- 当方法中不涉及到与任何对象相关的成员时,则可以将方法设计为静态方法以提高运行效率
- 静态代码块、静态方法只能调用静态成员,普通方法和普通代码块可以调用任何成员
- 静态方法属于类而不属于类实例,因此在静态方法内部无法访问 this 变量,也无法访问实例字段,只能访问静态字段和静态实例
-
代码块可以理解为只有方法体的方法,它没有方法名、返回值、参数,不能通过对象或类显式调用,只有在加载类或是创建对象时隐式调用
-
代码块的修饰符只能是 static 或无修饰符,块体中的语句可以是任何正确逻辑语句
-
如果只是调用类的静态成员,普通代码块并不会执行,普通代码块可以看作是构造器的一种补充机制,所以在调用类的静态成员但没有创建类的对象时,构造器并未被调用,因而类的普通代码块不会被执行
class GirlFriend { public static final int AGE = 2; // 当使用到 GirlFriend.AGE 时,此静态代码块不会执行即此类未加载 static { System.out.println("I am your only girlfriend"); } } -
类代码块的执行顺序优先于构造器
-
类加载时机:创建该类的对象时、创建子类的对象时父类也会加载、使用类的静态成员时
- 父类的静态代码块和静态属性按定义顺序依次执行
- 子类的静态代码块和静态属性按定义顺序依次执行
- 父类的普通代码块与普通属性按定义顺序依次执行
- 父类的构造器
- 子类的普通代码块与普通属性按定义顺序依次执行
- 子类的构造器
-
设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格以及解决问题的思考方式。设计模式好比经典的棋谱,不同的棋局采用不同的棋谱,免去再次思考和摸索的过程
-
类的单例设计模式:采取一定的方法使得在整个软件系统中,某个类有且仅有一个对象实例,并且该类只提供一个取得该对象的方法
-
单例设计模式分为饿汉式和懒汉式,饿汉式与懒汉式的区别:饿汉式在类加载时就创建实例而懒汉式在使用到对象时才创建。饿汉式不存在线程安全问题,懒汉式存在线程安全问题
-
单例模式的实现
- 构造器私有化
- 在类的内部创建对象
- 向外部提供一个静态的公共方法取得该对象
// 单例设计模式饿汉式 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; } } -
java.lang.Runtime 类就是经典的懒汉式单例模式
public class Runtime { private static Runtime currentRuntime = new Runtime(); public static Runtime getRuntime() { return currentRuntime; } private Runtime() {} }
-
final 的使用场景:不希望某个类被继承、不希望父类的方法被子类重写、不希望类的成员值被修改、不希望局部变量的值被修改
-
final 修饰的属性必须初始化,此后无法更改。初始化可在三个地方进行:定义时初始化、构造器中初始化、代码块中初始化(如果 final 修饰的属性同时是 static 的,那么只能在两个地方初始化:定义时初始化、静态代码块中初始化)
public static final int MAX = 9; public static final int MIN; static { MIN = -1; } -
如果非 final 类中含有 final 修饰的方法,则该方法可以被继承但不能被重写
-
final 往往和 static 搭配使用,效率更高,因为底层编译器做了优化处理,不会导致类的加载
-
当父类的某些方法需要被声明,但又不确定如何实现时,可以将其声明为抽象方法,那么这个类就是抽象类
-
有抽象方法的类一定是抽象类,抽象类不一定有抽象方法,abstract 只可以修饰类和方法
public abstract class Node { public int getMax() { return 100; } } -
如果一个类继承自抽象类,则必须实现父类的所有抽象方法,除非它也是一个抽象类
-
抽象方法不能使用 private、final、static 来修饰,因为这些修饰符与重写相违背
-
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"); } } -
抽象类实现接口可以不用实现方法、接口继承接口时可以不用实现方法
-
继承与接口对比:继承解决代码的复用性与可维护性,而接口用来设计规范方法,一定程度上实现代码解耦
-
Java 的接口特指 interface 的定义,表示一个接口类型和一组方法签名,而编程接口泛指接口规范,如方法签名,数据格式,网络协议等
-
局部内部类:定义在外部类的局部位置且有类名,比如方法或代码块中,具有以下特点
- 内部类可以直接访问外部类的所有成员,包括私有的
- 不可以添加访问修饰符,可以添加 final
- 局部内部类可以理解为方法的局部变量
- 如果外部类和局部内部类的成员重名时,默认遵循就近原则。若想访问外部类的成员,可以使用 外部类名.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(); } } -
匿名内部类:定义在外部类的局部位置,比如方法中且没有类名,同时还是一个对象
- 匿名内部类本身既是一个类的定义同时也是一个对象,因而从语法层面看,它既有类的特征也有对象的特征
- 只能定义在方法或代码块中,匿名内部类的地位就好比一个没有名字的局部变量
- 经典使用场景:在方法参数位置直接实现接口当作实参传递,简洁高效不冗余
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(); } -
成员内部类:成员内部类可以理解为类的成员
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); } } } -
静态内部类:静态内部类可以理解类的静态成员,可以直接访问外部类的所有静态成员,但不能访问非静态成员
-
枚举定义:枚举是一组常量的集合,属于一种特殊的类,里面只包含一组有限的特定对象
-
自定义枚举类:构造器私有化、不提供 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; } }
-
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; } } -
使用 enum 关键字开发一个枚举类时,该类是一个 final 类并且默认继承 Enum 类
| 方法名 | 功能 |
|---|---|
| toString() | 返回当前对象名,子类可重写 |
| name() | 返回当前对象常量名,子类不可重写 |
| ordinal() | 返回当前对象的索引号,默认从 0 开始 |
| values() | 返回当前枚举类中的所有常量 |
| valueOf() | 将字符串转换枚举对象 |
| compareTo() | 比较两个枚举常量的索引号 |
- 注解(Annotation)也称为元数据(Metadata),用于修饰解释包、类、方法、属性、构造器、局部变量等数据信息
- 与注释一样,注解不影响程序逻辑,但注解可以被编译或运行,相当于嵌入在代码中的补充信息
- 在 Java SE 中,注解的使用目的比较简单,例如标记过时的方法、忽略警告等。但注解在 Java EE 中注解占据重要角色,例如用来配置应用程序的任何切面、代替 Java EE 旧版中所遗留的冗杂代码和 XML 配置等
重写方法时如果添加了 @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 异常分类及体系图
- Error(错误):Java 虚拟机无法解决的严重问题,如 JVM 系统内部错误、资源耗尽等严重情况
- Exception(异常):其它因编程错误或偶然的外在因素导致的一般性问题,可以使用针对性的代码进行处理。分为编译时异常和运行时异常
-
如果出现异常,则 try 块中发生异常语句后的语句不再执行。若有可能抛出异常而未处理,则由 JVM 打印异常信息后退出程序
-
若在 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; } }
- 如果继承 Exception,则属于编译异常,必须显式处理或抛出
- 如果继承 RuntimeException,则属于运行时异常,可以默认 throws 处理,较为方便
-
如果一个方法中的语句执行时可能生成某种异常,但不能确定如何处理这种异常,则可以在方法声明处显式地抛出异常,由调用者自行处理
-
编译异常必须处理,对于运行时异常,如不处理则默认 throws
-
子类重写父类的方法时,子类抛出的异常需小于等于父类定义的异常类型
-
throws 和 throw 的比较
意义 位置 抛出内容 throws 异常处理的一种方式 方法声明处 异常类型 throw 手动生成异常对象 方法体中 异常对象
八大包装类都是 final 类型的。除 Boolean 和 Character 外,其余包装类均继承父类 Number
6.2 装箱与拆箱jdk5 以前是手动装箱和拆箱。自动装箱底层调用的是对应包装类的 valueOf() 方法
// 手动装箱 Integer integer = Integer.valueOf(i); // 手动拆箱 int ii = integer.intValue();6.3 包装类与 String 间转换
-
包装类转 String
Integer i = 100; // 方式 1 String str = i + ""; // 方式 2 String str = i.toString(); // 方式 3 String str = String.valueOf(i);
-
String 转包装类
String str = "123"; // 方式 1 Integer i = Integer.parseInt(str); // 方式 2 Integer i = new Integer(str);
自动装箱机制,在 [-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 的创建机制
-
创建方式一:String s1 = "lcx"; 先从常量池查找是否有 “lcx” 数据空间,如果有,直接将 s1 指向 “lcx”;没有则新建后指向,s1 最终指向的是常量池的空间地址
-
创建方式二:String s2 = new String("lcx"); 先在堆中创建空间,维护了 String 的字段 value[] 属性,然后判断常量池中是否有 “lcx” 的数据空间。如果常量池没有 “lcx”,则新建后使用 value 指向;如果有,则 value 直接指向。s2 最终指向的是堆中 value 的地址
-
两种创建方式的内存布局图
-
经典面试题说明 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());
常量相加看池,变量相加看堆
// 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
- StringBuffer 是一个线程安全的 final 类,其字段 value[] 不是 final 类型的
- String 保存的是字符串常量,value 引用到常量池。而 StringBuffer 保存的是字符串变量,数据存放在堆中
- StringBuffer value[] 无参构造器默认初始化容量为 16。若构造器传入的是字符串,则初始化容量为字符串长度加上 16
- StringBuilder 线程不安全,与 StringBuffer 使用方法基本一致
-
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);
-
使用 Arrays.binarySearch() 方法对有序数组进行二分查找时,若不存在该元素,则返回该元素应在数组中位置下标的负值
-
Arrays.asList() 可以将数组转换为 List 类型的集合,运行类型为 Arrays$ArrayList,即 Arrays 类中的静态内部类 ArrayList
-
模拟 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; } } } } }
BigDecimal bigDecimal = new BigDecimal("242131.24321335243234123");
// 为避免结果为无限循环小数,可对结果指定精度以解决 ArithmeticException
BigDecimal res = bigDecimal.divide(new BigDecimal(1.1), BigDecimal.ROUND_CEILING);
System.out.println(res);
6.10 第二、三代日期类
-
JDK1.0 中出现的 java.util.Date 类,大多数方法在 jdk 1.1 引入的 Calendar 类中已被弃用,第二代日期类 Calendar 也存在着以下一些问题
- 可变性:像日期和时间这样的类应该是不可变的
- 偏移性:年份从 1900 开始,月份从 0 开始
- 格式化:不能对 Calendar 进行格式化
- 线程不安全,不能处理闰秒(每隔两天,多出 1s)
-
JDK8 引入了第三代日期类:LocalDate(日期)、LocalTime(时间)、LocalDateTime(日期时间)
LocalDateTime now = LocalDateTime.now(); DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy:MM:dd HH:mm:ss"); System.out.println(formatter.format(now));
-
Collection 集合体系图
-
Map 集合体系图
-
Collection 接口没有直接的实现子类,是通过它的子接口 Set 和 List 的实现类功能的
// 只要是 Collection 接口的实现类都可以做实参 boolean addAll(Collection extends E> c); boolean removeAll(Collection> c); boolean containsAll(Collection> c);
-
Iterator 对象称为迭代器,主要用于遍历 Collection 集合中的元素。所有实现了 Collection 接口的集合类都有一个 iterator() 方法,用以返回一个实现了 Iterator 接口的对象即返回一个迭代器
// 得到某个集合的迭代器 Iterator iterator = collection.iterator(); // 判断是否还有下一个元素 while(iterator.hasNext()){ System.out.println(iterator.next()); } -
Iterator 对象仅用于遍历集合,本身并不存放数据对象。使用增强 for 循环遍历集合时,底层仍然使用的 Iterator 进行遍历
实现 List 的集合类中的元素有序(加入顺序与取出顺序一致),允许存在重复,支持使用对应的索引值直接获取元素的值(与数组使用方式类似,优点是可动态扩充大小)
// 在索引为 index 的位置插入 element,后续元素后移 void add(int index, E element); // 指定起始索引的子集合 [fromIndex,toIndex) List7.4 ArrayListsubList(int fromIndex, int toIndex);
-
ArrayList 底层维护了一个 Object 类型的数组transient Object[] elementData;
-
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); } -
ArrayList 可以添加多个 null 元素,用法基本等同于 Vector,但 ArrayList 线程不安全而 Vector 线程安全
-
Vector 底层存维护了一个对象数组即 protected Object[] elementData;,Vectory 同 ArrayList 一样也允许添加多个 null 元素且操作线程安全
-
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); }
-
LinkedList 具有双向链表和双端队列特点,线程不安全。同 ArrayList、Vectory 一样,LinkedList 允许元素重复且可以添加多个 null 元素
-
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; } } } -
LinkedList 尾添加元素操作
// 添加新节点到表尾 void linkLast(E e) { // 先获取到尾指针 final Nodel = last; // 新添加的节点 final Node newNode = new Node<>(l, e, null); // 尾指针指向新加入的节点 last = newNode; // 将新节点连接到链表尾 if (l == null) first = newNode; else l.next = newNode; size++; modCount++; } -
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; }
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
-
HashSet 的底层使用的是 HashMap,JDK1.8 版本的 HashMap 底层是【数组 + 链表 + 红黑树】,而 JDK1.7 版本的 HashMap 底层是【数组 + 链表】。默认初始化大小为 16,扩容加载因子为 0.75
public HashSet() { map = new HashMap<>(); } -
HashMap 存储形式为键值对,所以在 HashSet 采用 HaspMap 实现存储时,value 为系统给定的 PRESENT
// Dummy value to associate with an Object in the backing Map private static final Object PRESENT = new Object();
-
HashMap 元素的存放过程
- 先通过 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); }- 将 hash 值与本次哈希表大小 -1 的值进行按位与运算获得本次添加的元素在哈希表中的位置号,若该位置上没有其它元素则直接存放
// 用本次哈希表长度减 1 与本次元素的 hash 值进行按位与运算获得元素在哈希表中的位置号 if ((p = tab[i = (n - 1) & hash]) == null) // 位置号上未存储元素则直接存放 tab[i] = newNode(hash, key, value, null);
- 位置上已经存在元素,则遍历该条链表判断是否已经存在相同元素,若已存在则不添加并且返回元素值,否则创建新的节点连接到链表尾。完整存放过程如下
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; } -
HashMap 的扩容机制:第一次添加时 transient Node
[] table; 扩容到 DEFAULT_INITIAL_CAPACITY 16,加载因子为 loadFactor 0.75,临界值为 threshold 12,如果 table 已添加元素个数 size 不小于 threshold,则 table 按照 2 倍方式扩容到 32,临界值为 24,依次类推 -
树化条件:在 Java8 中,如果哈希表的大小 >= 64 且某条链表的长度 >= 8 则将该条链表树化为红黑树
static final int MIN_TREEIFY_CAPACITY = 64; static final int TREEIFY_THRESHOLD = 8;
-
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); } } -
LinkedHashMap 有 head 和 tail 指针,使用使用头尾指针遍历 linkedHashSet 时取出元素的顺序与插入元素的顺序一致
transient LinkedHashMap.Entry
head; transient LinkedHashMap.Entry tail; -
元素插入、取出过程与 HashMap 基本一致,额外增加了维护双向链表的过程
-
Map 与 Collection 接口并列存在,用于保存具有映射关系的键值对:key - value,Map 中的 key 和 value 可以是任何引用类型
-
Map 中的 key 不允许重复,value 可以重复。key 最多有一个 null,而 value 可以有多个 null。当 key 相同而 value 不同时,用新的 value 替换旧的 value
-
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 -
使用 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()); }
HashMap 是线程不安全的 key-value 键值对集合,数据 key-value 封装在 HashMap$Node 中。JDK8 版本以下的 HashMap 底层实现是【哈希表 + 链表】,JDK8.0 版本及以上是【哈希表 + 链表 + 红黑树】,树化条件是哈希表长度不小于 64 且某颗链表的长度不小于 8 就将该颗链表树化为红黑树。当然,若某颗红黑树元素个数较少,则会触发剪枝行为即将红黑树重新转换为链表
7.12 Hashtable-
Hashtable 的键和值都不能为 null,为 null 则抛出 NullPointerException,使用方法与 HashMap 基本一致。Hashtable 线程安全,而 HashMap 线程不安全
-
Hashtable 扩容机制:初始化容量大小为 11,数组类型为 Hashtable$Entry,加载因子 loadFactor 0.75,按原有容量的 2 倍加 1 的机制进行扩容
// overflow-conscious code int newCapacity = (oldCapacity << 1) + 1;
- TreeSet 的底层使用 TreeMap,TreeMap 实现了 SortedMap 接口,即 TreeMap 中插入的元素是有顺序的
- 使用TreeMap时,放入的 Key 必须实现Comparable接口以自定义元素比较规则从而实现元素排序
- 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)))) 判断是否添加
- TreeMap 的去重机制:如果传入了 Comparator 匿名对象,则使用实现的 compare 方法中的比较方式去重,compare 方法返回 0 则认为是相同的元素。如果没有传入匿名比较器对象,则以所要添加的对象实现的 Comparaeable 接口的 compareTo 方法比较机制去重
- 单个对象且允许重复选择 List
| 应用场景 | 集合选择 | 底层结构 | 备注 |
|---|---|---|---|
| 改查多 | ArrayList | Object[] | 默认 size = 0,第一次添加 size = 10,按 1.5 倍扩容 |
| 增删多 | LinkedList | 双向链表 | |
| 多线程 | Vector | Object[] | 默认 size = 0,第一次添加 size = 10,按 2 倍扩容,键值均不允许为 null |
- 单个对象且不允许重复选择 Set
| 应用场景 | 集合选择 | 底层使用 | 备注 |
|---|---|---|---|
| 无顺序要求 | HashSet | HashMap | |
| 添加、取出顺序一致 | LinkedHashSet | LinkedHashMap | 继承自 HashSet |
| 元素有序排列 | TreeSet | TreeMap |
- 键值对 key-value 选择 Map
| 应用场景 | 集合选择 | 底层结构 | 备注 |
|---|---|---|---|
| 键顺序无要求 | HashMap | 数组+链表+红黑树 | size = 16,loadFactor = 0.75,按 2 倍扩容 |
| 插入、取出顺序一致 | LinkedHashMap | 数组 + 双向链表 | 继承自 HashMap |
| 多线程 | Hashtable | 数组+链表+红黑树 | size = 11,loadFactor = 0.75,按 2倍 + 1 扩容,不允许 null |
| 配置文件 | Properties | 数组+链表+红黑树 | 继承自 Hashtable |
| 键有序存放 | TreeMap | 红黑树? |
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 |
- 泛型使用与否:不使用泛型的弊端:不能对加入到集合中的数据类型进行约束(不安全)、遍历集合时需要进行显式类型转换;使用泛型的好处:编译时检查元素的类型,提高了安全性、减少了类型转换的次数,提高了运行效率
- 泛型又称参数化类型,是 jdk5.0 出现的新特性,解决数据类型的安全性问题,只需在类声明或实例化时指定具体需要的类型即可,编译期即可确定类型
- Java 泛型保证在编译期没有发出警告的代码,在运行阶段就不会发生类转换异常,使得代码更加简洁与健壮
- 泛型的使用规则:可以在类声明时通过一个标识符表示类中某个属性的类型、或者是某个方法的返回值类型、或者是参数类型。指定泛型类型时只能是引用类型。在给泛型指定具体类型后,可以传入该类型或其子类类型。省略指定泛型类型时,默认填充 Object
- >:支持任意泛型类型
- extends A>:支持 A 类以及 A 的子类,规定了泛型的上限
- super A>:支持 A 类以及 A 的父类,不限定于直接父类,规定了泛型的下限
-
自定义泛型的注意事项:
-
静态方法、静态字段中不能使用类的泛型
-
使用泛型的数组,不能进行初始化
-
泛型不具备继承性,即以下代码语法错误 // List
lists = new ArrayList ();
-
-
泛型方法可以定义在普通类中、也可以定义在泛型类中;泛型接口的类型,在继承接口或是实现接口时确定
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 { }
-
进程是程序的一次执行过程,或是正在进行的一个程序。是动态过程,有其自身的产生、存在和消亡过程
-
线程是由进程创建的,是进程的一个实体,一个进程可以拥有多个线程
-
并发:同一个时刻,多个任务交替执行,造成一种 “貌似同时” 的错觉。简单地说,单核 CPU 实现的多任务就是并发
-
并行:同一个时刻,多个任务同时执行,多核 CPU 实现的多任务就是并行
-
Java 获取系统的处理器个数
// 获取 JVM 可用处理器个数 Runtime runTime = Runtime.getRuntime(); System.out.println(runTime.availableProcessors());
-
继承 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(); } } } } -
实现 Runnable 接口创建线程
- Java 是单继承机制,若某个类已经存在父类,这时只能通过实现 Runnable 接口实现线程
- 实现 Runnable 接口的类不能直接调用 start() 方法,可以将对象作为 Thread(Runnable) 的参数,从而调用 start() 方法(静态代理设计模式)
- 实现 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(); } } } }
- new Dog().run() 与 new Dog().start() 的区别:前者只是单纯地调用 run() 方法,而后者启动了线程,在 start() 方法中实际调用了 start0() 方法,这是个 native 修饰的方法,真正实现了线程启动
- start() 方法调用了 start0() 方法后,该线程并不一定会马上执行,只是将线程变成了可运行状态,具体什么时候执行,取决于操作系统
| 方法名 | 功能 |
|---|---|
| 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 守护线程
-
用户线程:也叫工作线程,当线程的任务执行完成后结束或以通知方式结束
-
守护线程:一般是为工作线程服务的,当所有的用户线程结束,守护线程自动结束(经典守护线程:垃圾回收机制)
-
守护线程案例
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(); } } } }
| 状态 | 说明 |
|---|---|
| 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 | 已退出的线程处于此状态 |
-
未使用同步锁出现超卖现象
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)); } } } -
锁方法,抱着锁睡觉,未均匀卖票,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(); } } } -
锁代码块,线程不抱着锁睡觉,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(); } } }
-
线程同步:当有一个线程正在对内存进行操作时,其它线程都不可以对这个内存进行操作,直到该线程完成操作,其它线程才能对该内存进行操作,也即同一时刻只允许一个线程操作内存
-
Java 语言中,引入了对象互斥锁的概念,来保证共享数据操作的完整性。每个对象都对应一个可称为 “互斥锁” 的标记,这个标记用来保证在任意时刻,有且仅有一个线程可以访问该对象。用关键字 synchronized 来实现对象的互斥锁
-
同步方法:得到对象的锁,才可以操作对象的代码。可以将 synchronized 加在方法声明中,表示整个方法为同步方法,也可以将 synchronized 加在某段代码上,表明此段代码时同步代码
-
静态同步方法的锁是当前类本身(ClassName.class)
// 静态方法中的互斥锁加在类上 class SellTicket implements Runnable { public static void getTicket() { synchronized (SellTicket.class) { System.out.println("售出一张票"); } } } -
非静态同步方法的锁可以是它本身 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(); } } }
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 释放锁
- 当前线程的同步方法、同步代码块执行结束会释放锁
- 当前线程在同步方法、同步代码块中遇到 break、return 会释放锁
- 当前线程在同步方法、同步代码块中出现了未处理的 Error 或 Exception 导致结束会释放锁
- 当前线程在同步方法、同步代码块中执行了线程对象的 wait() 方法,当前线程暂停,并释放锁
- 当前线程在执行同步代码块、同步方法的过程中调用了 Thread.sleep()、Thread.yield() 方法暂停当前线程的执行,不会释放锁
- 线程执行同步代码块时,其它线程调用了该线程的 suspend() 方法将该方法挂起,该线程不会释放锁。suspend()、resume() 方法均已过时,不再推荐使用
流的定义:数据在数据源(文件)和程序(内存)之间经历的路径,以程序(内存)为参照,流入内存为输入流,流出内存为输出流
| 方法名 | 功能 |
|---|---|
| new File(String) | 根据路径构建一个 File 对象 |
| new File(File,String) | 根据父目录文件 + 子路径构建 |
| new File(String,String) | 根据父目录 + 子路径构建 |
| getName() | 获取文件名,包含文件扩展名 |
| getAbsolutePath() | 获取文件绝对路径 |
| getParent() | 获取文件父级目录 |
| length() | 获取文件大小,以字节为单位 |
| exists() | 判断是否存在 |
| isFile() | 判断是否是文件 |
| isDirectory() | 判断是否是目录 |
| mkdir() | 创建一级目录 |
| mkdirs() | 创建多级目录 |
| delete() | 删除空目录或文件 |
- 操作数据单位:字节流和字符流
- 数据流方向:输入流和输出流
- 流的角色:字节流和处理流(包装流)
- IO 流的四大抽象基类:InputStream(字节输入流)、 OutputStream(字节输出流)、Reader(字符输入流)、 Writer(字符输出流)
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 字符流
- FileWriter 使用后,必须 close() 或 flush(),否则数据只是暂存在缓冲区,并未写入文件
- 字符流底层调用字节流实现具体功能
-
节点流是底层流,直接对数据源进行操作,可以从一个特定的数据源读写数据,如 FileReader、FileWriter
-
处理流(又称包装流)是 “连接” 在已存在的流,为程序提供了更为强大的读写功能,如 BufferedReader、BufferedWriter。使用处理流时,只需关闭外层流即可,对应的节点流会自动关闭
-
使用处理流包装节点流,既可以消除不同节点流的实现差异,也可以提供更加方便的方法来完成文件操作,底层调用节点流实现具体功能。优点主要有以下两点:
- 性能提高:主要以增加缓冲的方式来提高输入输出的效率
- 操作便捷:提供了一系列便捷的方法来一次输入、输出大批量的数据(比如 BufferedReader 可以一次读取一行,而 FileReader 只能以字符数组形式进行读取)
-
处理流设计理念体现了修饰器模式。列表中前 5 行为节点流,其余行对应的流为处理流
分类 字节输入流 字节输出流 字符输入流 字符输出流 1 抽象基类 InputStream OutputStream Reader Writer 2 访问文件 FileInputStream FileOutputStream FileReader FileWriter 3 访问数组 ByteArrayInputSteam ByteArrayOutputStram CharArrayReader CharArrayWriter 4 访问管道 PipedInputStream PipedOutputStream PipedReader PipedWriter 5 访问字符串 StringReader StringWriter 缓冲流 BufferedInputStream BufferedOutputStream BufferedReader BufferedWriter 转换流 InputStreamReader OutputStreamWriter 对象流 ObjectInputStream ObjectOutputStream 抽象基类 FilterInputStream FilterOutputStream FilterReader FilterWriter 打印流 PirntStream PrintWriter 推回输入流 PushbackInputStream PushbackReader 特殊流 DataInputStream DataOutputStream
-
序列化与反序列化:Java 序列化是指把 Java 对象转换为字节序列的过程,而 Java 反序列化是指把字节序列恢复为 Java 对象的过程
-
若某个对象需支持序列化机制,则必须让其类是可序列化的,也即必须实现 Serializable 或 Externalizable 接口之一。其中 Serializable 是标记接口,无需实现任何方法,而 Externalizable 继承自 Serializable,需要实现方法
-
序列化的类中建议添加 SerialVersionUID 序列化版本 ID 以提高版本的兼容性。private static final long serialVersionUID = 362498820763181265L;
-
序列化对象时,默认将除了 static、transient(让某些被修饰的成员不被序列化) 修饰的成员以外的所有成员进行序列化保存,序列化要求类的所有字段类型也需要实现序列化接口
-
序列化具备可继承性:子类继承父类而父类已经实现了序列化接口,则子类也可以序列化
-
对象序列化示例,对象追加写入文件需要注意的问题: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();
-
标准输入: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()); } -
标准输出: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()); }
-
InputStreamReader -> Reader:可以将 InputStream(字节流输入流)包装成 Reader(字符输入流),同时指定编码
-
OutputStreamWriter -> Writer:可以将 OutputStream(字节输出流)包装成 Writer (字符输出流),同时指定编码
-
转换流使用示例
// 使用 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();
涉及字符输出到文件时需要手动 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 码值 |
-
IP 作用:用于唯一标识网络中的每台计算机(主机)
-
Windows 查看本机 IP 地址:ipconfig,Linux 查看 IP 信息:ifconfig
-
IP 分类:IPV4 用 4 字节共 32 位标识一个 IP 地址(点分十进制),IPV6 用 8 字节共 128 位标识一个 IP 地址
-
IP 地址的组成:网络地址 + 主机地址,127.0.0.1 表示本机地址
-
IP 的表示方法
分类 表示方法 范围 A 0 + 7 位网络号 + 24 位主机号 0.0.0.0 ~ 127.255.255.255 B 10 + 14 位网络号 + 16 位主机号 128.0.0.0 ~ 191.255.255.255 C 110 + 21 位网络号 + 8 位主机号 192.0.0.0 ~ 223.255.255.255 D 1110 + 28 位多播组号 224.0.0.0 ~ 239.255.255.255 E 11110 + 27 位留待后用 240.0.0.0 ~ 247.255.255.255 -
域名:将 IP 地址映射成域名(http 协议),一个域名与一个 IP 地址唯一对应
-
端口:用于标识计算机上特定的网络程序,以整数形式表示,范围是 0 ~ 65535,其中 0 ~ 1024 已被一些知名程序占用
-
TCP / IP(Transmission Control Protocol / Internet Protocol):传输控制协议 / 因特网互联协议,又名网络通讯协议
-
五层网络体系结构
TCP/IP模型 对应协议 应用层 http、ftp、telnet、DNS··· 传输层 TCP、UDP··· 网络层 IP、ICMP、ARP··· 物理 + 数据链路层 Link
- TCP(Transmission Control Protocol):在使用 TCP 协议前,须先建立 TCP 连接(三次握手方式),形成传输数据通道,建立成功后可进行大量数据的传输。数据传输完毕需释放已建立的连接,效率相对较低
- UDP(User Data Protocol):将数据、源地址、目的地封装成数据包,数据传输前不需要建立连接,所以传输并不可靠。数据传输完成无需释放资源,因而数据传输速度较 TCP 快、效率高,但每个数据包的大小限制在 64K 以内,多有不便
- Socket(套接字)开发网络应用程序时被广泛使用,以至于成为事实上的标准。通信的两端都要有 Socket,实际上就是实现两台机器间通信的端口。Socket 允许程序把网络连接当作是一个流,数据在两个 Socket 间通过 IO 传输。一般发起通信的应用程序为客户端,等待通信请求的为服务端
| 方法名 | 功能 |
|---|---|
| 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 字节流编程
-
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(); -
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();
-
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(); -
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();
-
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(); } } } } -
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(); } } } }
-
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; ArrayListfileNameList = 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("文件目录发送到客户端成功!"); // } } -
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("接收服务端发送的文件目录成功!"); // } }
-
UDP 编程没有明确的服务端和客户端,因此无需建立连接
-
UDP 数据包通过数据包套接字 DatagramSocket 实现发送和接收,系统不保证 UDP 数据包一定送达目的地,也不确定什么时候可以送达即传输不可靠。DatagramSocket 对象封装了 UDP 数据包,在数据包中封装了数据、发送端和接收端的 IP 地址以及端口信息
-
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();
-
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();
- netstat -an | more:可以查看当前主机网络情况,包括端口监听和网络连接情况
- netstat -anb:以管理员身份运行可以查看监听端口的具体程序
- 当客户端与服务端建立连接后,实际上客户端也是通过一个端口与服务端进行通信的,这个端口号是根据 TCP / IP 协议由系统随机分配的
// 加载配置文件,读取配置文件中的类信息
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 反射机制
-
反射机制允许程序在执行期借助于 Reflection API 取得任何类的内部信息(如成员变量、构造器、成员方法等),并能操作对象的属性及方法,反射在设计模式和框架底层使用广泛
-
加载完类之后,在堆中就产生了一个 Class 类型(Class 本身也是一个类)的对象(一个类只有一个 Class 对象,因为类只加载一次),这个对象包含了类的完整结构信息,通过这个对象就可以得到类的所有信息
-
反射的作用
- 在运行时判断任意一个对象所属的类
- 在运行时构造任意一个类的对象,获取其属性或调用其方法
- 生成动态代理
-
反射的优点:可以动态创建和使用对象(框架底层核心),没有反射框架就失去了灵魂
-
反射的缺点:使用反射代码基本是解释执行,对执行速度有一定影响
-
反射的优化:关闭访问检查(Method、Field、Constructor 类都有一个 setAccessible(boolean) 方法,作用是启动和禁用访问安全检查的开关,传入参数 true 表示反射的对象在使用时取消安全检查,提高反射效率,提高效果并不明显)
- 代码阶段(编译阶段):将源码 .java 文件通过 javac 编译得到 .class 字节码文件
- Class 类阶段(加载阶段):通过类加载器(ClassLoader)将 .class 字节码文件加载到堆中生成 Class 类的对象,该对象记录了 .class 中类的字段 Field[] fields、构造器 Constructor[] constructors、方法 Method[] methods 等信息
- Runtime(运行阶段):通过 new 创建出的对象知道自己与哪个 Class 类型的对象相关联 obj.getClass()
-
java.lang.Class 代表一个类,继承自 Object 类,Class 对象代表某个类的字节码文件被类加载器加载后在堆中生成的 Class 类型的对象。加载类在堆里生成 Class 对象的同时也会在方法区生成对应类的字节码的二进制数据,也称为类的元数据,该二进制数据引用到 Class 类型对象
-
Class 类对象并不是 new 出来的,而是系统创建的,通过 ClassLoader 类的 loadClass 方法创建。对于某个类的 Class 对象,在堆中有且仅有一份,因为类只加载一次。通过一个类对应的 Class 对象,即可获取到该类的完整结构
-
哪些类型有Class对象:外部类、内部类、接口、数组、枚举、注解、基本数据类型、void
-
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));
-
编译阶段:Class.forName(String); 多用于配置文件,读取到类的全路径,而后加载类
-
类加载阶段:ClassName.class; 多用于参数传递,此方式最为安全可靠,程序性能最高
-
运行阶段:object.getClass(); 通过创建好的类的对象来获取 Class 对象也即运行类型
-
类加载器:object.getClass().getClassLoader().loadClass("ClassFullPath");
Car car = new Car(); // 获得类对应的类加载器 ClassLoader classLoder = car.getClass().getClassLoader(); // 获得 Class 对象 Class> aClass = classLoder.loadClass("com.springbear.Car"); -
八大基本数据类型直接使用:Class clazz = int.class;
-
基本数据类型对应的包装类,可以通过 ClassName.TYPE 获得 Class 对象:Class cls = Integer.TYPE;
-
静态加载:编译时加载相关的类,如果不存在相关类则报错,依赖性很强
-
动态加载:运行过程中在需要时加载该类,如果运行时未使用到该类,则不报错,降低了依赖性。反射机制是 Java 实现动态的关键也即通过反射实现类动态加载
-
类加载的时机:
- new 创建对象时
- 子类被加载时其父类也被加载
- 访问到类的静态成员时(非 static final)
- 通过反射加载
-
加载(Loading):将类的 .class 文件读入内存,并为之创建一个 Class 类型的对象,由类加载器完成
-
连接(Linking):将类的二进制数据合并到 JRE 中。细分为验证(Verification)、准备(Preparation)、解析(Resolution)三个子阶段
-
验证(verification):目的是为了确保 .class 文件的字节流中包含的信息符合当前虚拟机的要求,不会危害到虚拟机自身的安全。验证包括对文件格式验证(是否以魔数 oxcafebabe 开头)、元数据验证、字节码验证和符号引用验证等。可以考虑使用 -Xverify:none 参数来关闭大部分的类验证措施,缩短虚拟机加载时间
-
准备(preparation):JVM 会在此阶段给静态变量分配内存并执行默认初始化,这些变量所使用的内存都会在方法区中进行分配
// 在连接的准备子阶段先默认初始化为 0,后在初始化阶段再显式初始化为 1 public static int num1 = 1; // 在连接的准备子阶段直接初始化为 2 public static final int num2 = 2;
-
解析(resolution):JVM 将常量池内的符号引用替换为直接引用的过程
-
-
初始化(Initialization):真正执行类中定义的 Java 代码,此阶段是执行
() 方法的过程。 () 方法的执行过程是由编译器按代码在源文件中的出现顺序,依次收集类中所有的静态变量的赋值动作和静态代码块中的语句,并自动进行合并。JVM 保证一个类的 () 方法在多线程环境中会被正确地加锁、同步 static { System.out.println("静态代码块被执行!"); num = 300; } public static int num = 100; // 经() 方法收集合并后如下 System.out.println("静态代码块被执行!"); num = 100; -
类加载后内存布局情况:
- 在方法区存放类的字节码的二进制数据(元数据),元数据引用到对应的 Class 对象
- 在堆中存放类的 Class 对象(数据结构)
-
调用类的指定构造器
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); -
操作类的字段:如果获取的是静态属性,则 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)); -
操作类的方法:如果获取的是静态方法,则 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); -
最佳实践:在指定目录下创建文件
// 加载类信息 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 为访问不同的数据库定义了统一的接口,具体实现由各数据库厂商完成。Java 程序员使用 JDBC API 可以连接任何提供了 JDBC 驱动程序的数据库系统,从而完成对数据库的各种操作,只需面向这套接口编程即可,相关的接口和类在 java.sql 和 javax.sql 包中
-
JDBC 程序编写步骤:
- 注册驱动:加载 Driver 类
- 获取连接:获得 Connection 对象
- 执行 SQL:获得 Statement 对象
- 释放资源
-
静态加载方式连接到数据库
// 连接到的数据库: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(); -
使用反射动态加载驱动类 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); -
使用 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); -
使用反射加载驱动类 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); -
读取配置文件中的数据库信息,获取数据库连接
// 从配置文件中读取数据库信息 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);
-
ResultSet:表示从数据库读取到的数据表结果集。ResultSet 对象保持一个光标指向当前的数据行。最初,光标位于第一行之前。其有一个 next 方法将光标移动到下一行,并且由于在 ResultSet 对象中没有更多行时返回 false,因此常用 while 循环来遍历结果集
-
com.mysql.jdbc.JDBC42 ResultSet 类下有一个 RowData(接口) 类型的字段,rowData 中有一个 ArrayList
类型的集合 rows,rows 中又有 byte[] 类型的 internalRowData,数据真正存储的位置 -
查询数据库记录示例
// 从配置文件中读取数据库信息 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();
-
SQL 注入是利用某些系统没有对用户输入的数据进行充分的检查,而在用户输入的数据中注入非法的 SQL 语句段或命令,恶意攻击数据库
-
在建立数据库连接之后,想要对数据库进行操作,一般有以下三种方式:
- Statement:存在 SQL 注入
- PreparedStatement:预处理(解决 SQL 注入)
- CallableStatement:用于执行数据库存储过程
-
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(); } }
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
| 接口名 | 方法名 | 功能 |
|---|---|---|
| Connection | createStatement() | 创建执行静态 SQL 语句的对象 |
| createPreparedStatement(sql) | 获得 SQL 语句预处理对象 | |
| Statement | executeUpdate(sql) | 执行 DML 语句,返回受影响行数 |
| executeQuery(sql) | 执行 DQL 语句,返回结果集 | |
| execute(sql) | 执行任意 SQL 语句,返回布尔值 | |
| PreparedStatement | executeUpdate(sql) | 执行 DML 语句,返回受影响行数 |
| executeQuery(sql) | 执行 DQL 语句,返回结果集 | |
| execute(sql) | 执行任意 SQL 语句,返回布尔值 | |
| setXxx(index,value) | 设置 SQL 语句中的值 | |
| setObject(index,value) | 设置 SQL 语句中的值 | |
| ResultSet | next() | 向下移动一行,到表尾返回 false |
| previous() | 向上移动一行,到表头返回 false | |
| getXxx(index || colLabel) | 获得指定列的值 | |
| getObject(index || colLabel) | 获得指定列的值 |
-
JDBC 程序中当一个 Connection 对象被创建时,默认情况下是自动提交事务:每执行一条 SQL 语句时,如果执行成功,就会向数据库自动提交保存,不能进行回滚
-
开启事务:可以调用 Connection 接口的 setAutoCommit(false) 方法关闭自动提交事务,在所有的 SQL 语句都执行成功后,调用 commit() 方法提交事务,在其中某个操作失败或出现异常时,调用 rollback() 方法回滚事务
-
经典事务操作:打钱
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); } }
-
当需要成批插入或者更新记录时,可以采用 Java 的批处理更新机制,这一机制允许多条语句一次性提交给数据库批量处理。通常情况下比单条语句提交处理效率更高
-
JDBC 连接 MySQL 时,如果需要使用批处理功能,需要在 url 中添加参数:rewriteBatchedStatements=true
jdbc.url=jdbc:mysql://localhost:3306/temp?rewriteBatchedStatements=true
-
批处理往往和 PreparedStatement 一起搭配使用,既可以减少编译次数,又可以减少运行次数,效率大大提高
// 添加需要批量处理的 SQL 语句或参数 preparedStatement.addBatch(null or String); if (i % 1000 == 0) { // 批量发送执行 preparedStatement.executeBatch(); // 清空批处理包 preparedStatement.clearBatch(); } -
批处理源码剖析
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)); } }
-
传统的 JDBC 数据库连接使用 DriverManager 来获取,每次向数据库建立连接的时候都需要将 Connection 加载到内存中,再验证 IP 地址、用户名、密码(耗时0.05s ~ 1s)是否正确。需要连接数据库的时候,就向数据库请求一个连接,频繁的请求操作将占用过多的系统资源,容易造成服务器崩溃。每一次数据库连接,使用完后都得及时断开,如果程序出现异常而导致未能正常关闭数据库连接,过多的数据库连接将导致数据库内存泄漏,最终导致数据库崩溃
-
数据库连接池原理:预先在缓冲池中放入一定数量的连接,当需要建立数据库连接时,只需从 “缓冲池” 中取出一个,使用完毕归还给缓冲池(并不断开与数据库的连接)。数据库连接池负责分配、管理和释放数据库连接,它允许应用程序重复使用一个现有的数据库连接,而不是重新建立一个,大大减轻了数据库的压力
-
数据库连接池控制创建数据库连接的数量,当应用程序向连接池请求的连接数超过最大连接数量时,这些请求将被加入到等待队列
-
JDBC 的数据库连接池使用 javax.sql.DataSource 来表示,DataSource 只是一个接口,该接口具体实现留给第三方
-
各种数据库连接池之间的比较
连接池 特点 C3P0 速度相对较慢,稳定性不错(Hibernate、Spring 底层均采用) Druid 阿里巴巴提供的数据库连接池,集 DBCP、C3P0、Proxool 优点于一身 Proxool 有监控连接池状态的功能,稳定性较 C3P0 略差 BoneCP 速度快 DBCP 速度较 C3P0 快,但不稳定
-
引入 mysql-connector-java-8.0.27.jar 和 c3p0-0.9.1.2.jar
-
给定数据库连接信息(也可用 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(); -
c3p0-config.xml 配置文件方式
- c3p0-config.xml
com.mysql.cj.jdbc.Driver admin admin 10 30 100 10 - 获取数据库连接
// 将数据库配置信息写入到 c3p0-config.xml 配置文件中,并将配置文件拷贝到类路径下,C3P0 将会自动加载并读取此配置文件 ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource(); Connection connection = comboPooledDataSource.getConnection(); System.out.println(connection); connection.close();
-
引入 mysql-connector-java-8.0.27.jar 和 druid-1.1.10.jar
-
通过配置文件 properties 加载数据库信息,获取数据库连接
- 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
- 获取数据库连接
// 加载配置文件 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();
-
关闭 connection 后,resultSet 结果集无法继续使用,然而很多时候我们希望关闭 connection 连接后仍然可以继续使用查询到的数据;且resultSet 存储查询结果的方式不利于数据管理,从 resultSet 结果集中获取数据时操作方法不够明确,getXxx() 方法容易出错,含义模糊
-
定义一个类与数据库表的字段一一对应,这样的类一般称作 JavaBean 或 Domain 或 POJO 或 Entity,将返回的结果集的字段值封装到自定义的类的对象中,将若干个这样的对象放进集合中,就可以直接访问集合从而获得数据库表的查询结果
-
在创建 JavaBean 时类的字段的数据类型强制使用八大基本数据类型对应的包装类,因为 MySQL 数据库表中的字段值可能为空,而 Java 只有引用数据类型才有 NULL 值。创建 JavaBean 类的时候一定要给一个无参构造器,以方便通过反射机制获取该类信息
-
commons-dbutils 是 Apache 组织提供的一个开源 JDBC 工具类,它是对 JDBC 的封装,使用 dbutils 能极大简化 JDBC 编码量。QueryRunner 类封装了 SQL 的执行,是线程安全的 ,可以实现 CRUD 和批处理。RessultSetHandler 接口用于处理 java.sql.ResultSet,将查询到的数据转换为第 2 步中提到的结果集形式
-
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);
为每张数据库表设计一个 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;
}
}


![[Study]Java [Study]Java](http://www.mshxw.com/aiimages/31/941046.png)
