JAVAse

sudo bash -c “$(wget -qO- https://raw.githubusercontent.com/Jigsaw-Code/outline-server/master/src/server_manager/install_scripts/install_server.sh)”
先得不得几句吧，先说说学Java的初衷。是因为学校教了c，c++，Java。c和c++我是听不进去阿，而Java倒是还可以有，一点兴趣吧。后来为了应付java期末考试真正系统学习了javase。我特别喜欢周杰伦嘛，他的《头文字d》我看了四五遍，里面女主很好看（但是是坏女人伤害了拓海）她有一句话说人嘛，最重要知道自己想干什么。那时候我还不知道自己想干什么，所以觉得搞java还可以。当时班级搞前端很多嘛，我就想弄后端因为这样小组作业不会犯愁嘛哈哈。后来过了半年快大三了，感觉应该努力了，准备找工作了。就又捡起来这位hxd了，大学过的还蛮快的，我也是个普通人，但也想不普通嘛哈哈。现在正好在听杰伦的蜗牛：我要一步一步往上爬。希望你
的青春不说无怨无悔吧，就祝你不迷茫好了。

方法使用：

调用方法：单独调用；

（1)方法（）;

（2）打印调用：(2)System.out.println(方法名称（参数）)；
（3）赋值调用：(3)将结果赋值给一个变量，对变量进行操作
带着返回值返回方法的调用处
参数：工厂原料
返回值：产品

方法的注意事项：

void关键字不传返回值，什么也不返回
对于有返回值的方法，三种调用方法都可以
无返回值只能使用单独调用
方法定义在类中，顺序无所谓，希望执行的话一定要调用，方法有返回值必须return，返回值数据必须和返回值类型一致，无返回值return；
可以有多个return语句，但必须有一个会被执行到
方法重载，方法名称一样，参数列表不一样（参数个数，类型，多类型顺序不同可以重载，
方法重载与下列因素无关：
1.与参数的名称无关，值对应参数不一样，不可以重载
2.与方法的返回值类型无关，不可以重载

Switch结构：

Switch基本使用及注意事项：

switch(表达式){
语句体1;
break;
default:
语句体n+1；
break；//所有case都不匹配
}
1.多个case后面的数据不可以重复
2.switch后面小括号只能是下列数据类型基本数据类型和引用数据类型
3.case顺序可以颠倒，匹配哪一个case向下执行直到遇到break或default

数组：

定义及注意事项：

int arr[]={1,2,3}；
int arr[]=new int[3];
arr[1]=123;
数组作为返回值类型public static int[] method(){}，返回的也是数组的地址值

java内核：

java的内存分为5部分

栈：存放的是方法中的局部变量，方法的运行一定要在栈中运行，一旦超出作用域，立即从栈内存中消失
堆：凡是new出来的东西，都在堆中
方法区：存放.class信息，包含方法的信息
本地方法栈：与操作系统有关
寄存器：与CPU有关

类的描述及使用：

类对事物的模拟
对象是对类的具体实现
成员方法不带static
成员变量在方法外部，局部变量在方法内部
局部变量没有默认值，如果要想是用必须手动进行赋值
成员变量没有赋值，会自动生成默认值
局部变量位于栈内存
成员变量位于堆内存
getter方法中boolean类型用is
构造方法不写返回值类型，不return一个具体的返回值
不写赠送构造方法，一旦写之后赠送构造方法
匿名对象 new Person（）.name="";

List及其子类注意事项及使用：

List集合子类特点：List集合常用子类
ArrayList子类，底层数据结构是数组，查询快，增删慢,集合的长度是可以变化的ArrayList list = new ArrayList<>();直接打印的不是地址值而是内容 add操作/remove删除操作一定成功 不需要返回值 无法直接存储整数，可以使用包装类
LinkedList，底层数据结构是链表，查询慢，增删快
Vector类主要用在事先不知道数组的大小，或者只需要一个可以改变大小的数据的情况

字符串的注意事项及使用：

字符串的内容不可变，字符串可以共享使用，字符串效果上相当于char【】字符书组，低层原理是byte【】字节数组

创建字符串构造方法

public String（）；
public String(char[] array)根据字符数组的内容，来创建对应的字符串
public String (byte[] array)根据字节数组的内容，来创建对应的字符串
String str=""

注意：

没有new就是字符串对象

继承及注意事项：

父子类的继承关系中，如果成员变量重名，创建子类对象时，访问有两种方式：
直接通过子类对象访问成员变量，=左边是谁优先用谁，没有向上找
调用本类的成员变量用this，调用父类的成员变量用super

继承中的方法的注意事项：

重写override名称一样，参数列表也一样
重载overload，方法的名称一样，参数列表不一样
覆盖重写的要求，方法的名称一样，参数列表也一样
子类方法的范围必须小于等于父类方法返回值的范围
子类方法的全新必须大于等于父类方法的权限修饰符

super关键字的用法：

在子类的成员方法中访问父类的成员变量
在子类的成员方法访问父类的成员方法
在子类的构造方法中，访问父类的构造方法

接口及抽象方法的使用：

抽象方法：(public abstract) void 方法名（）;
接口的实现类必须覆盖重写（实现）接口中所有的抽象方法
实现：去掉abstract关键字，加上方法体大括号
0创建实现类的对象，进行使用

接口中的默认方法，可以解决接口的升级问题
在接口中添加新的方法时使用默认方法：(public) default void method01(参数列表){方法体}

不能使用接口实现类的对象调用接口的静态方法，用接口直接调用接口的静态方法

从java9开始，接口中允许定义私有方法
1.普通私有方法，解决多个静态方法之间重复代码问题
格式：private static 返回值类型 方法名称(参数列表){方法体}
2.静态私有方法，解决多个静态方法之间的重复代码问题
private static 返回值类型 方法名称(参数列表){方法体}

接口中成员变量（常量）的定义方法：
（public static final） 数据类型 常量名称=数据值

接口中的注意事项：

接口中没有静态代码块或构造方法
一个类的直接父类是唯一的，但一个类实现多个接口
如果多个接口中有重复的抽象方法，只需重写一次
没有覆盖重写所有接口中的所有抽象方法，那么实现类必须是一个抽象类
如果类所实现的多个接口中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写

多态注意事项及使用：

多态：父类引用指向子类对象 弊端：无法调用子类的属性和方法
格式：父类名称 对象名 = new 子类名称（）;接口名称 对象名 = new 实现类名称();
访问成员变量的两种方式：
直接通过对象名称访问成员变量：看等号左边是谁，优先用谁，没有则向上找
间接通过成员方法访问成员变量：看该方法属于谁，优先用谁，没有则想上找
成员方法：编译看左边，运行看右边，
成员变量：编译看左边，运行还看左边
对象的向上转型，右侧创建一个子类对象，把他当作父类看待，向上转型一定是安全的，转型为父类后，无法调用子类原本持有的内容
对象的向下转型：子类名称 对象名=（子类名称）父类对象 使用instanceof关键字前面的对象能不能当作后面类型的实例

final关键字的使用：

final关键字表示最终的，不可改变的
final可以修饰一个类：不能有任何的子类，其中所有成员方法不能进行覆盖重写
修饰一个方法：此方法为最终方法不可以覆盖重写
修饰一个局部变量：一旦修饰一个局部变量，那么这个变量就不能修改 基本类型数值不可变，引用类型地址值不可变
还可以修饰一个成员变量：用了final关键字后必须手动赋值，不再给默认值了，要么使用直接赋值，要么采用构造方法赋值二选一。

权限修饰符的比较：

权限修饰符：public>protected>default(根本不写)>private
同一个类： Y Y Y Y
同一个包： Y Y Y N
不同包子类 ：Y Y N N
不同包非子类：Y N N N

内部类的分类及使用：

内部类：常规分为成员内部类，局部内部类（包含匿名内部类）
成员内部类：
定义格式：修饰符 class外部类名称{修饰符 class 内部类名称{}}
内用外随意访问，外用内需要借助内用类的对象
调用方法:外部类.内部类 对象名 = new 外部类（）.new 内部类（）；
局部内部类：
如果一个类定义在一个方法内部的，那么这就是一个局部内部类。只有当前所属的方法才能使用它，除了这个方法外面就不能用了
定义格式：修饰符 返回值类型 方法名（）{class 内部类名称{}}
访问方法的局部变量的话，局部变量必须是有效final的

匿名内部类：
如果接口的实现类只需使用唯一的一次，那么这种情况下就可以省略该类的定义，而改为使用匿名内部类
定义格式：接口名称 对象名=new 接口名称（）{覆盖重写所有的抽象方法};
注意事项：匿名内部类，在创建对象使用时，只可以使用一次

直接打印对象，相当于调用ToString方法打印对象的地址值
equals方法public boolean equals(Object obj){return this==obj} this时对象调用的方法，方法中的this就是那个对象。p1调用的equals方法，所以this就是p1,
obj时传递过来的参数p2

StringBuilder：字符串缓冲区，可有改变长度在内存中始终时一个数组会自动扩容
append方法往对象中添加数据
append返回地址值
toString方法变成String类型

包装类的使用及注意事项：

包装类：把基本数据类型装起来，在类中添加方法 int= Integer char =Character
自动装箱 Integer i =1;
自动拆箱：i=i+2

特别注意：

基本类型-》字符串 Integer.toString
字符串-》基本类型
Integer.parseInt

list接口：有序的集合，允许存储重复的元素，有索引可以使用for循环遍历
set接口：不允许存储重复元素，没有索引
colletion 所有单列集合都可以使用共性的方法没有带索引的方法

迭代器的使用步骤

使用集合中的iterator方法获取迭代类的实现对象，利用Iterator接口接收
利用Iterator接口中的方法hasnext()判断还有没有下一个元素
利用Iterator接口中的方法next()取出迭代器中的元素

增强for循环for（元素的数据类型 变量：collectio集合或数组）

泛型的基本介绍

（未知的数据类型，当我们不知道使用什么数据类型的时候就可以使用泛型，泛型也可以是一个变量用来接收数据类型）：可变参数：

泛型的优缺点

使用泛型的好处：避免了类型转换的麻烦，存储的是什么类型，取出的就是什么类型
2.把运行期异常（代码运行后抛出的异常）提到了编译期
弊端：泛型是什么类型，只能存储什么类型

泛型的使用方法

定义含有泛型的类
格式：修饰符<泛型> 返回值类型 方法名（参数列表（泛型名））{ }
接口使用什么泛型，实现类就使用什么泛型，类跟着接口走

数据结构的基本介绍：

栈：先进后出，像开枪一样
队列：先进先出
数组：（查询快。增删慢）要删除一个元素要创建一个新的数组，数组长度为原数组长度减一，剩下的元素进行复制。
链表：（查询慢，增删快）自己的地址 数据 下一个节点的地址删除时只需要把下一个节点的地址换成别的节点即可
二叉树：分支不能超过两个
平衡树：左分支和右分支相等
红黑树：趋近于平衡树，查询的速度非常快，查询叶子子节点最大次数和最小次数不能超过二倍（根节点，叶子节点（空节点）都是黑色的）
当链表长度超过了8位为了提升查找速度，就会把链表转换成红黑树

List接口的特点：

1.有序的集合，存储元素的顺序和取出元素的顺序是一致的
2.有索引包含了一些带索引的方法(特有方法：add将元素添加到指定位置上 get remove返回的是被移除的元素 set用指定元素返回集合中指定的元素，返回值为更新前的元素)
3.允许存储重复的元素

Colletcion集合包括：List集合和Set集合

ArrayList集合底层是数组结构
LinkedList是链表结构不能使用多态

哈希集合

哈希值是一个十进制的整数，由系统随机给出对象的地址值，不是数据实际存储的物理地址
哈希表是（数组+链表/红黑树）
Set集合不允许重复元素的原理，在调用add方法的时，会调用元素的hascode方法和equals方法，如果存在哈希值相同的元素，则不存入
LinkedHashSet（有序的，不允许重复链表：多了一条链表（记录元素的存储顺序），保证元素有序） extends HashSet（无序的不允许重复）

Map集合：键值对集合key不允许重复的，值是可以重复的，一对一的

HashMap集合的特点：底层是哈希表：查询速度比较快
2.HashMap集合是一个无序的集合，存储元素和取出元素的顺序有可能不一致
当两个键值对键相同的时候，输出的值是被替换的，输出HashMap的时候是相同键=替换的值
LinkedHashMap:集合底层是哈希表+链表（保证迭代的顺序）
LinkedHashMap集合是一个有序的集合，存储元素和取出元素的顺序是一致的

Map集合遍历方式：

方法一：通过键找值的方式，步骤：使用map集合中的keySet方法，把key都取出来存储到一个set集合中
2.遍历set集合，获取集合中的每一个key
通过集合中的方法get（key），通过key找到value
方法二：Entry对象负责存储键值对

可变参数：

底层为数组，根据传递参数不同，会创建不同长度的数组，来存储这些参数
当参数列表数据类型已经确定，但参数的个数不确定，就可以使用可变参数

可变参数的使用：

格式 修饰符 返回值类型 方法名（数据类型…变量名）{}

异常处理

trycatch的使用

try {可能会出现异常代码}catch{异常的处理逻辑}编译期间异常Error犯了根本错误，需要改正，所以要修改源代码

JVM接收到了异常对象会做两件事

1.把异常对象（内容，原因，位置）以红色的字体打印在控制台
2.jvm会终止当前正在执行的java程序->中断处理

throw关键字：

可以使用throw关键字，在指定方法中抛出指定的异常
throw new xxxException(“产生异常的原因”)
1.throw关键字必须写在方法的内部
2.throw关键字后面new的对象必须是Exception或者Exception子类对象
3.throw关键字后面抛出指定的异常对象，我们就必须处理这个异常对象
throw关键字后面的是RunTimeException或者是RunTimeException子类对象我们可以不处理，默认交给jvm处理（打印异常对象，中断程序）
如果是编译异常要么throws要么trycatch
NullPointerException是一个运行期异常，交给JVM处理
数组越界，告诉方法的调用者“传递的索引超出了数组的使用范围”
public staticT requireNonNull(T obj) 查看指定对象不是null

throws异常处理的方式：

throws异常处理的第一种方式，交给别人处理

把异常对象声明抛出给方法的调用者处理（自己不处理，给别人处理）最终交给jvm
使用格式：修饰符 返回值类型 方法名（番薯列表）throws{
throw new AAAException
}
1.必须写在方法声明
2.后面声明的异常必须是Exception或是Exception的子类
3.方法内部如果出现多个异常对象，那么throws后面也必须声明多个异常
如果抛出的多个异常对象有子父类关系，直接声明父类异常即可
4.调用了一个声明异常的方法，我们就必须要处理声明的异常，要么继续使用throws声明抛出，交给方法的调用者处理，最终交给jvm

要么try catch自己处理

try{可能会出错的语句}catch（异常类 定义一个变量用来接收try抛出的异常对象）{
后续处理异常的方式，在一般工作中会把异常的信息记录在一个日志中} }
finally一般不能单独使用，必须与try一起使用，一般用于资源释放，无论程序是否出现异常，最好要进行释放，finally必须执行

异常的注意事项：

一次捕获多次处理，catch定义的异常变量如果有子父关系，子类的异常变量必须写在上边
父类异常是什么样，子类异常就是什么样

线程的并发：

并发：一个cpu交替执行多个任务
并行：多个cpu同时执行多个任务
进程：进入内存中的程序叫进程
线程：应用程序功能打开后，就会开启应用程序到cpu的执行路径，这条执行路径叫线程

多线程的好处：

1.效率高2.线程之间互不影响

线程调度：

平均调度和抢占式调度（根据优先级选择线程实现顺序）java属于抢占式调度

多线程实现方法1：

创建一个Thread子类2.重写run方法3.创建Thread的子类对象4.主方法调用Thread的Start方法 子类调用run方法

多线程实现方法2：

实现Runnable方法
1.创建一个runnable接口的实现类
2.在实现类中重写Runnable接口的run方法设置线程任务
3.创建一个Runnable接口的实现类对象
4.创建Thread类对象，构造方法中传递Runnable接口的实现类对象
5.调用Thread类中的start方法，开启新的线程执行run方法多线程运行原理：main方法执行后获得main线程，但在main方法中子类对象

实现Runnable接口创建多线程程序的好处

1.避免了单继承的局限性
2.增强了程序的扩展性，降低了程序的耦合性调用start方法后重写的run方法也开始执行所以又开启一个线程
Thread sleep方法

匿名内部类实现线程的创建：

匿名内部类实现Thread的方法

线程安全的解决方法：1.同步代码块 2.同步方法 3.锁机制

1.同步代码块：

Synchronized(同步锁){需要同步的代码}

2.同步方法原理：

使用了一个锁对象（同步锁，对象所，对象监视器）线程一获取锁之后遇到synchronized代码块，查看代码块中是否有锁对象，有锁就用它，线程2好不容易拿到cpu执行权但是没有锁对象给他使用，就会等待t0将锁对象归还。才能获得锁对象进入同步中执行
步骤，定义一个同步方法，将多线程代码放进去，再执行方法 会把方法内部的代码锁住

3.使用lock：

1.在成员位置创建一个Reemtrantlock对象
2.在可能会出现安全问题的代码前调用lock接口中的方法lock获取锁
3.在可能出现安全问题的代码后调用lock接口中的方法unlock释放锁

线程通信：

资源类：设置属性
生产者：是一个线程类可以继承Thread
对包子的状态进行判断
true：有包子 包子铺调用wait方法进入等待状态
false：没有包子
包子铺生产好了包子修改包子的状态为有（true）
唤醒吃货线程，让吃货线程吃包子
消费者（吃货）是一个线程类
设置线程任务（run）吃包子
对包子的状态进行判断
false没有包子
吃货线程调用wait方法进入等待状态
true：有包子
吃货吃包子
吃货吃完包子
修改包子的状态为没有（false）
吃货唤醒包子铺线程，生产包子
测试类：包含main方法，启动程序
创建包子对象：创建包子铺线程。开启创建吃货线程开启

线程的状态

线程状态：New（新建）新建状态
Runnable（可运行）正在java虚拟机中执行的线程
Blocked（锁阻塞）：受阻塞并等待某一个监视器锁的线程
waiting(无线等待) 无限期的等待另一个线程来执行某一特定操作的线程处于这种状态
TimedWaiting（计时等待）：等待另一个线程来执行取决于指定等待时间的操作的线程处于这种状态
TermInated(死亡状态)：已推出的线程

线程池：

java.util.concurrent.Executors:线程池1的工厂类，用来生成线程池
Executors类中的静态方法：
static ExecutorService newFixedThreadPool(int nThreads)创建一个可重用固定线程数的线程池
参数int nThreads：创建线程池中包含的线程数量
返回值：ExecutorService接口，返回的是ExecutorService接口的实现类对象，我们可以使用ExecutorService接口接收
java.util.concurrent.ExecytirService：线程池接口
从线程池中获取线程，调用start方法，执行线程任务
submit（Runnable task）提交一个Runnable任务用于执行
关闭/销毁线程池的方法
void shutdown();

文件的创建和删除

创建文件 public boolean createnewFile();//路径必须存在，只能创建文件
创建目录 public boolean mkdir();//既可以创建单级文件夹又可以创建多级文件夹
创建多级目录 public boolean mkdirs();
删除构造方法中路径给出的文件和文件夹public boolean delete(),不走回收站
绝对路径：盘符开头完整的路径名，不需要其他任何信息可以定位他所表示的文件
相对路径：相对是指相对于其他项目的根目录
删除目录要先删除目录中的文件

递归

递归要找到条件限定：否则会出现栈内存溢出
递归找到规则：与原问题相似的规模较小的问题

IO流

内存：临时存储
input输入
output删除
OutputStream字节输出流这个抽象类（无法直接使用）表示字节输出流的所有类的超类
FileOutputStream文件字节输出流的构造方法
FileOutputStream（String name）:创建文件输出流以指定的名称写入文件
FileOutputStream(File file) 创建一个向具有指定名称恶的文件中写入数据的输出文件流

编译器->JVM虚拟机->操作系统->文件目录

字节流

字节流写数据步骤：

1.创建FileOutputstream对象（调用系统功能创建了文件，创建字节输出流对象，让字节输出流对象指向文件）
2.调用字节输出流对象的写数据方法write写入到文件中数值为0-127是ASILL值
3.释放资源（关闭此文件输出流并释放与此流相关联的任何系统资源，使用完毕后把内存清空，提高程序的效率）

一次写多字节方法：

第一个字节是正数，显示的时候是查询ascii表
写的第一个字节是负数，那第一个字节和第二个字节形成一个中文显示，查询系统默认码表
fos.write（字节数组，起始点和长度属性）

追加使用两个参数的构造方法

FileOutputStream(String name, boolean append)创建一个具有指定name的文件中写入数据的输出文件流
FileOutputStream(File file, boolean append)创建一个向指定file对象表示的文件中写入数据的文件输出流
true：不会覆盖源文件，继续在文件的末尾书写
false：创建一个新文件，覆盖源文件
字符缓冲输出流bw.newline（）；换行输出
public String readline（）;读一行文字只读内容不读换行符号

InputStream字节输入流这个抽象类时表示字节输入流的所有类的超类
FileInputStream(String name)
FileInputStream(File file)

字节输入流读取数据

FileInputStream 共性的成员方法

int read（）从输入流中读取数据的下一个字节

in（byte[]b）从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中

void close（）释放资源

步骤：
1.创建FileInputStream对象，构造方法中要绑定要读取的数据源
2.使用FileFInputStream对象中的方法read，读取文件
3.释放资源
int length=0;
while(length=fis.read()!=0){}
字节输入流一次读取多个字节的方法
int read(byte[] b)从输入流中读取一定数量的字节，并储存在数组b中
1.方法的参数byte[]的作用是什么
2.方法的返回值int是什么

字符流

字符输入流

java.io.Reader 抽象类是表示用于读取字符类所有类的超类，可以读取字符信息到内存中。他定义了字符输入流的基本共性功能方法

方法

public void close():关闭此流并释放与此流相关联的任何系统资源

public int read() 从输入流读取一个字符

public int read (char[] cbuf):从输入流中读取一些字符，并将他们存储在字符数组中

使用步骤：

创建FileReader对象，构造方法中要绑定要读取的数据源

2.使用FileReader对象中的方法read读取文件

3.释放资源

字符输出流

java.io.Reader 抽象类是表示用于写数据字符类所有类的超类

共性的成员方法：

void write(int c)写入单个字符

void write（char[] cbuf）写入字符数组

abstract void write（char[] cbuf,int off,int len）写入字符数组的一部分，off为开始索引，len为写的字符个数

void write(String str) 写入字符串

void write（String str ，int off ，int len）写入字符串的莫一部分，off为字符串的开始索引，len为写的字符个数

void flush刷新该流的缓冲

void close（）关闭此流，但要先刷新

使用步骤

1.创建FileWriter对象，构造方法中绑定要写入数据的目的地

2.创建FileWriter中的write，把数据写入到内存缓冲区中（字符转换为字节的过程）

3.使用FileWriter的方法flush，把字符缓冲区中的数据刷新到文件中

4.释放资源

flush和close区别

flush刷新缓冲区，流对象可以继续使用

close 先刷新缓冲区，然后通知系统释放资源，流对象不可以再被使用了

续写和换行

FileWriter（String fileName，boolean append）

FileWriter(File file,boolean append)

IO异常的处理

trycatch处理

JDK7的新特性：

在try的后边增加一个（），在括号内定义流对象

那么流对象的作用域在try中有效

try中的代码执行完毕，会自动把流对象释放，不再写finally

JDK9的新特性

try的前边可以定义一个流对象

在try后的（）中可以直接引入流对象的名称

在try代码执行完毕后，流对象也可以释放掉，不再写finally

A a=new A（）；

B b=new B();

try(a ,b){可能会出现异常的代码}

属性集

Properties集合 extends HashTable<k,v> implements Map<k,v>

properties集合是一个唯一和Io流相结合的集合

可以使用集合中的方法store，把集合中的临时数据，持久化写入到硬盘中存储

void store(OutputStream out,String comments) OutputStream:字节输出流，不能写入中文

Writer writer：字符输出流，可以写中文

String moments：注释：用来解释说明保存的文件是干什么用的

​ 不能使用中文，会产生乱码，默认是unicode编码，一般使用空字符串

store方法

使用步骤：

1.创建Properties集合对象添加数据

2.创建字节输出流/字符输出流对象，构造方法中绑定要输出的目的地

3.使用Properties集合中的方法store，把集合中的临时数据，持久化写入到硬盘中存储

4.释放资源

void store(Writer writer String comments)

load方法

可以使用集合中的方法load，把硬盘中保存的文件，读取到集合中使用

void load(InputStream inputStream)

void load(Reader reader)

InputStream 字节输入流，不能读取含有中文的键值对

Reader 字符输入流，可以读取含有中文的键值对

使用Properities集合存储数据，遍历取出Properties集合中的数据

使用步骤：

1.创建Properties集合对象

2.使用Properties集合对象中的方法load读取保存键值对的文件

3.遍历Properties集合

Properities集合是一个双列集合，key和value默认都是字符串

集合中一些操作字符串的特有方法

Object setProperty（String key，String value）调用Hashtable的方法put

String getproperty（String key）通过key找到value值，此方法相当于map集合中的get（key）方法

set stringPropertyNames()返回此属性列表中的键集，其中该键及其对应值是字符串，相当于map集合中的keyset方法

缓冲流

增强基本字节输入输出流，增强基本字符输入输出流。他们效率比较低

增加一个缓冲区（数组）提高基本的字节输入流的读取效率，一次处理多个

字节缓冲输出流

BufferOutputStream extends OutputStream

共性的成员方法：

abstract void write（char[] cbuf,int off,int len）写入字符数组的一部分，off为开始索引，len为写的字符个数

void write(String str) 写入字符串

void write（String str ，int off ，int len）写入字符串的莫一部分，off为字符串的开始索引，len为写的字符个数

void flush刷新该流的缓冲

void close（）关闭此流，但要先刷新

构造方法

BufferedOutputStream(OuteputStream out) 创建一个新的缓冲输出流，将数据写入指定的底层输出流

BufferedOutputStream(OutputStream out,int size)创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入底层输出流

OutputStream out:字节输出流

int size 指定缓冲流内部缓冲区的大小

使用步骤：

1.创建一个OutputStream对象，构造方法中绑定要输出的目的地

2.创建BufferedOutputStream对象，构造方法中传递FileOutputStream对象，提高FileOutputStream对象效率

3.使用BufferedOutputStream对象中的方法write，把数据写入到内部缓冲区中

4.使用BufferedOutputStream对象中的方法flush,把内部缓冲区中的数据刷新到文件中

5.释放资源（会先调用flush方法刷新数据第四步可以省略）

字节缓冲输入流

BufferedInputStream extends InputStream

继承自父类的成员方法：

int read（）从输入流中读取数据的下一个字节

in（byte[]b）从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中

void close（）释放资源

构造方法

BufferedInputStream(InputStream in)创建一个 BufferedInputStream 并保存起参数，即输入流in，以便将来使用

BufferedInputStream (InputStream in,int size)创建具有指定缓冲区大小的BufferedInputStream 并保存其参数，即输入流

参数：

InputStream in 字节输入流

使用步骤：

1.创建FileInputStream对象，构造方法中要绑定要读取的数据源

2.创建BufferedInputStream对象，构造方法中传递FileInputSteam对象，提高FileInputStream对象的读取效率

3.使用BufferedInputStream对象中的方法read，读取文件

4.释放资源

字符缓冲输出流

继承自父类的成员方法

abstract void write（char[] cbuf,int off,int len）写入字符数组的一部分，off为开始索引，len为写的字符个数

void write(String str) 写入字符串

void write（String str ，int off ，int len）写入字符串的莫一部分，off为字符串的开始索引，len为写的字符个数

void flush刷新该流的缓冲

void close（）关闭此流，但要先刷新

构造方法

BufferedWriter(Writer out) 创建一个使用默认大小输出缓冲区的缓冲字符输出流

BufferedWriter(Writer out int size)创建一个使用给定大小的输出缓冲区的新缓冲字符输出流

参数：

Writer out：字符输出流

可以传递FileWriter，缓冲流会给FileWriter增加一个缓冲区，提高FileWriter的写入效率

int sz：指定缓冲区的大小

特有的成员方法

void newLine()写入一个行分隔符，会根据不同的操作系统，获取不同的行分隔符

使用步骤：

1.创建字符缓冲输出流对象，构造方法中传递字符输出流

2.调用字符缓冲输出流中的方法write，把数据写入到内存缓冲区中

3.调用字符缓冲流中的方法flush，把内存缓冲区的数据刷新到文件中

4.释放资源

字符缓冲输入流

共性的成员方法

int read（）从输入流中读取数据的下一个字节

in（byte[]b）从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中

void close（）释放资源

构造方法

BufferedReader(Reader in)创建一个使用默认大小输入缓冲区的缓冲字符输入流

BufferedReader(Reader in,int sz)创建一个使用指定大小输入缓冲区的缓冲字符输入流

参数：reader in：字符输入流

​ 可以传递FileReader，缓冲流会给FileReader增加一个缓冲区，提高FileReader的读取效率

特有的成员方法：

String readLine()读取一个文本行，

行的终止符号：通过下列字符之一即可认为某行已经终止：换行或回车或回车后直接跟着换行

返回值：包含该内容的字符串，不包含任何终止符，如果已到达流末尾，则返回null

使用步骤：

1.创建字符缓冲输入流对象，构造方法中传递字符输入流

2.使用字符缓冲输入流对象中的方法read/readLine（）读取文本

3.释放资源

转换流

转换流原理：

将字节输入流传输过来的字节通过InputStreamReader类按指定的码表转化为字符（解码）

将字符输出流传过来的字符通过OutputStreamWriter按指定的的码表转化为字节（编码）

字符编码：

就是一套自然语言的字符与二进制数之间的对应规则（编码表）

将字符存放在计算机中叫编码，将二进制数解析出来叫做解码

字符集

一个系统支持的所有字符的集合，包括各国家文字，标点符号，图形符号，数字等

读取的文件不是UTF-8（三个字节存储一个中文）格式而是GBK（两个字节存储中文）编码的文件该怎么办呢？

OutputStreamWriter

成员方法

abstract void write（char[] cbuf,int off,int len）写入字符数组的一部分，off为开始索引，len为写的字符个数

void write(String str) 写入字符串

void write（String str ，int off ，int len）写入字符串的莫一部分，off为字符串的开始索引，len为写的字符个数

void flush刷新该流的缓冲

void close（）关闭此流，但要先刷新

构造方法

OutputStreamWriter(OutputStream out)创建使用默认字符编码的OutputStreamWriter

OutPutStreamwriter(OutputStream out,String charsetName)创建使用指定字符记得OutputStreamWriter

参数：

OutputStream out ：字节输出流，用来写转换后的字节到文件中

String charsetName:指定的代码表名称，不区分大小写

使用步骤：

1.创建OutputStreamWriter对象，构造方法中传递字节输出流，和指定的编码表名称

2.使用OutputStreamWriter对象中的方法write，把字符转换为字节存储缓冲区中（编码）

3.使用OutputStreamWriter对象中的方法flush，把内存缓冲区中的字节刷新到文件中（使用字节流写字节的过程

）

4.释放资源

InputStreamReader

成员方法

继承自父类的共性成员方法：

int read（）从输入流中读取数据的下一个字节

in（byte[]b）从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中

void close（）释放资源

构造方法：

InputStreamReader(InputStream in) 创建一个使用默认字符集的InputStreamReader

InputStreamReader(InputStream in,char setName)创建使用指定字符集的InputStreamReader

参数：

InputStream in:字节输入流，用来读取文件中保存的字节

String charsetName:指定的编码表名称，不区分大小写

使用步骤

1.创建InputStreamReader对象，构造方法中传递字节输入流和指定的编码表名称

2.使用InputStreamReader对象中的方法read读取文件

3.释放资源

注意事项

构造方法中指定的编码表名称要和文件的编码相同，否则会发生乱码