3.2.7.字符串转换相关方法

3.2.7.1.char[] toCharArray()
将当前字符串拆分成新的字符串数组，做返回值返回

3.2.7.2.byte[] getBytes(String charsetName)
获得当前字符中底层的字节数组

3.2.7.3.String replace(char oldChar, char newChar)
将多有的老字符替换成新字符，返回替换的结果字符串

3.2.8.字符串的切割方法

3.2.8.1.public String【】split（String regex）
按照参数规则，将字符串切割成若干份

split方法参数其实是正则表达式若是按照英文.切割，必须要加“\\”

3.2.9.多个字符串没有大小修改或拼接，灵活使用当前字符串对象String

3.3.StringBuilder类

参见: 执行效率：

StringBuilder>StringBuffer>String (执行效率)

3.3.1.String和Stringbuilder 区别
String 是 一个不可变字节数组，被final修饰的
StringBuilder 是 一个可以变字节数组，没有被final修饰

3.3.1.1.

3.3.2.可变长字符串，线程不安全，效率高
单线程字符串大量的修改，建议使用StringBuilder

3.3.3.构造方法

3.3.3.1.StringBuilder()
构造一个其中不带字符的字符串生成器，初始容量为 16 个字符。

3.3.3.2.StringBuilder(String str)
构造一个字符串生成器，并初始化为指定的字符串内容。

3.3.3.3.StringBuilder(int capacity)
构造一个其中不带字符的字符串生成器，初始容量由 capacity 参数指定。

3.3.4.成员方法

3.3.4.1.int capacity()
Returns the current capacity.（初始容量）

3.3.4.2.int length()
Returns the length (character count).（真实字符串个数）

3.3.4.3.StringBuilder append(任何)
追加字符（任何数字，boolean等等）

3.3.4.4.StringBuilder delete(int start, int end)
删除数据，索引，start开始，end结束

3.3.4.5.StringBuilder insert(int offset, int i)
插入数据，索引 offset从那里插入 ，i字符‘’’

3.3.4.6.StringBuilder reverse()
反转

3.4.StringBuffer类

参见: 执行效率：

StringBuilder>StringBuffer>String (执行效率)

3.4.1.可变长字符串，线程安全，效率低
多线程环境下，需要保证线程安全，在对字符串做大量的修改，建议使用StringBuffer

3.5.基本数据类型包装类

3.5.1.基本数据对比包装类：
注意俩个：Int---------------->Integer
char--------------->Character
byte--------------->Byte
short-------------->Short
long--------------->Long
float---------------->Float
double-------------->Double
boolean------------->Boolean

3.5.2.自动拆装箱：
自动装箱：基本数据------>引用
自动拆箱：引用数据------->基本

3.5.3.Integer i3=127;
Integer i4=new Integer(127);
int i5=127;
System.out.println(i4==i5); //true
System.out.println(i3==i5); //true

3.5.3.1.Integer类型无论是否是new的,和基本数据类型比较,会自动拆箱,只要值相同肯定相同

3.5.4.注意：
1、Integer引用和引用数据类型比较，只要值一样，在范围内，就是相等
2、基本类型和引用数据类型，比较，引用数据类型会自动拆箱对比，只要值相等，就相等
3、只要new 就是新建对象了
4、只有Integer有缓冲区就是-128，127之间，在之间，内容相等就相等，超出就算内容相等返回false

3.6.Date日期类

3.6.1.类 Date 表示特定的瞬间，精确到毫秒。

3.6.2.构造方法

3.6.2.1.Date() ; 当前本机时间
分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）。

//Date() 分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）。
Date date=new Date();

3.6.2.2.Date(long date)
分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。

Date date1=new Date(9283472174982L);

3.6.3.成员方法

3.6.3.1. boolean after(Date when)
测试此日期是否在指定日期之后。

a.after(b)a的日期是否在b的日期之后

3.6.3.2. boolean before(Date when)
测试此日期是否在指定日期之前。

a.after(b)a的日期是否在b的日期之前

3.6.3.3. boolean equals(Object obj)
比较两个日期的相等性。

a.after(b)a的日期是否在b的日期是否相等

3.6.4.转换器
SimpleDateFormat

3.6.4.1.日期对象转字符串
format

SimpleDateFormat simple=new SimpleDateFormat(这里也可以加指定格式例如：2019/10/10 10:20:30);
Date date=new Date();
simple.format(date)

y: 年
M: 月
d: 日
H: 24小时制
h: 12小时制
m: 分
s: 秒
S: 毫秒

3.6.4.2.字符串转日期对象
parse

SimpleDateFormat simple3=new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss");
String str="2017年08月12日 05:36:15";
simple3.parse(str)

3.7.枚举类
枚举类是类，所有的枚举类，都是隐式的继承java.lang.Enum类
因为构造方法是私有的，所以测试类是无法直接new对象的，需要在类名.实例调用

3.7.1.定义一件事情的所有可能性

3.7.2.定义枚举类，是使用关键字：enum 类名，不在使用class

3.7.3.枚举类的每一个字段都是该类的一个实例（公共的静态的不可变的常量）
如何获取枚举的字段？
枚举类名。（点）字段名（方法）
默认字段修饰符为public static final修饰的

3.7.4.创建了枚举类，就无法在创建对象调用了，只能直接获取了（枚举类。字段名）
枚举内的属性只能私有，无法公共public 修饰

3.7.5.枚举类和实现子类相比？
少写了代码，少创建了类，提高效率

3.8.Math数字类

3.8.1.继承于java.lang.Math

3.8.2.常用的方法

3.8.2.1.static double ceil(double a)

向上取整，大于等于

3.8.2.2.static double floor(double a)

向下取整，小于等于

3.8.2.3.static long max(long a, long b)

两个值比较大的

3.8.2.4.static double min(double a, double b)

两个值比较小的

3.8.2.5.static long round(double a)

四舍五入，小数点后一位

4.异常
Throwable

4.1.错误
Error

4.1.1.一般是虚拟机脱出的，程序员无法控制的，无需关注，就是代码语法写错了

4.2.异常
Exception
异常见名

4.2.1.checked
编译时异常
系统判断有可能写这个代码会有问题，需要提前告知解决方案

4.2.1.1.在编译时，出现的异常，如不处理，程序无法运行

处理异常方式
想要处理这个功能就捕捉异常，不想处理这个功能，就抛出

捕获异常
try.....catch

当前不处理，异常抛到上一层，谁调用这个方法，谁处理这个异常

抛出异常
throws

1、在遇到异常的时候当前位置，开始处理，捕捉异常对象，使用异常的功能2、如果try中遇到的异常，try中下面的代码不会执行，如果没遇到异常，正常执行所有的try代码3、一个try可以跟多个catch，捕获小范围的异常，catch写在上面，否则下面的catch执行不到（先小异常后大异常）4、finally中的内容，无论是否处理异常，最终都会执行（会在try若是有return,finally也会强制执行）

try{ 可能会出现的异常的代码 }catch(异常类 引用)｛ ｝finally{ }

方法重写：如果父类的方法存在异常抛出，子类重写方法抛出异常范围<=父类< span="">

4.2.2.运行时异常
Runtime
所有的运行时异常都是直接，或间接的继承RuntimeException

4.2.2.1.在编译时没有检测到异常，然后在运行时出现的异常，可以通过逻辑判断（if）增强程序的健壮性解决（就是逻辑错了，但是这个代码还要，用if判断，让代码继续运行）

常见的运行时异常：
1、空指针(NullpointerExcption):对象为null(空）还要找索引，字节
2、数组索引越界（ArrayIndexOutofBoundsException）:例子，数组总共才5个，在查找时非要第7个
3、类型转换异常（ClassCastException）:例子，在多态，向下转型的时候，转错儿子了
4、数字异常（ArithmeticException）:例子，4/0
5、负数异常（NeptiveArraysizeException）:例子，在数组给长度的时候直接给了负数
6、数字格式异常（NumberFormatException）:例子，基本包装类，原字符串时纯数字，转换包装类，原字符串不是纯数字了
7、找不文件异常（FileNotFoundException）：例子，Io文件路径写错了
8、 EOFException: 文件存在,内容读取不到-->操作必须是源文件
9、ConcurrentmodificationException:并发修改异常：多个线程，同时操作数据，可是就一个数据，不知道这个数据给谁操作
10、ClassCastException：转换异常，因为一个类是数字类，错误数字类向字符串类的转换，从而产生了异常，强制转换或者是SQL映射时发生了这个异常。

4.2.2.2.可以用抛出异常或捕获异常处理，也可以if增强健壮性解决

4.2.3.制造异常
throw

4.2.3.1.heihei(-1);
}
static void heihei(int i){
if(i<0){
throw new ArrayIndexOutOfBoundsException();//制造异常对象
}

4.2.4.自定义异常类
除了java提供的这些异常类以外，自己定义的就是异常类

4.2.4.1.要求：
自己定义的异常类直接或间接的继承Exception或RuntimeExcepion等子类

4.2.4.2.先自己定义一个异常类继承Exception或RuntimeExcepion等子类，要有空构造，有带参构造，super(引用）
在做私有方法的时候set设置方法的时候判断，if(判断条件){throws new 自己写的异常类}
在主方法调用异常的时候捕捉异常

5.设计模式

5.1.单例模式
一个类只能有一个实例

5.1.1.懒汉式
当第一次调用功能，才创建对象，线程不安全，效率高

5.1.1.1.1、.私有的构造方法
2、私有的静态的该类的引用
3、公共的静态的访问方式

public class Single02 {
private Single02(){};
private static Single02 sing=null;
public static Single02 aa(){
if(sing=null){
sing=new Single02();
}
}
｝

5.1.1.2.为什么引用是私有的？
因为不私有，其他类，可以直接类。引用可以直接调用
为什么引用静态的？
因为需要类加载是第一次创建对象
为什么访问是静态？
因为引用是静态的
为什么构造方法是私有？
因为要防止其他类直接new 对象
为什么引用直接new对象？
因为懒汉式是需要类第一次加载创建对象
为什么在公共的访问方式要if?
因为需要知道，是不是要等于null，才能给他new对象

5.1.1.3.同步块
synchronized

同步方法
直接同步方法，同步的资源范围太大了
在返回数据类型之前就可以

子主题 1

同步块
一重锁
在一个if判断之前synchronized(类名。class)

子主题 1

双重锁
筛选条件
在最后的一个if之前上面synchronized(类名.class)

子主题 1

5.1.2.饿汉式
类第一次加载完成就创建好了对象，线程安全，效率低

5.1.2.1.为什么引用是私有的？
因为不私有，其他类，可以直接类。引用可以直接调用
为什么引用静态的？
因为需要类加载是第一次创建对象
为什么访问是静态？
因为引用是静态的
为什么构造方法是私有？
因为要防止其他类直接new 对象
为什么引用直接new对象？
因为懒汉式是需要类第一次加载创建对象

5.1.2.2.1、构造方法私有化，控制外部不允许直接创建对象，因为不能调用构造方法
2、提供一个静态的私有的该类引用--》存储创建的那个唯一的对象
3、公共的静态的访问方式，返回值：该类引用的对象，对象在该类的引用中存储

public class SingleTon01 {
private SingleTon01(){}
private static SingleTon01 singTon=new SingTon01():
public static SingleTon01 s(){
return singTon;
}
public int getA() {
return a
}
public void setA(int a) {
this.a=a;
}
void haha(){
syso("笑。。。。。")
}
}

5.2.代理模式

5.2.1.动态代理模式

5.2.1.1.

5.2.2.静态代理模式

5.2.2.1.1、一种对象不适合直接引用另一个对象
2、原本两个子类没有联系，因需要实现共同的功能产生联系，所以需要一个子类引用另一个子类的对象引用

5.2.2.2.1、真实角色
2、代理角色
3、相同共性的接口
4、代理角色要持有真实角色的引用
5、代理行为

5.2.2.3.优点：解耦，便于后期维护

5.3.简单工厂模式

5.3.1.抽象产品角色：具体的产品角色实现的父接口
具体产品角色：抽象产品角色的实现类或子类
工厂角色生产产品

5.3.1.1.1、一个父接口，两个实现子类，实现接口重写法方法
2、在主方法中，用接口做返回值，静态的带参成员方法
3、用接口做数据类型 给null,
4、if判断引用。equals(子类名称）
5、return 接口
6、直接调方法

public class Factory04 {
public static void main(String[] args) {
Car car=factory("Mes");
car.run();
}
//工厂角色 创造不同的车
public static Car factory(String name){
Car car=null;
if(name.equals("Mes")){
car=new Mes();
}else{
car=new YeMa();
}
return car;
}
}
//接口
interface Car{
void run();
}
//奔驰
class Mes implements Car{
@Override
public void run() {
System.out.println("坐在引擎盖上哭...");
}
}
//野马
class YeMa implements Car{
@Override
public void run() {
System.out.println("野马...");
}
}

5.3.2.一个共性的接口，俩个子类实现，工厂方法，返回值父类接口，传值要什么，创建个地址，给个空值，if对比条件，在给对象，最好return接收，父类引用

5.4.内部类
类中定义类
当类中成员也是一个事物需要定义成为类时

5.4.1.成员内部类
位置：类中方法外，成员位置

5.4.1.1.特点

类的特性

可以直接继承，或实现类或接口，修饰符权限修饰符

成员的特点

可以用成员修饰符：public ,static ,final

5.4.1.2.注意

1、内部类中不可以定义静态的内容（变量和方法），只能用final修饰的变量
2、内部类可以直接外部类的成员（变量和方法），包括私有的
3、外部类用内部类的内容，需要new内部类的对象调用

5.4.1.3.如何其他类中调用内部类？
需要跟随外部类的对象进行调用
1、先new外部类，在内部类类型 引用=外部类。new内部类类型（），这个需要导包
2、直接外部类类型.内部类类型 引用=new 外部类类型().new 内部类类型();

5.4.1.4.在系统内部文件显示
Outer01$Inner -->$代表内部类

5.4.2.静态内部类

5.4.2.1.1、可以定义静态的内容
2、静态内部类静态方法，可以直接使用外部类与内部类的静态变量，但是外部类与内部类的成员变量，需要对象调用
3、静态内部类成员方法，可以直接调用静态内部类的静态变量和成员变量，外部类的静态变量，也可以直接调用，但是外部类的成员变量，需要通过对象调用
4、外部类的成员方法，需要类名调用内部静态变量名，静态内部类的成员变量，需要通过对象调用，外部类的静态变量和成员变量可直接调用

5.4.2.2.如何测试类调用静态内部类的内容？
1、外部类类型。内部类类型。变量名
2、外部类类型。内部类类型 引用=new 外部类类型。内部类类型（）

5.4.3.局部内部类
被final修饰的内部类

5.4.3.1.测试类调用局部内部类时调不出来的

5.4.3.2.位置：
方法中定义内部类

5.4.3.3.注意：
1、不能使用,public static default,protected,private ...修饰的
2、只能在自己的局部内部类方法外调用自己的对象的方法或变量，外部类可以直接调用，自己局部内部类需要new对象
3、局部内部类使用方法的参数，要求这个参数必须被final修饰，1.7之前版本必须显示，1.8之后默认的

5.4.4.匿名内部类

参见: Lambda表达式

1.8新特性 (区别，Lambda必须式函数式接口，而匿名内部类可以是函数接口，也不是函数接口)

5.4.4.1.简化没有具体本身作用的实现类

5.4.4.2.三种实现方式
只需要一个父类或父接口

匿名对象

匿名的实现类对象，只能使用一次，用完就没有了

new 父类类型()｛子类重写父类的方法（其实就是父类有什么方法，在这里可以直接重写）｝.子类重写父类的方法名（就是父类里面的方法名）

1、匿名内部类，在创建对象的时候，只能使用一次(仅适用于匿名对象不适用匿名类实例）
如果希望多次创建对象，而且类的内容是一样的，那么就必须单独定义实现子类
2、匿名对象，在调用方法的的时候，只能调用一次
如果希望同一个对象，调用多个方法，那么，必须给对象起名字
3、匿名内部类就是省略了实现类或子类名称，但是匿名对象是省略了对象名称
匿名内部类和匿名对象不是一回事

匿名类实例（有对象名）

利用多态思维，可以把匿名内部类的信息给引用，多次调用

父类类型 引用=new 父类类型｛子类重写父类的方法（其实就是父类有什么方法，在这里可以直接重写）｝引用。子类重写父类的方法名（其实就是父类的方法名）

可以方法的参数作用

写在类中方法外：方法名 （父类类型 形参）｛形参。子类重写父类的方法名（其实就是父类的方法名）｝
写在方法里：方法名（new 父类类型（）｛子类重写父类的方法（其实就是父类有什么方法，在这里可以直接重写）｝）

5.4.4.3.Lambda表达式
1.8新特性

参见: 匿名内部类 (区别，Lambda必须式函数式接口，而匿名内部类可以是函数接口，也不是函数接口)

作用：符合条件的可以简化匿名内部类

格式：
()->{}
():重写方法的参数列表
->:Lambda符号，上下文推导作用
{}:重写抽象方法的方法体

前提：
必须是函数式接口
怎么检测是不是函数式接口？
@FunctionalInterface
什么式函数式接口？
只有一个抽象方法的接口

写法

1、只保留唯一的一个需要被重写的抽象方法的方法体和参数列表
父类数据类型 引用=（）->{syso("重写的内容")}
2、当方法体只有一句话，方法体{}前后的花括号可以省略
父类数据类型 引用=（）->syso("重写的内容")
3、当抽象方法存在参数，参数的参数数据类型可以省略
父类数据类型 引用=（参数）->syso("重写的内容)
引用。父类的方法名（传参）
4、当参数只有一个的时候，参数列表前后的()小括号可以省略
父类数据类型 引用=参数 ->syso("重写的内容”)
引用。父类的方法名（传参）
5、当抽象方法式需要返回值的，需要return 返回值 的时候，return可以省略
父类数据类型 引用= 参数->返回值
引用。父类的方法名（传参）

函数式接口：
@FunctionalInterface
interface HaHa{
String h();
}
有参数的抽象方法
@FunctionalInterface
interface HaHa{
int h(int a);
}

5.4.5.私有内部类

5.4.5.1.私有的内部类中的内容只能在外部类通过对象调用

5.4.5.2.1、测试类调用私有内部类的私有方法
调不出来
2、测试类调用私有内部类的私有变量
先在外部成员方法，new私有内部类对象，在调用

5.4.5.3.私有的内部类，可以有私有的，也可以有成员的

6.IO流

6.1.Io流
读写文件中的内容
都是java.Io包下的

6.1.1.流：是通道，一连串流动的数据，先入先出的特点
IO:读入写出

6.1.2.操作单元
节点流:直接从数据源到目的地

6.1.2.1.子节流
所有数据可以都可以用字节流操作（文本或图片）

参见: 字节功能流

父类重写了子类，可以用多态 (功能流包含字点流)

输入流
FileInputTream+read写入，关闭

格式：
1、选择流，父类，多态思维，文件路径
InputStream 引用=new FileInputStream(文件路径)
2、准备数组
byte[] 引用=new byte[1024]
3、开始装数据
int num=-1;
4、如果文件的读取数组的内容为-1，则不在读取数据，否则会读取数据
相当于不用整个byte数组读取出来，只读取byte数组里面装的内容
while(num=流的引用.read(数组的引用)不等于-1){
String类型 引用=new String(数组，从那里，存到那里（存多少数据）)
打印
}
5、判断路径是否存在，关闭资源，提升作用域
流的引用.close

参见: 从那个文件写出

InputStream inp=new FileInputStream(文件路径);

写到那个文件，追加

OutputStreamoup=new FileOutputStream(文件路径);

读入写出

准备数组

byte[] in=new byte[1024];

int num=-1;//存储读入的数据

while(-1!=(num=inp.read(in))){

写出原文件数据的内容，不是整个数组写出

oup.write(in,0,num);

}

刷出

oup.flush();

判断文件是否存在，在关闭资源，后开的先关闭

流的引用.close

输出流
FileOutputStream+输出write(）+appecd追加+ 刷出flush() + close()关闭

格式：
1、选择流，父类，多态思维，文件路径
OutputStream 引用=new FileOutputStream(文件路径)
2、准备数据
String s="";
3、写出
流的引用.write(数据的引用。getBytes(),从那里开始，到那里结束)
4、刷出
流的引用.flush();
5、先判断是不是有路径，在关闭
流的引用.close();

参见: 从那个文件写出

InputStream inp=new FileInputStream(文件路径);

写到那个文件，追加

OutputStreamoup=new FileOutputStream(文件路径);

读入写出

准备数组

byte[] in=new byte[1024];

int num=-1;//存储读入的数据

while(-1!=(num=inp.read(in))){

写出原文件数据的内容，不是整个数组写出

oup.write(in,0,num);

}

刷出

oup.flush();

判断文件是否存在，在关闭资源，后开的先关闭

流的引用.close

基本数据类型流：data
仅是字节流的功能流
读写的顺序保持一致

输出

公共的，静态的，void write（string path（路径））｛ DataOutputStream基本数据输出流 引用=new DataOutputStream基本数据输出流(new BufferedOuputSteram缓冲输出流（new FileOuputStream文件输出流（path路径传值））) 引用。writeInt(写值：100)； 刷出：引用。flush(): 关闭资源：引用.close();}

参见: 公共的，静态的，void read（string path（路径））｛

DataInputStream基本数据流 引用=new DataInputStream基本数据流(new BufferedInputStream缓冲流（new FileInputStream文件输入流（path路径））)

数据类型 引用=基本数据流引用。read+数据类型（）；

引用。close();

｝ (主方法：

先write(绝对路径)在删掉

read("绝对路径"))

输入

公共的，静态的，void read（string path（路径））｛ DataInputStream基本数据流 引用=new DataInputStream基本数据流(new BufferedInputStream缓冲流（new FileInputStream文件输入流（path路径））) 数据类型 引用=基本数据流引用。read+数据类型（）； 引用。close();｝

参见: 公共的，静态的，void write（string path（路径））｛

DataOutputStream基本数据输出流 引用=new DataOutputStream基本数据输出流(new BufferedOuputSteram缓冲输出流（new FileOuputStream文件输出流（path路径传值））)

引用。writeInt(写值：100)；

刷出：引用。flush():

关闭资源：引用.close();

} (主方法：

先write(绝对路径)在删掉

read("绝对路径"))

对象流
和字节流的区别：对象流可以和对象和数据，字符串

1、序列化(Objectoutpustream)：对象转字节流的输出
2、反序列化(ObjectInputStream)：字节转对象的输入，存储
3、先序列化在反序列化

注意：
1、被关键字static修饰的属性，会导致取出的数据和存入的数据不一致
2、被关键字transiect修饰的属性，会导致对象不可获取
3、若需要被序列化需要类实现接口：seriaizable
4、若父类实现seriaizable接口，子类可对父类的所有内容进行序列化
5、若子类实现了serializble接口，父类没有实现serializble接口，子类只能序列自己独有的内容

对象流新增的方法，所以在创建对象的时候，无法使用多态
1、输出：writeobject
2、输入：readObject

例子：
先创建类释宪案接口seriaizable
//反序列化输入流
public static void inp(String path) throws FileNotFoundException, IOException, ClassNotFoundException{
ObjectInputStream inp=new ObjectInputStream(new BufferedInputStream(new FileInputStream(path)));
//多态的思想，大家的爸爸
Object oo=inp.readObject();
//关闭
inp.close();
}
//序列化输出流
public static void out(String path) throws FileNotFoundException, IOException{
ObjectOutputStream obj=new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(path)));
//new对象
Fu f=new Fu("小孙",18);
//对象流包含对象
obj.writeObject(f);
//刷出
obj.flush();
//关闭资源
obj.close();
}
//主方法调用
序列化。out(绝对路径）
反序列化。inp(结对路径）

6.1.2.2.字符流
纯文本的数据可以用字符流，图片可传不可以打开（因为在转向字符会和as表中的数据替换导致图片打不开）

参见: 字符功能流

子类有拓展自己的方法，不适合多态，和其他流的区别 (功能流包含字点流，有一点细微区别，注意：没有字节数组)

输入流:Reader
FileReader+read()写入 +append()追加 + close()关闭

参见: 格式;

1、字符文件输入流，多态，文件路径

Reader read=new FileReader(文件地址);

字符文件输出流，多态，文件路径

Writer write=new FileWriter("D:/houhou.txt",true);

2、准备字符数组数据

char[] car=new char[1024];

3、存储字符数据

int len=-1;

4、循环遍历数据

while((len=read.read(car))!=-1){

输出文件内容

write.write(car, 0, len);

}

5、刷出

输出流引用.flush();

6、判断路径是否为真，关闭资源，提升作用域

流的引用。close();

输出流:writer
FileWriter+writer()读出+appecd()追加（防止文件内容被重写）+flush()刷出+close()关闭

参见: 格式;

1、字符文件输入流，多态，文件路径

Reader read=new FileReader(文件地址);

字符文件输出流，多态，文件路径

Writer write=new FileWriter("D:/houhou.txt",true);

2、准备字符数组数据

char[] car=new char[1024];

3、存储字符数据

int len=-1;

4、循环遍历数据

while((len=read.read(car))!=-1){

输出文件内容

write.write(car, 0, len);

}

5、刷出

输出流引用.flush();

6、判断路径是否为真，关闭资源，提升作用域

流的引用。close();

6.2.功能流：缓冲流
功能包含字点流
作用：加快读写效率

6.2.1.字节功能流
父类重写了子类，可以用多态

参见: 子节流

所有数据可以都可以用字节流操作（文本或图片） (功能流包含字点流)

6.2.1.1.输入
BufferedInputStream

参见: 格式：

1、选择流

InputStream 引用=new BufferedInputStream功能流（new FileInputStream字节文件输入（路径））

OutputStream 引用=new BufferedOutputStream(功能流）（new FileOutputStream字节文件输出(路径)）

2、准备数组

byte[] car=new byte[1024];

3、存储字节数据

int len=-1;

4、循环遍历文件内容

while((len=is.read(car))!=-1){

写出文件内容

os.write(car, 0, len);

}

5、刷出

输出流引用.flush();

6、关闭

流的引用.close();

6.2.1.2.输出
BufferedOutputStream

参见: 格式：

1、选择流

InputStream 引用=new BufferedInputStream功能流（new FileInputStream字节文件输入（路径））

OutputStream 引用=new BufferedOutputStream(功能流）（new FileOutputStream字节文件输出(路径)）

2、准备数组

byte[] car=new byte[1024];

3、存储字节数据

int len=-1;

4、循环遍历文件内容

while((len=is.read(car))!=-1){

写出文件内容

os.write(car, 0, len);

}

5、刷出

输出流引用.flush();

6、关闭

流的引用.close();

6.2.2.字符功能流
子类有拓展自己的方法，不适合多态，和其他流的区别

参见: 字符流

纯文本的数据可以用字符流，图片可传不可以打开（因为在转向字符会和as表中的数据替换导致图片打不开） (功能流包含字点流，有一点细微区别，注意：没有字节数组)

6.2.2.1.输入
BufferedReader

参见: 格式：

1、选择字符功能流

BufferedReader 引用=new BufferedReader功能(new FileReader字符输入("D:/first.txt"));

BufferedWriter 引用=new BufferedWriter功能(new FileWriter字符输出("D:/haha.txt"));

2、存储读入的数据

String 引用=null;

3、循环reading每一行

while((msg=br.readLine())!=null){

写出数据内容

bw.write(msg);

bw.newLine(); //换行，不换行，数据都写在一起了

}

4、刷出

输出流的引用.flush()

5、关闭资源

流的引用.close()

6.2.2.2.输出
BufferedWriter

参见: 格式：

1、选择字符功能流

BufferedReader 引用=new BufferedReader功能(new FileReader字符输入("D:/first.txt"));

BufferedWriter 引用=new BufferedWriter功能(new FileWriter字符输出("D:/haha.txt"));

2、存储读入的数据

String 引用=null;

3、循环reading每一行

while((msg=br.readLine())!=null){

写出数据内容

bw.write(msg);

bw.newLine(); //换行，不换行，数据都写在一起了

}

4、刷出

输出流的引用.flush()

5、关闭资源

流的引用.close()