共计 19765 个字符，预计需要花费 50 分钟才能阅读完成。
@TOC
JAVA
简历：技术（10W）+ 我的项目（20W）+ 算法(30W) + 业务(50~100W) + 行业视线（上不封顶）
①JavaSE
JAVA 背景常识
JDK 装置和配置
程序的运行机制
- Java 语言是编译型和解释型的联合
![[外链图片转存失败, 源站可能有防盗链机制, 倡议将图片保留失败, 源站可能有防盗 a 下来 img-E8Ie02)(C:\Ue10V-526\011027\AppData\Roaming\Typora\typora-user-images\image-2021480310176152570.pg6
9)(C:\Users\UC241027\AppData\Roaming\Typora\typora-user-images\image-20210310171652570.png)]](https://img-blog.csdnimg.cn/2…
- JVM（Java Virtual Machine）：它定义了指令集、寄存器集、构造栈、垃圾收集堆、内存区域，负责 java 字节码解释运行，边解释边运行，一次编译随处运行。
- JRE（Java Runtime Environment）：Java 虚拟机、库函数、运行 Java 应用程序必须的文件。
- JDK（Java Development Kit）：蕴含 JRE，以及减少编译器和调试器等用于程序开发的文件。
Java 装置与配置
- 环境变量 Path 配置
JAVA_HOME : JAVA 装置的目录
Path:%JAVA_HOME%\bin
第一个 Java 程序
- Java 编译的时候，呈现 unmappable character for encoding GBK
解决办法：
1、因为零碎默认编码不是 utf8，所以要将编译改写为 javac -encoding UTF-8 XXX.java 就能够失常输入
2、将 XXX.java 文件另存为 –> 抉择编码 ANSI 保留
变量、数据类型、运算符
标识符
- ASCⅡ字符集：12^8 = 256
- Unicode 国内字符集：2^16 = 65536
变量
- 变量实质是可操作的存储空间，空间地位是确定的，值不确定；变量名拜访“对应的存储空间”，操作这个“存储空间”存储的值
- 局部变量、成员变量（也称实例变量）和动态变量
数据类型
- boolean 类型是 4 个字节，数组中是 1 个字节（在内存中占 1 个字节或 4 个字节）
- 数字格式化输入
System.out.format("%.3f %.3f\n",r,volume);
System.out.printf("%.3f %.3f\n",r,volume);运算符
- 整数运算：
两数有一个为 long, 则后果为 long。
没有 long 时，后果为 int。即便操作数全为 short、byte，后果也是 int。
- 浮点运算：
有一个为 long，后果为 long。
两个为 float，后果才为 float。
- 取模运算：
个别应用整数，后果是”余数“，”余数“符号和右边雷同。
- 自增、自减
a++ // 先赋值，再自增
++a // 先自增，再赋值
- 关系运算符
\>、>=、<、<= 仅针对数值类型（byte/short/int/long,float/double 以及 char–>0~65535）
- 逻辑运算符
- 位运算符
- 数据类型的转换
整型常量是 int 类型，然而能够主动转为：byte、short、char。只有不超过对应类型的范畴。
管制语句
- 管制语句分为：程序、抉择、循环；
- 任何软件和程序，实质上都是有 ” 变量、抉择语句、循环语句 ” 组成。
switch 语句
- switch 语句中 case 标签在 JDK1.5 之前必须是整数（long 类型除外）或枚举，不能字符串，但在 JDK1.7 之后容许应用字符串
Scanner 类 键盘输入
-
java 中 Scanner 类 nextInt 之后用 nextLine 无奈读取输出
问题呈现起因：
这是因为在调用 nextLine()函数前调用了 Scanner 的另一个函数 nextInt()（或是 nextDouble()）。呈现这种状况的起因是两个函数的解决机制不同，nextInt()函数在缓冲区中遇到“空格”、“回车符”等空白字符时会将空白字符前的数据读取走，但空白字符不会被解决掉，而 nextLine()函数是在缓冲区中读取一行数据，这行数据以“回车符”为完结标记，nextLine()会把包含回车符在内的数据提走。所以 nextInt()后的 nextLine()函数并非读取不到数据，因为 nextInt()将“回车符”留在了缓冲区，nextLine()读取时遇到的第一个字符便是“回车符”，所以间接完结了。
解决办法：
在要应用 nextLine()前先调用一次 nextLine()，这样留在缓冲区的“回车符”就会被解决掉，这时第二个 nextLine()函数能够失常读取到数据。
办法
办法重载（overload）：理论是齐全不同的办法，只是名称雷同而已，释义：定义多个办法名雷同，但参数不同的办法。
-
形成办法重载的条件：
- 不同的含意：形参类型、形参个数、形参程序不同
- 只有返回值不同不形成办法的重载（如：int a(String str){}与 void a(String str){}不形成办法重载）
- 只有形参的名称不同，不形成办法的重载
- 办法重写的三个要点：
面向对象编程
- 属性用于定义该类或该类对象蕴含的数据或者说动态特色。成员变量能够对其初始化，如果不对其初始化，Java 应用默认的值对其初始化。
- 成员变量的默认值
- 结构器 4 个要点
- JAVA 虚拟机内存模型概念
- 容易造成内存透露的操作
①. 创立大量无用对象
②. 动态汇合类的应用
③. 各种连贯对象（IO 流对象、数据库连贯对象、网络连接对象）未敞开
④. 监听器的应用
- 对象的申明周期
- 创建对象四步
①. 调配对象空间，并将对象成员变量初始化为 0 或空
②. 执行属性值得显式初始化
③. 执行构造方法
④. 返回对象的地址给相干的变量
- 应用
通过变量援用操作对象
- 回收
对象咩有被变量应用，则被认为是”垃圾“, 会被垃圾回收器回收
this、static 关键字
this 关键字
- 创立一个对象分为四步：
** this 的实质是“创立好的对象地址”，在构造方法调用前，对象曾经创立。因而，在构造方法中应用 this 示意 ” 以后对象 ”。
- this 最常的用法
static 关键字
继承
继承的实现
- 继承要点：
instanceof 运算符
instanceof 是二元运算符，右边是对象，左边是类；当对象是左边类或子类所创建对象时，返回 true; 反之为 false。
public class Person{
String name;
int age;
public static void main(String[] args){Student s = new Student(“AAA”,66);
System.out.println(s instanceof Person);
System.out.println(s instanceof Student);
}
}
class Student extends Person{}办法的重写 override
子类通过重写父类的办法，能够用本身的行为替换父类的行为；办法的重写是实现多态的必要条件。
- 办法重写须要合乎三个要点：
final 关键字
属性和办法前加 final，是不可扩大（继承）和更改的，办法不可重写，但可重载。
- final 关键字的作用：
继承和组合
组合不同于继承，更加灵便。
组合的外围是将父类对象作为子类的属性，而后，子类通过调用这个属性来获取父类的属性和办法。
- 组合：排汇或并购
public class Animal{public static void main(String[] args){Taidi t = new Taidi();
t.dog.shout();}
}
class Dog{public void shout(){System.out.println("wangwang....");
}
}
// 组合
class Taidi {Dog dog = new Dog(); //Taidi 蕴含（排汇）了 Dog, 所以具备了 Dog 的属性和办法
}总结： 继承除了代码复用、也能不便咱们对事务建模。”is a“关系倡议应用继承，”has a“关系倡议应用组合。（如：Student is a Person 逻辑就没问题，但 Student has a Person 就有问题了；笔记本和芯片的关系属于蕴含，则能够应用”has a“）
super 关键字
- super 能够看做是间接父类对象的援用。通过 super 来拜访被子类笼罩的办法或属性。
- 应用 super 调用一般办法，语句没有地位限度，能够在子类中轻易调用。
- 若构造方法的第一行代码没有显式的调用 super()或者 this(); 那么 java 默认都会调用 super(), 含意是调用父类的无参数构造方法。super()可省略。
继承树追溯
封装（encapsulation）
- 封装的具体的长处
- 封装的实现 — 应用拜访控制符
+ protected 须要留神的两个细节
多态
多态指的是同一个办法调用，因为对象不同可能会有不同的行为。
- 多态的要点
- 多态的必要三个条件
- 继承
- 重写
- 父类援用指向子类对象
- 类型的强制转化，分编译和运行，编译看右边，编译之后是什么类型就执行什么样的办法；运行看左边。
形象办法和抽象类
abstract 润饰的办法，没有办法体，只有申明。定义的是一种 ” 标准 ”，就是通知子类必须要给形象办法提供具体的实现。
- 抽象类的应用要点：
接口 interface
- 面向对象的精华，是对对象的形象，最能体现这一点的就是接口。
- 接口就是比 ” 抽象类 ” 还 ” 形象 ” 的 ” 抽象类 ”。（abstract）
- 接口就是定规范的，就是要让他人实现的。（public）
- 接口申明办法的时候能够不写 public 和 abstract，默认是有的。
- 接口定义的是不变的，如变量只能定义为常量。能够不写 public abtract final 来润饰变量，默认是有的。
定义接口的具体阐明：
区别：
- 一般类：具体实现
- 抽象类：具体实现，标准（形象办法）
-
接口：JDK1.8 之前只有标准，但 JDK1.8 之后新增了静态方法和默认办法
- 默认办法：
默认办法和形象办法的区别是形象办法必须要被实现，因为默认办法有办法体，所以不须要实现，在接口中 default 必须要写，通过实现类的对象调用。 - 静态方法：
能够在接口中间接定义静态方法的实现。这个静态方法间接从属于接口（接口也是类，一种非凡的类），能够通过接口名调用。
- 默认办法：
接口的多继承
接口齐全反对多继承，和类的继承相似，子接口扩大某个父接口，将会取得父接口中所定义的所有。
字符串 String 类详解
字符串 String 是在办法区的字符串常量池（String Pool）中存储
String 类和常量池
- 常量池分三种：
- String 根底
外部类
- 外部类：
- 定义在一个类的外部的类，目标是方便使用外部类的相干属性和办法；
- 外部类只是一个编译时概念，一旦编译胜利，就会成为齐全不同的两个类。
- 外部类作用
- 外部类的分类
- 非动态外部类
// 外部类
public class Outer {
private int age = 10;
private void show(){System.out.println("good!!!");
}
// 非动态外部类
public class Inner{
private String name = "tom";
private int age = 20;
public void showInner(){System.out.println("Inner.showInner");
System.out.println(age);
System.out.println(Outer.this.age);
show();}
}
public static void main(String[] args) {Outer.Inner inner = new Outer().new Inner(); // 通过 new 外部类名(). 外部类名() 来创立外部类对象
inner.showInner();}
}- 动态外部类
// 外部类
public class Outer {
private int a = 10;
private static int b = 20;
// 动态外部类
static class Inner{public void test(){System.out.println(b);
}
}
public static void main(String[] args) {Outer.Inner inner = new Outer.Inner(); // 通过 new 外部类名. 外部类名() 来创立外部类对象
inner.test();}
}- 匿名外部类
适宜那种只须要应用一次的类。
public class AnonymousInnerClass {public void test(A a){a.run();
}
public static void main(String[] args) {AnonymousInnerClass anonymousInnerClass = new AnonymousInnerClass();
// 匿名外部类
anonymousInnerClass.test(new A() {
@Override
public void run() {System.out.println("匿名外部类是没有名字的类，只需应用一次；如果从新调用一次，就会定义新的匿名外部类！");
}
});
}
}
interface A{void run();
}- 部分外部类
定义在办法外部的，作用域只限于本办法。
public class LocalInnerClass{public void show(){
// 作用域仅限于该办法
class Inner{public void fun(){System.out.println("部分外部类的实现！");
}
}
new Inner().fun();
}
public static void main(String[] args){new LocalInnerClass().show();}
}数组
数组：雷同类型数据的有序汇合，数组也是对象。
- 数组的四个根本特点
数组初始化
- 1、数组动态初始化
例如：
int[] a = {1,2,3}; // 动态初始化根本类型数组
Man[] mans = {new Man(1,1),new Man(2,2)}; // 动态初始化援用类型数组
- 2、数组动静初始化
例如：
int[] a = new int[2]; // 动静初始化数组，先调配空间
a[0] = 1; // 给数组元素赋值
a[1] = 2; // 给数组元素赋值
- 3、数组的默认初始化
例如:
int[] a = new int[2]; // 默认值：0,0
boolean[] b = new boolean[2]; // 默认值：false,false
String[] s = new String[2]; // 默认值：null,null
总结：默认初始化 —-> 数组元素相当于对象的属性，恪守对象属性默认初始化的规定。
异样机制
当程序呈现谬误，程序平安的、继续执行的机制。
JAVA 罕用类
Wrapper 包装类
包装类：能够把根本类型、包装类对象、字符串三者进行互相转化
- 主动装箱和拆箱
- 包装类的缓存问题
当数字在 [-128,127] 之间的时候，返回缓存数组中的某个元素。
public class Test{public static void main(String[] args){// 当数字在 [-128,127] 之间的时候，返回的是缓存数组中的某个元素
Integer i1 = 123; // 主动装箱；编译器：Integer i1 = Integer.valueOf(123);
Integer i2 = 123; // 主动装箱；编译器：Integer i1 = Integer.valueOf(123);
System.out.println(i1 == i2); // true; 是因为 123 都是从缓存中取的同一个元素
System.out.println(i1.equals(i2)); // true
}
}字符串相干类
String 类：不可变字符序列，会产生新对象的。
StringBuilder 类：可变字符序列；效率高，然而线程不平安；增加字符序列，返回本身对象。
StringBuffer 类：可变字符序列；效率低，然而线程平安；增加字符序列，返回本身对象。
- String 类
public class Test{public static void main(String[] args){
// 编译器做了优化，在编译的时候，左边是字符串常量, 不是变量，所以间接将字符串做了拼接
String str1 = "hello" + "java"; // 相当于 str1 = "hello java";
String str2 = "hello java";
System.out.println(str1 == str2); //true
String str3 = "hello";
String str4 = "java";
// 编译的时候不晓得变量中存储的是什么，所以没方法在编辑的时候做优化
String str5 = str3 + str4;
System.out.println(str2 == str5); //false
}
}- 效率测试
public class Test {public static void main(String[] args) {
String str = "";
long num1 = Runtime.getRuntime().freeMemory();
long time1 = System.currentTimeMillis();
for(int i = 0;i < 5000;i++){str += i;}
long num2 = Runtime.getRuntime().freeMemory();
long time2 = System.currentTimeMillis();
System.out.println("String 占用内存：" + (num1 - num2));
System.out.println("String 占用工夫：" + (time2 - time1));
System.out.println("===================================");
StringBuilder sb = new StringBuilder("");
long num3 = Runtime.getRuntime().freeMemory();
long time3 = System.currentTimeMillis();
for(int i = 0;i < 5000;i++){sb.append(i);
}
long num4 = Runtime.getRuntime().freeMemory();
long time4 = System.currentTimeMillis();
System.out.println("StringBuilder 占用内存：" + (num3 - num4));
System.out.println("StringBuilder 占用工夫：" + (time4 - time3));
System.out.println("===================================");
StringBuffer sb2 = new StringBuffer("");
long num5 = Runtime.getRuntime().freeMemory();
long time5 = System.currentTimeMillis();
for(int i = 0;i < 5000;i++){sb2.append(i);
}
long num6 = Runtime.getRuntime().freeMemory();
long time6 = System.currentTimeMillis();
System.out.println("StringBuffer 占用内存；" + (num5 - num6));
System.out.println("StringBuffer 占用工夫：" + (time6 - time5));
}
}效率测试后果如下：
File 类
java.io.File 类：代表文件和目录。
枚举
枚举类型隐形地继承自 java.lang.Enum。枚举本质上还是类，而每个被枚举的成员本质就是一个枚举类型的实例。他们默认都是 public static final 润饰的。能够间接通过枚举类型名应用。
enum 枚举名 {枚举体（常量列表）}- 特地留神：
汇合（容器）
泛型
泛型简介
泛型是将类型基于一个占位符模式来定义，在泛型中，不能够应用根本类型，只能用对象类型来定义泛型。
- 泛型的益处：
总结一下：
- 类型擦除
编译时采纳泛型写的类型参数，编译器会在编译时去掉。
泛型的应用
- 定义泛型
- 泛型类
泛型类是把泛型定义在类上。
- 泛型接口
泛型接口和泛型类的申明形式统一。泛型接口的具体类型须要在实现类中进行申明。
- 泛型办法
泛型办法是指将办法的参数类型定义成泛型，以便在调用时承受不同类型的参数。类型参数能够有多个，用逗号隔开，如：<K,V>。类型参数个别放到返回值后面。
+ 非静态方法
+ 静态方法静态方法无法访问类上定义的泛型；如果静态方法操作的援用数据类型不确定的时候，必须要将泛型定义在办法上。
- 泛型办法与可变参数
在泛型办法中，泛型也能够定义可变参数类型。
-
通配符和高低限定
- 无界通配符
+ 通配符的下限限定下限限定示意通配符的类型是 T 类以及 T 类的子类或者 T 接口以及 T 接口的子接口。
+ 通配符的上限限定上限限定示意通配符的类型是 T 类以及 T 类的父类或者 T 接口以及 T 接口的父接口。该办法不实用泛型类。
- 泛型总结
容器
数组也是一种容器，能够搁置对象或根本类型数据
- 数组的劣势：是一种简略的线性序列，能够疾速地拜访数组元素，效率高。仅从效率和类型查看的角度讲，数组是最好的。
- 数组的劣势：不灵便。容量须要当时定义好，不能随着需要的辩护而扩容。
总之，容器的底层都是基于数组来实现的。容器中数据都是存储在内存的。
List
List：有序（元素存入汇合的程序和取出的程序统一）、可反复
- ArrayList 是 List 接口的实现类。是 List 存储特色的具体实现。
- ArrayList 底层是用数组实现的存储。特点：查问效率高、增删效率低、线程不平安。
- ArrayList：提早扩容，如要扩容以 1.5 倍扩容。
Vector
Vector：底层应用数组实现的。线程平安，效率低。Vector 的应用与 ArrayList 是雷同的。初始容量是 10，如要扩容以 2 倍扩容。
Stack
Stack：栈容器，是 Vector 的一个子类，它实现了一个规范的后进先出（LIFO：Last In First Out）的栈。
- 栈的操作
// 栈容器应用案例
public class StackTest {public static void main(String[] args) {StackTest st = new StackTest();
st.symmetry();}
// 匹配符号的对称性
public void symmetry(){String str = "...{.....[....(....)....]....}..(....)..[...]...";
// 实例化 Stack
Stack<String> stack = new Stack<>();
// 假如修改法
boolean flag = true; // 假如是匹配的
// 拆分字符串获取字符
for(int i = 0;i < str.length();i++){char c = str.charAt(i);
if(c == '{'){stack.push("}");
}
if(c == '['){stack.push("]");
}
if(c == '('){stack.push(")");
}
// 判断符号是否匹配
if(c == '}'||c == ']'||c == ')'){if(stack.empty()){
flag = false;
break;
}
String x = stack.pop();
if(x.charAt(0) != c){
flag = false;
break;
}
}
}
if(!stack.empty()){flag = false;}
System.out.println(flag);
}
}LinkedList
- 底层用双向链表实现的存储。特点：查问效率低，增删效率高，线程不平安。
- 实现了 List 接口，所以 LinkedList 是具备 List 的存储特色的（有序，元素有反复）
Set
Set 特点：无序，不可反复。无序指 Set 中的元素没有索引，只能遍历查找；不可反复指不容许退出反复的元素。
HashSet
- HashSet：是一个没有反复元素的汇合，不保障元素的程序，线程不平安。容许有 null 元素；采纳哈希算法实现，底层是用 HashMap 实现的，HashMap 底层应用的是数组与链表实现元素的存储。查问效率和增删效率比拟高。Hash 算法也称之为散列算法。
无序：
不反复：
TreeSet
- 通过元素本身实现比拟规定
- 通过比拟器指定比拟规定
Map
Map 接口定义了双例汇合的存储特色，它不是 Collection 接口的子接口。双例汇合的存储特色是以 key 与 value 构造为单位进行存储的。
- Map 与 Collection 的区别
HashMap
- HashMap 的底层源码
TreeMap
Iterator 迭代器
- Iterator 对象的工作原理
Collections 工具类
数据结构
数据结构是以某种特定的布局形式存储数据（存储构造上差别）的容器。
- 数据结构逻辑分类
- 线性构造：元素存在一对一的互相关系
线性表、栈、队列、串（一堆数组）等
- 树形构造：元素存在一对多的互相关系
二叉树、红黑树、B 树、哈夫曼树等
- 图形构造：元素存在多对多的互相关系
有向图、无向图、简略图等
线性构造
栈构造
栈是一种只能从一端存取数据且遵循 ” 后进先出（LIFO）” 准则的线性存储构造
链表构造
链表构造是由许多节点形成的，每个节点都蕴含两局部：
- 链表分类
单向链表
双向链表
双向循环链表
- 链表的特点
- 链表的优缺点
单向链表构造
双向链表构造
树形构造
- 节点
应用树结构存储的每一个数据元素都被称为“结点”。
- 节点的度
某个结点所领有的子树的个数
- 树的深度
树中节点的做大档次数
- 叶子结点
度为 0 的结点，也叫终端结点。
- 分支结点
度不为 0 的结点，也叫非终端结点或外部结点。
- 孩子
也可称之为子树或者子结点，示意以后节点上层的间接结点。
- 双亲
也可称之为父结点，示意以后结点的间接下层结点。
- 根节点
没有双亲结点的结点。在一个树形构造中只有一个根节点。
- 先人
从以后结点下层的所有结点。
- 子孙
以后结点上层的所有结点。
- 兄弟
同一双亲的孩子。
二叉树
满二叉树
齐全二叉树
二叉树遍历
正则表达式
Java 中正则表达式为 String 类型，被验证的内容同样为 String 类型。通过 String 类中的 matches 办法实现内容的匹配校验。如：”被验证内容“.matches(“ 正则表达式 ”)
在定义限定内容规定是，如果没有指定长度限定，那么默认长度为 1。
内容限定
- 单个字符限定
[a]：示意以后内容必须是字母 a
- 范畴字符限定
[a-z0-9]：示意内容能够是 a - z 之间的任意字母或者 0 - 9 之间的任意数字，不分先后
- 取反限定
[^abc]：示意内容不能是 a 或 b 或 c。
长度限定
长度限定符号
预约义字符
在正则表达式中能够通过一些预约义字符来示意内容限定。目标是为了简化内容限定的定义
组合定义
通过多个内容限定与长度限定来组合定义
常见的正则表达式
|：或者，如：a|b (a 或 b)
\\.：任意字符，如：-|\\. (- 或任意一个字符)
IO 流
- 数据源：提供数据的原始媒介。常见的数据源有：数据库、文件、其余程序、内存、网络连接、IO 设施。
- 流：形象、动静的概念，是一连串间断动静的数据汇合。
输出流：数据流从数据源到程序（InputStream、Reader 结尾的流）
输入流：数据流从程序到目的地（OutputStream、Writer 结尾的流）
- JAVA 中四大 IO 抽象类
InputStream/OutputStream 和 Reader/Writer 类是所有 IO 类的形象父类
InputStream: 字节输出流
OutputStream: 字节输入流
Reader: 读取的字符流抽象类，数据单位为字符
Writer: 输入的字符流抽象类，数据单位为字符
- Java 中流的细分
按流的方向分类：
输出流：InputStream、Reader 结尾的流
输入流：OutputStream、Writer 结尾的流按解决的数据单元分类：
字节流：以字节为单位获取数据，FileInputStream、FileOutputStream
字符流：以字符为单位获取数据，Reader/Writer 结尾的流，如 FIleReader、FileWriter按解决对象不同分类
节点流：间接从数据源或目的地读写数据，如：FileInputStream、FileReader、DataInputStream
解决流：也叫包装流，不间接连贯到数据源或目的地，是”解决流的流“。通过对其余流的解决进步程序的性能，如：BufferedInputStream、BufferedReader。
- 通过字节缓冲流进步读写效率
总结：
- File 类
File 类是 Java 提供的针对磁盘中的文件或目录转换对象的包装类。一个 File 对象能够代表一个文件或目录。
文件字节流
通过缓冲区进步读写效率
形式一：
public class FileDemo {public static void main(String[] args) throws Exception{try(FileInputStream fis = new FileInputStream("images/s1.jpg");
FileOutputStream fos = new FileOutputStream("images/11.jpg");
){
// 创立一个缓冲区
byte[] buff = new byte[1024]; // 空间换效率, 效率低，但空间节俭。int len = 0;
while((len = fis.read(buff)) != -1){fos.write(buff,0,len);
}
fos.flush();}catch (Exception e){e.printStackTrace();
}
}
}形式二：
public class FileDemo {public static void main(String[] args) throws Exception{try(FileInputStream fis = new FileInputStream("images/s1.jpg");
FileOutputStream fos = new FileOutputStream("images/11.jpg");
){
// 创立一个缓冲区
byte[] buff = new byte[fis.available()]; // 效率换空间，占内存，但效率快
fis.read(buff);
fos.write(buff);
fos.flush();}catch (Exception e){e.printStackTrace();
}
}
}通过字节缓冲流进步读写效率
public class FileCopyTools {public static void main(String[] args) {copyFile("images/s1.jpg","images/11.jpg");
}
/**
* 文件拷贝办法
*/
public static void copyFile(String src,String des){try(BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(des));
){
int temp = 0;
while((temp = bis.read()) != -1){bos.write(temp);
}
bos.flush();} catch (Exception e){e.printStackTrace();
}
}
}文件字符流
- 如果一个一个字符读取，后果是 Unicode 字符，需将后果强转 char 才能看懂数据内容。
- 如果是字符输入流，创立了两个字符输入流并同时向同一个文件输入内容，默认是会笼罩。除非加参数 true, 能力追加。
字符缓冲流
字符输出缓冲流
字符输入缓冲流
转换流
InputStreamReader/OutputStreamWriter 用来实现将字节流转化成字符流。
字符输入流
- PrintWriter: 是节点流，能够间接作用于文件的。
字节数组流
字节数组输出流（ByteArrayInputStream）
- ByteArrayInputStream : 则是把内存的 ” 字节数组对象 ” 当做数据源。
- FileInputStream：是把文件当做数据源。
字节数组输入流（ByteArrayOutputStream）
- ByteArrayOutputStream：将流中的数据写入到字节数组中。
public class ByteArrayOutputStreamDemo {public static void main(String[] args) {
ByteArrayOutputStream bos = null;
StringBuilder sb = new StringBuilder();
try{bos = new ByteArrayOutputStream();
bos.write('a');
bos.write('b');
bos.write('c');
byte[] arr = bos.toByteArray();
for(int i = 0;i < arr.length;i++){sb.append((char)arr[i]);
}
System.out.println(sb.toString());
}finally{
try{if(bos != null){bos.close();
}
}catch (Exception e){e.printStackTrace();
}
}
}
}数据流
- DataInputStream 和 DataOutputStream 提供了能够存取与机器无关的所有 Java 根底类型数据（如：int、double、String 等）。
数据输入流
// 数据输入流
public class DataIOStreamDemo {public static void main(String[] args) {try(DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream("data.txt")));){dos.writeChar('a');
dos.writeInt(4);
dos.writeDouble(Math.random());
dos.writeUTF("您好");
dos.flush();}catch (Exception e){e.printStackTrace();
}
}
}数据输出流
读取的程序要与数据输入流写入的程序统一，否则不能读取数据
// 数据输出流
public class DataIOStreamDemo {public static void main(String[] args) {try(DataInputStream dis = new DataInputStream(new BufferedInputStream(new FileInputStream("data.txt")));){
// 间接读取数据，留神：读取的程序要与写入的程序统一，否则不能读取数据
System.out.println("char:" + dis.readChar());
System.out.println("int:" + dis.readInt());
System.out.println("double:" + dis.readDouble());
System.out.println("utf:" + dis.readUTF());
}catch (Exception e){e.printStackTrace();
}
}
}对象流
数据流只能实现对根本数据类型和字符串类型的读写，并不能 Java 对象进行读写操作（字符串除外），而对象流除了能实现对根本数据类型进行读写操作，还能对 Java 对象进行读写操作。
- 对象的序列化和反序列化
序列化
对象的序列化：把 java 对象转换为字节序列的过程。
- 对象序列化的作用
- 序列化波及的类和接口
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
// 对象输入流实现根本数据类型的输入
public class ObjectIOStreamDemo {public static void main(String[] args) {try(ObjectOutputStream oos = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream("data")));){oos.writeInt(10);
oos.writeDouble(Math.random());
oos.writeChar('a');
oos.writeBoolean(true);
}catch (Exception e){e.printStackTrace();
}
}
}- 将对象序列化到文件
反序列化
对象的反序列化：字节序列复原为 Java 对象的过程。
随机拜访流
- 外围办法
多线程
程序：
过程：
- 过程特点
线程：
- 线程和过程的区别
- 并发
- 办法的执行特点（）
- 线程的执行办法的特点
- 主线程
+ 主线程的特点它是产生其余子线程的线程。
它不肯定是最初实现执行的线程，子线程可能在它完结之后还在运行。
- 主线程
在主线程中创立并启动的线程，个别称之为子线程。
线程的创立
通过继承 Thread 类实现多线程
通过实现 Runnable 接口实现多线程
线程的执行流程
线程的生命周期
- 新生状态
- 就绪状态
- 运行状态
- 阻塞状态
- 死亡状态
线程的应用
终止线程
import java.io.IOException;
public class StopThread implements Runnable{
private boolean flag = true;
@Override
public void run() {System.out.println(Thread.currentThread().getName() + "线程开始");
int i = 0;
while(flag){System.out.println(Thread.currentThread().getName() + " " + i++);
try {Thread.sleep(1000);
} catch (InterruptedException e) {e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() + "线程完结");
}
// 劝本人他杀形式终止线程, 线程能失常完结。public void stop(){this.flag = false;}
public static void main(String[] args) throws IOException {System.out.println("主线程开始");
StopThread st = new StopThread();
Thread t1 = new Thread(st);
// 启动线程
t1.start();
System.in.read();
st.stop();
System.out.println("主线程完结");
}
}- 暂停以后线程执行 sleep/yield
+ yield 办法的应用
线程联结
- join 办法的应用
class A implements Runnable{
@Override
public void run() {for (int i = 0; i < 10; i++) {System.out.println(Thread.currentThread().getName() + " " + i);
try {Thread.sleep(1000);
} catch (InterruptedException e) {e.printStackTrace();
}
}
}
}
public class JoinThread {public static void main(String[] args) throws InterruptedException {Thread t = new Thread(new A());
// 启动 A 线程
t.start();
// 主线程
for (int i = 0; i < 10; i++) {System.out.println(Thread.currentThread().getName() + " " + i);
// 当 i = 2 时，主线程期待 A 线程完结之后再运行
if(i == 2){t.join();
}
Thread.sleep(1000);
}
}
}Thread 类罕用办法
- 获取以后线程名称
- 判断以后线程是否存活
线程优先级
守护线程
- 守护线程的特点：守护线程会随着用户线程死亡而死亡。
- 守护线程与用户线程的区别
线程同步（就是把并行改成串行）
synchronized 可阻止并发更新同一个共享资源，实现了同步，然而 synchronized 不能用来实现不同线程之间的消息传递（通信）。
实现线程同步
- synchronized 关键字应用时须要思考的问题：
> 
> 线程同步的应用
应用 this 作为线程对象锁
在不同线程中雷同对象中 synchronized 会互斥。
语法结构：
synchronized(this){// 同步代码}或
public synchronized void accessVal(int newVal){}应用字符串作为线程对象锁
所有线程在执行 synchronized 时都会同步。因字符串是不变序列，所以会持有雷同锁。
synchronized("字符串"){// 同步代码}应用 Class 作为线程对象锁
在不同线程中，领有雷同 Class 对象中的 synchronized 会互斥。
synchronized(XX.class){// 同步代码}或
synchronized public static void accessVal(){// 同步代码}
应用自定义对象作为线程对象锁
在不同线程中，领有雷同自定义对象中的 synchronized 会互斥。放在线程中造成互斥锁。
synchronized(自定义对象){// 同步代码}死锁及解决方案
死锁是因为同一代码块呈现嵌套 synchronized 造成的，解决办法是避免出现嵌套 synchronized 语句块。
线程并发合作（生产者 / 消费者模式）
-
角色：
生产者：负责生产数据的模块
消费者：负责解决数据的模块
缓冲区：消费者不能间接应用生产者数据，它们之间有个“缓冲区”。生产者将生产好的数据放入“缓冲区”，消费者从“缓冲区”拿要解决的数据。
缓冲区的益处： - wait() 办法：要在 synchronized 块中调用，该办法执行后，线程会将持有的对象锁开释，并进入阻塞状态，其余须要该对象锁的线程就能够持续运行了。
- notify() 办法：要在在 synchronized 块中调用，该办法执行后，会唤醒处于期待状态队列中的一个线程
/**
* 定义馒头类
*/
class ManTou{
private int id;
public ManTou(int id){this.id = id;}
public int getId(){return this.id;}
}
/**
* 定义缓冲类
*/
class SyncStack{
// 定义放馒头的盒子
private ManTou[] mt = new ManTou[10];
// 定义盒子的 suoyin
private int index;
/**
* 放馒头
*/
public synchronized void push(ManTou manTou){while(this.index == this.mt.length){
try {
// 该办法执行后，线程会将持有的对象锁开释，并进入阻塞状态，其余须要该对象锁的线程就能够持续运行了。this.wait();} catch (InterruptedException e) {e.printStackTrace();
}
}
this.notify(); // 该办法执行后，会唤醒处于期待状态队列中的一个线程
this.mt[this.index] = manTou;
this.index++;
}
/**
* 取馒头
*/
public synchronized ManTou pop(){while(this.index == 0){
try {
// 该办法执行后，线程会将持有的对象锁开释，并进入阻塞状态，其余须要该对象锁的线程就能够持续运行了。this.wait();} catch (InterruptedException e) {e.printStackTrace();
}
}
this.notify(); // 该办法执行后，会唤醒处于期待状态队列中的一个线程
this.index--;
return this.mt[this.index];
}
}
/**
* 定义生产者线程
*/
class Producer extends Thread{
private SyncStack ss;
public Producer(SyncStack ss){this.ss = ss;}
@Override
public void run() {for (int i = 0; i < 10; i++) {System.out.println("生产馒头：" + i);
ManTou manTou = new ManTou(i);
this.ss.push(manTou);
}
}
}
/**
* 定义消费者线程
*/
class Customer extends Thread{
private SyncStack ss;
public Customer(SyncStack ss){this.ss = ss;}
@Override
public void run() {for (int i = 0;i < 10;i++) {ManTou manTou = this.ss.pop();
System.out.println("生产馒头：" + i);
}
}
}
public class ProduceThread {public static void main(String[] args) {SyncStack ss = new SyncStack();
new Thread(new Producer(ss)).start();
new Thread(new Customer(ss)).start();}
}线程并发合作总结
- 线程通过哪些办法来进行消息传递，总结如下：
下列的办法均是 java.lang.Object 类的办法，都只能在同步办法或者同步代码块中应用，否则会抛出异样。
网络编程
网络通信协定
OSI 七层协定模型：别离是：应用层、表示层、会话层、传输层、网络层、数据链路层、物理层。
TCP/IP 协定
应用层、传输层、互联网络层、网络接口层（物理 + 数据链路层）
- 传输过程中，会波及到封装和解封
总结：发送数据必须同时指定 IP 地址和端口。
#### URL（Uniform Resource Locator）
在 www 上，每一信息资源都有对立且惟一的地址。URL 由四局部组成：协定、寄存资源的主机域名、被迫文件和端口号。
#### Socket
#### TCP 和 UDP 协定
TCP 协定
UDP 协定
网络编程中罕用类
- InetAddress 类：封装计算机的 IP 地址和域名。没有构造方法，如果要失去对象，只能通过 getLocalHost()、getByName()等静态方法创建对象。
- InetSocketAddress 类：蕴含 IP 和端口信息，罕用于 Socket 通信。此类实现 IP 套接字地址（IP 地址 + 端口号）, 不依赖任何协定。相比于 InetAddress 多了端口号。
- URL 类：标识了计算机的资源，它是指向互联网“资源”的指针。（IP 地址标识了 Internet 上惟一的计算机）
TCP 通信实现
- 申请 - 响应 模式
Socket 类：发送 TCP 音讯
ServerSocket 类：创立服务器
- Socket 的编程程序
UDP 通信实现
- DatagramPacket：数据容器（封包）的作用
示意数据报包。数据报包用来实现将发送的数据进行封包解决的。
