IO字节流字符流

IO流是什么：i：input （输入：读取） 输入：把硬盘中的数据读取到内存中去
o： output （输出：写入） 输出：把内存中的数据写入到硬盘中保存
流：字符流 字节流
字节输入流（InputStream） 字节输出流（OutputStream）
字符输入流（Reader） 字符输出流（Writer）
FileOutputStream:文件字节输出流
构造方法：FileOutputStream(String name) 创建一个像具体指定名称的文件中写入数据的输出文件流
FileOutputStream(File file) 创建一个向指定File对象表示的文件中写入数据的文件输出流
参数：写入数据的目的 String name: 目的地是一个文件的路径 File file:目的地是一个文件
构造方法的作用：创建一个FileOutputStream对象
会根据传递方法中传递的文件/文件路径，创建一个空文件夹
会把FileOutputStream对象指向创建好的文件
写入数据的原理（内存–>硬盘）不是IO流直接写入
java程序–JVM–操作系统（OS）–OS调用写数据方法–把数据写入到文件中
自己输出流使用步骤：
创建一个FileOutputStream对象，构造方法中传递写入数据的目的地
调用FileOutputStream对象中的方法write，把数据写入到文件中
释放资源（流使用的时候会占用一定的资源，使用完毕要把内存清空）

FileOutputStream fos = new FileOutputStream("D:\\lianxi\\lianxi1\\v.txt");//创建对象
fos.write(97);//调用写文件的方法
fos.write(12);//调用
fos.close();//释放资源

子类共性方法：
public void close() 关闭此输出流并释放于此流的相关资源
public void flush() 刷新此输出流并强制任何缓冲缓冲的输出字节被写入
public void write(byte[] b) 将b.length字节从指定的字节组写入此输出流

FileOutputStream fos = new FileOutputStream(new File("D:\\lianxi\\lianxi1\\l.txt"));
byte[] bytes = {49,48,48};
fos.write(bytes);

public void write(byte[] b,int off,int len) 从自定字节组写入 len字节，从偏移量off开始输出到此字节流

FileOutputStream fos = new FileOutputStream(new File("D:\\lianxi\\lianxi1\\oo.txt"));
byte[] bytes = {49,48,48,6,9,8};
fos.write(bytes,1,2);

public abstract void write(int b) 将指定的字节输出流
byte[] getBytes() 写字符串 把字符串转换成字节组

FileOutputStream fos = new FileOutputStream(new File("D:\\lianxi\\lianxi1\\oo.txt"));
byte[] bytes = "咋瓦鲁多".getBytes();
fos.write(bytes);

续写与换行
续写：使用两个参数的构造方法
FileOutputStream(String name,boolean append) 创建一个定具有指定，name的文件写入数据的输出文件流
FileOutputStream(File file,boolean append) 创建一个指定 File对象表示的文件中写入数据的文件输出
参数：String name ,File file 写入数据的目的地
boolean append 追加写开关
true创建对象不会覆盖原文件，继续在文件的末尾追加写数据

FileOutputStream fos = new FileOutputStream(new File("D:\\lianxi\\lianxi1\\oo.txt"),true);
fos.write("您好".getBytes());
fos.close();

换行：\r\n 也是一个字符串

FileOutputStream fos = new FileOutputStream(new File("D:\\lianxi\\lianxi1\\oo.txt"), true);
for (int i = 1; i <= 10; i++) {
    fos.write("咋瓦鲁多".getBytes());
    fos.write("\r\n".getBytes());
}
fos.close();

字节输入流：InputStream
int read() 输入流中读取数据的下一个字节
FileInputStream fis = new FileInputStream(“D:\lianxi\lianxi1\oo.txt”);
int re = fis.read();
System.out.println(re);
fis.close();
int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组B中

FileInputStream fis = new FileInputStream("D:\\lianxi\\lianxi1\\oo.txt");
byte[] bytes = new byte[2];
int i =  fis.read(bytes);
System.out.println(i);
System.out.println(Arrays.toString(bytes));
fis.close();

void close() 释放内存
InputStream：文件字节输入流 作用：把硬盘文件中的数据，读取到内存中使用
构造方法：
InputStream(String name)
InputStream(File file)
参数：读取文件的数据源
String name 文件路径
File file 文件
构造方法作用：
会创建一个InputStream对象
会把InputStream对象指向构造方法中要读取的文件
使用步骤
创建InputStream对象，构造方法中绑定要读取的数据源
使用InputStream对象中的方法read读取文件
释放资源

FileInputStream fis = new FileInputStream("D:\\lianxi\\lianxi1\\oo.txt");
int re = fis.read();
System.out.println(re);
fis.close();

文件复制
创建一个字节输入对象，构造方法中绑定要读取的数据源
创建一个字节输出对象，构造方法中绑定要写入的目的地
使用字节输入流对象中的方法read读取文件
使用字节输出流中的方法write 吧读取到的字节写入到目的地
释放资源

FileInputStream fis = new FileInputStream("D:\\lianxi\\lianxi1\\oo.txt");
FileOutputStream fil = new FileOutputStream("D:\\lianxi\\lianxi1\\v.txt");
byte[] bytes = new byte[1024];
int len = 0;
while ((len = fis.read())!=-1){
    fil.write(bytes,0,len);
}
fil.close();
fis.close();

IO字符流 reader 把硬盘中的文件以字符的方式读取到内存中
共性成员方法：
int read() 读取单个字符并返回
int read(char[] cbuf) 一次读取多个字符，将字符读入数组
int close() 释放内存
构造方法：
FileReader(String fileName)
FileReader(File file)
参数:：读取文件的数据源 String fileName文件路径 FileReader(File file)文件
步骤：创建 FileReader对象，构造方法中绑定要读取的数据源
FileReader对象使用read方法
释放内存

FileReader fi = new FileReader("D:\\lianxi\\lianxi1\\oo.txt");
char[] cs = new char[1024];
int len = 0;
while ((len = fi.read(cs))!=-1){
    System.out.println(new String(cs,0,len));
}
fi.close();

字符输出流 writer 把内存中的字符写入到硬盘中
构造方法：
FileWriter(File file) 根据给定的file对象构造一个FileWriter对象
FileWriter(String fileName) 根据给定的文件名构造一个FileWriter对象
参数：写入数据目的地
字符输出流的使用步骤：
创建一个FileWriter对象 构造方法中写入绑定目的地
使用FileWriter中的方法write，把数据写到内存缓冲区（字符转换成字节的过程）
使用FileWriter中的方法flush(刷新的方法)把内存缓冲区的数据，刷新到文件中去
释放资源

FileWriter fil = new FileWriter("D:\\lianxi\\lianxi1oo.txt");
fil.write(97);
fil.flush();
fil.close();

续写换行和字节流一样
IO流异常处理
格式：
try{
可能会产生异常的代码
}catch(异常类变量 变量名){
异常处理逻辑
}finally{
一定会指定的代码
资源释放
}

FileWriter fil = null;
try {
    fil = new FileWriter("D:\\lianxi\\lianxi1oo.txt");
    fil.write(97);
    fil.flush();
}catch (IOException e){
    System.out.println(e);
}finally {
    if (fil!=null){
        try {
            fil.close();
        } catch (IOException e) {
            e.printStackTrace();
        }   
    }
}