java ：IO流

一、字符与字节
字节是计算机存储容量的度量单位 1byte =8bit

字符是指计算机中所使用的文字和符号，比如1、2、3、4、A、B、C、a、b、c、！、#、@、——》等等。

二、IO流的概述
打个比方：
北京—>火车站—>上海
北京：源头
火车站：Java
上海：目的地
北京进火车站：输入流
出火车站到上海：输出流

三、字节输入流
java.io.InputStream；抽象类，是所有字节输入流的父类
java.io.FileInputStream；文件字节输入流，继承了InputStream

换行符号
windows系统:\r\n
linux系统:/n
mac系统:/r

1、作用：
把硬盘文件数据读取到内存中

2、构造方法：
FileInputStream(String name)
FileInputStream(File file)

3、使用方法：
int read()
；从输入流的数据中，读取下一个字节。

int read(byte[] b)
：从输入流的数据中，读取多个字节，并将字节存储缓冲在b数组中。

void close()
：关闭输入流，释放资源，清理内存

读取数据的原理

java程序–>JVM(java虚拟机)–>OS(操作系统)–>OS调用读取数据的方法–>读取文件

 public static void main(String[] args) throws IOException{
        //创建文件字节输入流的对象，读取对象
        FileInputStream fis = new FileInputStream("D:\\IO\\B.txt");
        //使用字节输入流调用对象
        /*
        int l = fis.read();
        System.out.println(l);//97

        int l1 = fis.read();
        System.out.println(l1);//98
*/
        //每一个字节就要写一段代码，可以使用循环
        int len =0;
        while ((len=fis.read())!=-1){//-1是已经到末尾
            System.out.println(len);
        }
    }

文件输入字节流的String构造方法
String(byte[] bytes)
String(byte[] bytes, int offset, int length)

public static void main(String[] args) throws IOException {
    //创建文件字节输入流对象，并读取传递数据的对象
    FileInputStream fis = new FileInputStream("D:\\IO\\B.txt");

    /*
    //读取多个字节
    byte [] bytes =new byte[5];
    System.out.println(fis.read(bytes));//5
    System.out.println(new String(bytes));//abcdb

    //重复打印
    System.out.println(fis.read(bytes));//5
    System.out.println(new String(bytes));//cd好
    */

    //以上代码太繁琐，可以使用while
    byte [] b = new byte[1024];
    int len = 0;
    while ((len=fis.read(b))!=-1){
        System.out.println(len);//19

        //这种输出方法因为字节是1024个单位，所以输出打印后会有空格
       // System.out.println(new String(b));//abcdbcd好好学习(后面是空格)
        System.out.println(new String(b,0,len));//abcdbcd好好学习
    }
    fis.close();
}

四、字节输出流
java.io.OutputStream；抽象类，是所有字节输出流的父类
java.io.FileOutputStream；文件字节输出流，继承了OutputStream
1、作用：
从内存输出文件到硬盘中

2、原理
java程序–>JVM(java虚拟机)–>OS(操作系统)–>OS来调用写数据的方法–>写入到文件

3、构造方法
FileOutputStream(String name)：写入的目的地是一个文件的路径
FileOutputStream(File file):写入的目的地是一个文件

4、使用方法
public abstract void write(int b)
：写入指定输出流（单个）

public void write(byte[] b)
：写入指定数组长度的输出流（多个）

public void write(byte[] b, int off, int len)
：在指定数组长度的基础上，使用索引值调用指定长度的字节

public void close() ：释放资源，关闭输出流，清理内存

public static void main(String[] args) throws IOException{
    //创建文件字节输出流对象，并传递写入数据目的地
    FileOutputStream fos = new FileOutputStream("D:\\IO\\A.txt");//路径相对和绝对都可以
       //文件字节输出流对象调用write,文件写入数据
       fos.write(98);//，
       //释放资源
    fos.close();
}

public static void main(String[] args)throws IOException {
    //创建文件字节输出流对象，并传递写入数据到目的地
    FileOutputStream fos = new FileOutputStream("D:\\IO\\B.txt");

    //使用字节数组
    byte [] bytes ={97,98,99,100};
    fos.write(bytes);//在B.txt文档里会有abcd

    //在字节数组的基础选择一部分写入文本
    //1是索引值，3是从索引值起向后取出几个
    fos.write(bytes,1,3);//bcd

    //字符串转换字节
    byte[] bytes1 = "好好学习".getBytes();
    //用数组集合打印字节
    System.out.println(Arrays.toString(bytes1));
    //[-27, -91, -67, -27, -91, -67, -27, -83, -90, -28, -71, -96]
    //文本输出结果
    fos.write(bytes1);//好好学习
}

/*
使用IO流复制文件
1、先要创建文件字节输入流读取文件，读入数据
2、再创建文件字节输出流写入文件，写入文件到目的地
 */
 public static void main(String[] args) throws IOException{
    //创建文件字节输入流的对象，并读取数据对象
    FileInputStream fis = new FileInputStream("D:\\IO\\1.png");

    //创建文件字节输出流对象，并写入数据对象
    FileOutputStream fos = new FileOutputStream("C:\\a\\1.png");
/*
    //使用read方法读取文件字节
    int len =0;
    while ((len=fis.read())!=-1){
        fos.write(len);
        // System.out.println(len);
    }
    */

    //可以使用byte数组缓存读取多个字节
    //这样传输速度更快
    byte[] bytes = new byte[1024];
    int len = 0;
    while((len=fis.read(bytes))!=-1){
        fos.write(bytes,0,len);
    }

    //资源释放
    fos.close();
    fis.close();
}

五、字符输入流、字符输出流
java.io.Reader; 是字符输入流的父类
java.io.FileReader: 文件字符输入流

java.io.Writer：是字符输出流的父类
java.io.FileWriter：文件字符输出流

FileReader extends InputStreamReader extends Reader

构造方法和使用方法与字节输入流、输出流大同小异
一个是byte
一个是char

字符流可以直接输入字符串

fw.write("你好！")//你好！

六、缓冲流
概念：
从家里拿着一袋东西到一个地方

*如果是走路，东西存放在手上，东西拿的少，速度慢(输出流)

*如果开车，东西存放在车里，东西拿的多，而且速度快(缓冲输出流)

字节缓冲输入流：BufferedInputStream
字节缓冲输出流：BufferedOutputStream

java.io.BufferedIntputStream extends InputStream
java.io.BufferedOutputStream extends OutputStream

使用方法
因为继承所以方法大致和字节流一致

构造方法
要将 文件字节流 的 对象
传递到 字节缓冲输入流 或者 输出流 中

public static void main(String[] args) throws IOException{
  //创建一个文件字节输出流的对象，到哪个地方
    FileOutputStream fos = new FileOutputStream("D:\\IO\\A.txt");

    //创建字节缓冲输出流对象，传递fos
   BufferedOutputStream bos =new BufferedOutputStream(fos);

   //bos调用write方法，写入数据到缓冲区
    byte [] b  = {97,98,99};
    bos.write(b);

   // bos.write("\r\n".getBytes());//换行

    byte []bytes = "字节缓冲输出流".getBytes();
    bos.write(bytes);

    bos.flush();

    bos.close();
}

public static void main(String[] args) throws IOException{
    FileInputStream fis = new FileInputStream("D:\\IO\\A.txt");

    BufferedInputStream bis = new BufferedInputStream(fis);

    /*
    int len =0;
    while ((len=bis.read())!=-1){
        System.out.println(len);
    }
    */

    byte [] bytes =new byte[1024];
    int len =0;
    while((len=bis.read(bytes))!=-1){//注意bytes要传递进去
        System.out.println(new String(bytes,0,len));//abc缓冲字节输出流
    }

    bis.close();
}

七、字符缓冲输入流、字符缓冲输出流
BufferedReader：字符缓冲输入流
继承了Reader

BufferedWriter：字符缓冲输出流
继承了Writer

也要先传递 字符流 的 对象 到 字符缓冲流中

void newLine() 写入一个行分隔符
字符缓冲输出流的对象名.newLine;//换行

String readLine() 读取一个文本行。读取一行数据
可以使用循环

String line;
	//逐行读取缓冲流对象br中的文本
        while((line = br.readLine())!=null){
            System.out.println(line);
        }

八、转换流
InputStreamReader
outputStreamWriter

九、序列化流和反序列化流
序列化流： ObjectOutputStream
也就自定义类，把对象内容写到内存，字节形式存储
writeObject();

反序列化流： ObjectInputStream
从内存中读取出来
readObject();

创建自定义类时，必须实现一个空接口
Serializable接口
这个就是查看有没有序列化流，没有就会出现异常

十、打印流
PrintStream