Java基础之IO字节流

1 什么是IO？

I：input 输入（读取），把硬盘中的数据读取到内存中使用；
O：output 输出（写入），把内存中的数据写入到硬盘中保存；
流：数据（字符、字节），一个字符=两个字节，一个字节=8个二进制位

	输入流	输出流
字节流	字节输入流InputStream	字节输出流OutputStream
字符流	字符输入流Reader	字符输出流Writer

2 字节流

一切文件数据在存储时，都是以二进制数字的形式保存，都是一个个的字节，所以字节流可以传输任意文件的数据，底层传输的始终是二进制数据。

3 字节输出流

java.io.OutputStream:字节输出流，此抽象类表示输出字节流的所有类的超类（父类）

• 定义了一些子类公用的成员方法：

• public void close();关闭此输出流并释放与此输入流相关联的任何系统资源
  

• public void flush();刷新此输出流并强制任何任何缓存的输出字节被写出
  

• public void write(byte[] b):将b.length字节从指定的字节数组写入此输出流
  

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

• public abstract void write(int b):将指定的字节写入此输出流
  

• java.io.FileOutputStream extends OutputStream  文件字节输出流，将内存的数据写入到硬盘文件中
  

• 构造方法：

• FileOutputStream（String name）创建一个向具有指定名称的文件中写入数据的输出文件流  参数：是一个文件的路径
  

• FileOutputStream（File file）创建一个向指定file对象表示的文件中写入数据的文件字节流 参数：是一个文件
  

• 构造方法的作用：

1. 创建一个FileOutputStream对象
2. 会根据构造方法中传递的文件或文件路径，创建一个空的文件
3. 会把FileOutputStream对象指向创建好的文件

• 写入数据的原理（内存–>硬盘）

•   Java程序--JVM（Java虚拟机）--OS操作系统--OS调用写数据的方法--把数据写入到文件中
  

• 字节输出流的使用步骤：

1. 创建一个FileOutPutStream对象，构造方法中传递写入数据的参数；
2. 调用FileOutputStream对象中的writer方法，把数据写入到文件中；
3. 释放资源（清空内存，提高程序的效率）。

• 以下代码是输出一个字节：

package com.zrz.IO;

import java.io.FileOutputStream;
import java.io.IOException;

public class OutputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //1，创建一个FileOutPutStream对象，构造方法中传递写入数据的参数；
        FileOutputStream fos = new FileOutputStream("IOAndProperties\\a.txt");
        //2，调用FileOutputStream对象中的writer方法，把数据写入到文件中；
        fos.write(97);//写数据会把十进制转换成二进制
        //文本编辑器在打开文件时都会查询编码表，把字节转换为字符表示，0~127查询的是ASCII表，其他值查询的是默认码表（中文系统默认GBK）
        //3，释放资源（清空内存，提高程序的效率）
        fos.close();
    }
}

• 以下代码是输出多个字节

package com.zrz.IO;

import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.reflect.Array;
import java.util.Arrays;

public class OutputStreamDemo02 {
    public static void main(String[] args) throws IOException {
        //1，创建一个FileOutPutStream对象，构造方法中传递写入数据的参数；
        FileOutputStream fos = new FileOutputStream("IOAndProperties\\b.txt");
        //2，调用FileOutputStream对象中的writer方法，把数据写入到文件中；
        /*一次写入多个字节：
        *     如果写的第一个字节是正数（0~127），那么显示的时候会查询ASCII表
        *     如果写的第一个字节是负数，那么第一个字节和第二个字节会组成一个中文显示，查询系统默认码表（GBK）
        * */
        fos.write(49);
        fos.write(48);
        fos.write(48);
        byte[] bytes = {65,66,67,68,69};
        byte[] bytes1 = {-65,-66,-67,68,69};
        fos.write(bytes);
        //从指定的字节数组写入len字节，从偏移量off开始输出到此输出流。
        fos.write(bytes,1,2);
        //写入字符的方法：可以使用String类中的方法，把字符串转换成字节数组
        byte[] bytes2 = "你好".getBytes();
        System.out.println(Arrays.toString(bytes2));//[-28, -67, -96, -27, -91, -67]
        fos.write(bytes2);
        //3，释放资源（清空内存，提高程序的效率）
        fos.close();
    }
}

• 文件的续写
  FileOutputStream（String name，boolean append）创建一个向具有指定名称的文件中写入数据的输出文件流
  FileOutputStream（File file，boolean append）创建一个向指定file对象表示的文件中写入数据的文件字节流
• boolean append追加写的开关

• true：创建的对象不会覆盖源文件，继续在文件的末尾写数据
  

• false：创建一个新文件，覆盖原文件
  

• 换行：写换行符号

• Windows:\r\n
  

• Linux:\n
  

• Mac:\r
  

以下是文件续写和换行的代码

package com.zrz.IO;

import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;
 
public class OutputStreamDemo03 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("IOAndProperties\\c.txt",true);
        for(int i=0;i<10;i++){
            fos.write("你好".getBytes());
            fos.write("\r\n".getBytes());
        }
    }
}

4 字节输入流

java.io.InputStream:字节输入流，此抽象类表示输入字节流的所有类的超类（父类）

• 定义了一些子类公用的成员方法：

• int read():从输入流中读取文件的下一个字节；
  

• int read(byte[] b):从输入流中读取一定数量的字节，并将其存储在缓存数组b中；
  

• void close():关闭此输出流并释放与此输入流相关联的任何系统资源。
  

• 构造方法：

• FileInputStream（String name）
  

• FileInputStream（File file）
  

• 构造方法的作用：

1. 创建一个FileInputStream对象
2. 会把FileInputStream对象指定到构造方法中要读取的文件

• 读取数据的原理（硬盘–>内存）

•   Java程序--JVM（Java虚拟机）--OS操作系统--OS调用读取的方法--把读取文件
  

• 字节输出流的使用步骤：

3. 创建一个FileInputStream对象，构造方法中要绑定读取的数据源；
4. 调用FileInputStream对象中的read方法，读取文件；
5. 释放资源（清空内存，提高程序的效率）。

一次读取一个字节代码如下：

package com.zrz.IO.InputStream;

import java.io.FileInputStream;
import java.io.IOException;

public class InputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //1. 创建一个FileInputStream对象，构造方法中要绑定读取的数据源；
        FileInputStream fis = new FileInputStream("IOAndProperties\\a.txt");
        //2. 调用FileInputStream对象中的read方法，读取文件；
        //int read()读取文件的一个字符并返回，读取到文件的末尾返回-1
//        int len = fis.read();
//        System.out.println(len);
        //不清楚文件中有多少个字节，使用while循环，读取到-1时结束
        int len = 0;//记录读取到的字节
        while((len = fis.read()) != -1){
            System.out.println((char)len);
        }
        //3. 释放资源（清空内存，提高程序的效率）。
        fis.close();
    }
}

字节输入类一次读取多个字节的方法：

• int read(byte[] b):从输入流中读取一定数量的字节，并将其存储在缓存数组b中；
  

1. 方法参数byte[] 的作用：起到缓存作用，存储每次读到了多个字节（数组长度一般定义为1024（1kb）或1024的整数倍）；
2. 方法的返回值：每次读取的有效字节个数；

具体代码实现如下：

package com.zrz.IO.InputStream;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Arrays;

public class InputStreamDemo02 {
    public static void main(String[] args) throws IOException {
        //1. 创建一个FileInputStream对象，构造方法中要绑定读取的数据源；
        FileInputStream fis = new FileInputStream("IOAndProperties\\a.txt");
        //2. 调用FileInputStream对象中的read方法，读取文件；
//        byte[] bytes = new byte[2];
//        int len = fis.read(bytes);
//        System.out.println(len);
//        System.out.println(Arrays.toString(bytes));
//        System.out.println(new String(bytes));
        //不清楚文件中有多少个字节，使用while循环，读取到-1时结束
        int len1 = 0;//记录读取到的字节
        byte[] bytes = new byte[1024];
        while((len1 = fis.read(bytes)) != -1){
            //System.out.println(new String(bytes));
            System.out.println(new String(bytes,0,len1));
        }
        //3. 释放资源（清空内存，提高程序的效率）。
        fis.close();
    }
}

字节流就先到这里了，后面要用到其他的方法再更新！