IO字节流

Posted 2021-10-07 超霸霸

IO字节流

一、什么是字节流

• 一切文件数据在存储时都是以二进制数字的形式保存，都是一个一个的字节，传输时一样如此。所以，字节流可以传输任意文件数据。在操作流的时候，我们要明确，无论使用什么样的流对象，底层传输的始终为二进制数据

	输入流	输出流
字节流	字节输入流：InputStream（读取）	字节输出流：OutputStream（写入）

• 流：数据（字符，字节）

  • 1个字符=2个字节

  • 1个字节=8个二进制位

• 写入数据的原理：

  java程序 - ->JVM(java虚拟机) - ->OS(操作系统) - ->OS调用写数据的方法 - ->把数据写入文件中

• 读取数据的原理：

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

二、字节输出流【OutputStream】

• 需要的包文件：java.io.OutputStream
• 构造方法：

FileOutputStream(String name)	创建一个向具有指定名称的文件中写入数据的输出文件流
FileOutputStream(File file)		创建一个向指定File对象表示的文件中写入数据的文件输出流

- **方法摘要：**

| 方法名                                   | 功能                                                         |
| ---------------------------------------- | ------------------------------------------------------------ |
| `void close()`                           | 关闭此输出流并释放与此流有关的所有系统资源                   |
| `void flush()`                           | 刷新此输出流并强制写出所有缓冲的输出字节                     |
| `void write(byte[] b)`                   | 将 `b.length` 个字节从指定的 byte 数组写入此输出流           |
| `void write(byte[] b, int off, int len)` | 将指定 byte 数组中从偏移量 `off` 开始的 `len` 个字节写入此输出流 |
| `abstract void write(int b)`             | 将指定的字节写入此输出流                                     |

- **实例：**

1. 创建一个`FileOutputStream`对象并向其中写入单个字节

```java
/*
	任意的文本编辑器（记事本，notepad++等）在打开文件的时候，都会查询编码表把字节转换为字符表示
	0-127：查询ASCII表
	其他：查询系统默认码表（中文系统GBK）【GBK中一个汉字是2个字节，UTF-8中一个汉字是3个字节】
*/

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

public class test {
    public static void main(String[] args) throws IOException {
        //1.创建一个FileOutputStream对象，构造方法中传递写入数据的目的地
        FileOutputStream fos = new FileOutputStream("src//com//chao//a,txt");	//相对路径
        //2.调用FileOutputStream对象中的方法write，把数据写入到文件中
        fos.write(97);
        fos.write(98);
        fos.write(99);
        //3.释放资源
        fos.close();
    }
}

​ a.txt文件：

abc

2. 创建一个FileOutputStream对象并向其中一次写入多个字节

/*
	public void write(byte[] b)：将b.length个字节从指定的字节数组写入此输出流
	一次写多个字节：
		如果写的第一个字节是正数（0-127），那么显示的时候会查询ASCII表
		如果写的第一个字节是负数，那第一个字节会和第二个字节组成一个中文显示，查询系统默认码表GBK
*/
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class test {
    public static void main(String[] args) throws IOException {
        //1.创建一个FileOutputStream对象，构造方法中传递写入数据的目的地
        FileOutputStream fos = new FileOutputStream("src//com//chao//a,txt");    //相对路径
        //2.调用FileOutputStream对象中的方法write，把数据写入到文件中
        byte[] bytes = {65, 66, 67, 68, 69};
        fos.write(bytes);
        /*
        	public void write(byte[] b,int off,int len)
        	off：数组的开始索引
        	len：写几个字节
        */
        fos.write(bytes,1,3);
        //3.释放资源
        fos.close();
    }
}

​ a.txt文件：

ABCDEBCD

3. 创建一个FileOutputStream对象并向其中写入字符

/*
	写入字符的方法：可以使用String类中的方法把字符串转换为字节数组
	byte[] getBytes() 把字符串转换为字节数组
*/

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;

public class test {
    public static void main(String[] args) throws IOException {
        //1.创建一个FileOutputStream对象，构造方法中传递写入数据的目的地
        FileOutputStream fos = new FileOutputStream("src//com//chao//a,txt");    //相对路径
        //2.调用FileOutputStream对象中的方法write，把数据写入到文件中
        byte[] bytes="你好".getBytes();
        System.out.println(Arrays.toString(bytes));		//[-28, -67, -96, -27, -91, -67]
        fos.write(bytes);
        fos.write("牛逼".getBytes());
        //3.释放资源
        fos.close();
    }
}

​ a.txt文件：

你好牛逼

4. 在文件后面追加内容

/*
	追加/续写：使用两个参数的构造方法：
		FileOutputStream(String name, boolean append)	创建一个向具有指定名称的文件中写入数据的输出文件流
		FileOutputStream(File file, boolean append)		创建一个向指定File对象表示的文件中写入数据的文件输出流	
	参数：
		String name,File file：写入数据的目的地
		boolean append：追加写开关
			true：创建对象不会覆盖原文件，继续在文件末尾追加写数据
			false（默认）：创建一个新文件，覆盖原文件
*/
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;

public class test {
    public static void main(String[] args) throws IOException {
        //1.创建一个FileOutputStream对象，构造方法中传递写入数据的目的地
        FileOutputStream fos = new FileOutputStream("src//com//chao//a,txt",true);    //相对路径
        //2.调用FileOutputStream对象中的方法write，把数据写入到文件中
        fos.write("针不戳".getBytes());
        //3.释放资源
        fos.close();
    }
}

​ a.txt文件：

你好牛逼针不戳

5. 写换行

/*
	windows:\\r\\n
	linux:/n
	mac:/r
*/
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;

public class test {
    public static void main(String[] args) throws IOException {
        //1.创建一个FileOutputStream对象，构造方法中传递写入数据的目的地
        FileOutputStream fos = new FileOutputStream("src//com//chao//a,txt");    //相对路径
        //2.调用FileOutputStream对象中的方法write，把数据写入到文件中
        fos.write("我无敌\\n".getBytes());
        fos.write("你随意".getBytes());
        //3.释放资源
        fos.close();
    }
}

​ a.txt文件：

我无敌
你随意

三、字节输入流【InputStream】

• 需要的包文件：java.io.IntputStream
• 构造方法：

FileInputStream(String name)	创建一个向具有指定名称的文件中写入数据的输入文件流
FileInputStream(File file)		创建一个向指定File对象表示的文件中写入数据的文件输入流

• 方法摘要：

方法名	功能
void available	返回此输入流下一个方法调用可以不受阻塞地从此输入流读取（或跳过）的估计字节数
void close()	关闭此输入流并释放与该流关联的所有系统资源
void mark(int readlimit)	在此输入流中标记当前的位置
boolean markSupported()	测试此输入流是否支持 mark 和 reset 方法
abstract int read()	从输入流中读取数据的下一个字节
int read(byte[] b)	从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中
int read(byte[] b, int off, int len)	将输入流中最多 len 个数据字节读入 byte 数组
void reset()	将此流重新定位到最后一次对此输入流调用 mark 方法时的位置
long skip(long n)	跳过和丢弃此输入流中数据的 n 个字节

• 实例：

1. 创建一个FileInputStream对象，使用read读取单个字节

/*
	int read()读取文件中的一个字节并返回，读取到文件的末尾返回-1
*/
import java.io.FileInputStream;
import java.io.IOException;

public class test {
    public static void main(String[] args) throws IOException {
        //1.创建一个FileInputStream对象，构造方法中绑定要读取的数据源
        FileInputStream fis = new FileInputStream("src//com//chao//a,txt");    //相对路径
        //2.调用FileInputStream对象中的方法read读取文件
        int len=fis.read();
        System.out.println(len);	//65（A）
        
        int len=fis.read();
        System.out.println(len);	//66（B）
        
        int len=fis.read();
        System.out.println(len);	//67（C）
        //3.释放资源
        fis.close();
    }
}

​ 输出：

65
66
67

​ a.txt文件：

ABC

2. 创建一个FileInputStream对象，使用read循环读取字节

/*
	不知道文件中有多少个字节，可以使用循环优化
	while循环结束条件：读取到-1的时候停止
*/

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

public class test {
    public static void main(String[] args) throws IOException {
        //1.创建一个FileInputStream对象，构造方法中绑定要读取的数据源
        FileInputStream fis = new FileInputStream("src//com//chao//a,txt");    //相对路径
        //2.调用FileInputStream对象中的方法read读取文件
        int len = 0;
        while ((len = fis.read()) != -1) {
            System.out.println(len);
        }
        //3.释放资源
        fis.close();
    }
}

​ 输出：

65
66
67

​ a.txt文件：

ABC

3. 创建一个FileInputStream对象，使用read一次读取多个字节

/*
	字节输入流一次读取多个字节的方法：
		int read(byte[] b)从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中
*/
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Arrays;

public class test {
    public static void main(String[] args) throws IOException {
        //1.创建一个FileInputStream对象，构造方法中绑定要读取的数据源
        FileInputStream fis = new FileInputStream("src//com//chao//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));
        //3.释放资源
        fis.close();
    }
}

​ 输出：

2
[65, 66]
AB

​ a.txt文件：

ABC

4. 创建一个FileInputStream对象，使用read一次读取所有字节

/*
	字节输入流一次读取多个字节的方法：
		int read(byte[] b)从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中
	方法的参数byte[]的作用：起缓冲作用，存储读取到的多个字节
	数组的长度一般定义为1024（1kb）或整数倍
	方法的返回值int是每次读取的有效字节个数
*/
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Arrays;

public class test {
    public static void main(String[] args) throws IOException {
        //1.创建一个FileInputStream对象，构造方法中绑定要读取的数据源
        FileInputStream fis = new FileInputStream("src//com//chao//a,txt");    //相对路径
        //2.调用FileInputStream对象中的方法read读取文件
        byte[] bytes = new byte[1024];
        int len = 0;
        while ((len = fis.read(bytes)) != -1) {
            System.out.println(new String(bytes, 0, len));
        }
        //3.释放资源
        fis.close();
    }
}

​ 输出：

ABC

​ a.txt文件：

ABC

四、练习

题目：将文件c:\\\\p1.jpg复制到路径d:\\\\中去

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

public class test {
    public static void main(String[] args) throws IOException {
        //1.创建一个FileInputStream对象，构造方法中绑定要读取的数据源
        FileInputStream fis = new FileInputStream("c:\\\\p1.jpg");
        //2.创建一个FileOutputStream对象，构造方法中绑定要写入的目的地
        FileOutputStream fos = new FileOutputStream("d:\\\\p2.jpg");    //相对路径
        //3.复制
        byte[] bytes = new byte[1024];
        int len = 0;
        while ((len = fis.read(bytes)) != -1) {
            fos.write(bytes, 0, len);
        }
        //3.释放资源(先关闭写的，后关闭读的)
        fos.close();
        fis.close();
    }
}