IO 스트림:
I: 입력, 입력, 메모리에 읽기
O: 출력, 출력, 파일에 쓰기
스트림: 데이터 스트림(문자, 바이트)
카테고리:
흐름 방향:
입력: 바이트 입력 스트림(FileInputStream), 문자 입력 스트림(FileReader)
출력: 바이트 출력 스트림(FileOutputStream), 문자 입력 스트림(FileWriter)
유형:
문자, 바이트
java.io.OutputStream: 바이트 출력 스트림은 모든 바이트 출력 스트림의 상위 클래스
공용 멤버 메소드:
abstract void write(int b)는 바이트를 씁니다
void write(byte[] b)는 바이트 배열을 씁니다
void write(byte[] b, int off, int len)은 바이트 배열을 쓰고, off는 시작 인덱스이며, 여러 len을 씁니다.
void close()는 이 출력 스트림을 닫고 이 스트림과 관련된 모든 시스템 리소스를 해제합니다.
java.io.FileOutputStream: 파일 바이트 출력 스트림
기능: 메모리에 있는 데이터를 바이트 형태로 파일에 씁니다.
구성 방법:
FileOutputStream(파일 파일) 지정된 A 파일에 파일을 생성합니다. File 객체가 나타내는 파일에 데이터를 쓰기 위한 출력 스트림입니다.
FileOutputStream(String name) 지정된 이름을 가진 파일에 데이터를 쓰는 출력 파일 스트림을 생성합니다.
구성 방법의 매개변수:
파일: 파일
이름: 파일의 경로
는 모두 데이터를 쓰는 대상입니다.
특징 :
구성 방법에 지정된 파일 또는 경로가 가리키는 파일이 파일이 없으면 생성 방법에 따라 파일이 생성됩니다
추가 쓰기 스위치가 켜지지 않고 파일이 이미 존재하는 경우 덮어쓰게 됩니다
사용 단계:
1. 바이트 출력 스트림을 만듭니다. FileOutputStream 객체 및 데이터 대상 바인딩
2. FileOutputStream의 write 메소드를 사용하여 파일에 데이터 쓰기
3. 리소스 해제
스트림이 데이터를 쓸 때 JVM을 찾고 JVM은 시스템의 로컬을 호출합니다. 스트림을 사용한 후 시스템 관련 리소스를 사용하려면(메모리 해제)
void write(byte[] b) 바이트 배열을 씁니다
void write(byte[] b, int off, int len) 바이트 배열을 씁니다. 끄는 것이 시작입니다. 인덱스의 경우 len
1 public static void main(String[] args) throws IOException { 2 File file = new File("b.txt"); 3 FileOutputStream fos = new FileOutputStream(file); 4 //写入100到文件中,100是3个字节 5 fos.write(49); 6 fos.write(48); 7 fos.write(48); 8 9 /*10 * void write(byte[] b) 写入字节数组11 * 写入数据的时候,如果一次写多个字节12 * 写入的字节是正数:会查询ASC||表13 * 写入的字节是,第一个字节是负数,第二个字节可以是正数,也可以是负数,查询的时候就会把两个字节组成一个中文,查询GBK编码表14 */15 byte[] bytes = {65,66,67,68,69};//ABCDE16 //byte[] bytes = {-65,-66,-67,68,88};//烤紻17 18 fos.write(bytes);19 20 //void write(byte[] b, int off, int len) 写入字节数组,off是开始的索引,len写几个21 fos.write(bytes, 1, 2);22 23 /*24 * 快速写入字节数组的方法25 * String类中有一个方法26 * byte[] getBytes(String charsetName) :把字符串转换为字节数组
27 */28 byte[] bytes2 = "你好".getBytes();29 System.out.println(Arrays.toString(bytes2));//[-60, -29, -70, -61]30 fos.write(bytes2);31 32 fos.close();33 }void write(byte[] b) 写入字节数组
写入数据的时候,如果一次写多个字节
写入的字节是正数:会查询ASC||表
写入的字节是,第一个字节是负数,第二个字节可以是正数,也可以是负数,查询的时候就会把两个字节组成一个中文,查询GBK编码表
快速写入字节数组的方法
String类中有一个方法
byte[] getBytes(String charsetName) :把字符串转换为字节数组
文件的续写和换行:
换行:
windows:\r\n
linux:\n
mac:\r
追加写:使用两个参数的构造方法
FileOutputStream(File file, boolean append)
FileOutputStream(String name, boolean append)
参数:
File file,String name:写入数据的目的地
boolean append:追加写的开关,true:可以追加写(往之前的文件,继续写内容),fasle:不能追加写(覆盖之前的文件)
java.io.InputStream:字节输入流,是所有字节输入流的父类
公共的成员方法:
int read():读取一个字节并返回，没有字节返回-1.
int read(byte[]): 读取一定量的字节数，并存储到字节数组中，返回读取到的字节数。
void close() 关闭此文件输入流并释放与此流有关的所有系统资源。
java.io.FileInputStream:文件字节输入流
作用:把文件中的数据,以字节的方式读取到内存中
构造方法:
FileInputStream(String name)
FileInputStream(File file)
参数:读取的哪个文件(数据源)
String name:字符串的文件路径
File file:读取的文件
使用步骤:
1.创建字节输入流对象FileInputStream,并且绑定数据源
2.使用FileInputStream对象中的方法read,读取文件
3.释放资源
int read(byte[]): 读取一定量的字节数，并存储到字节数组中，返回读取到的字节数。
明确:
1.byte数组的作用:起到缓冲作用,一次可以往数组中缓冲多个字节,可以提高读取效率
byte数组的长度:一般定义为1024(一kb字节)或者1024的整数倍
2.返回值int是什么:每次读取的有效字节个数
文件的复制:读取文件采用一次读取一个字节的方式,写入文件采用一次写一个字节的方式
数据源:c:\\1.jpg
数据目的地:d:\\1.jpg
操作步骤:
1.创建字节输入流对象FileInputStream,并且绑定数据源
2.创建字节输出流对象FileOutputStream,并且绑定数据目的地
3.使用FileInputStream中的方法read,一次读取一个字节
4.使用FileOutputStream中的方法write,一次写一个字节
5.释放资源(先关写,后关读)
1 public static void main(String[] args) throws IOException { 2 long s = System.currentTimeMillis(); 3 //1.创建字节输入流对象FileInputStream,并且绑定数据源 4 FileInputStream fis = new FileInputStream("c:\\1.jpg"); 5 //2.创建字节输出流对象FileOutputStream,并且绑定数据目的地 6 FileOutputStream fos = new FileOutputStream("d:\\1.jpg"); 7 //3.使用FileInputStream中的方法read,一次读取一个字节 8 int len = 0;//接收读取到的字节 9 while((len = fis.read())!=-1){10 //4.使用FileOutputStream中的方法write,一次写一个字节11 fos.write(len);12 }13 //5.释放资源(先关写,后关读)14 fos.close();15 fis.close();16 long e = System.currentTimeMillis();17 System.out.println(e-s);18 }文件的复制:读取文件采用字节数组缓冲读取,写入数据一次写入多个字节
*
* 数据源:c:\\1.jpg
* 数据目的地:d:\\1.jpg
*
* 操作步骤:
* 1.创建字节输入流对象FileInputStream,并且绑定数据源
* 2.创建字节输出流对象FileOutputStream,并且绑定数据目的地
* 3.使用FileInputStream中的方法read(byte[]),一次读取多个字节
* 4.使用FileOutputStream中的方法write(byte[],0,len),一次写多个字节
* 5.释放资源
1 public static void main(String[] args) throws Exception { 2 long s = System.currentTimeMillis(); 3 //1.创建字节输入流对象FileInputStream,并且绑定数据源 4 FileInputStream fis = new FileInputStream("c:\\z.zip"); 5 //2.创建字节输出流对象FileOutputStream,并且绑定数据目的地 6 FileOutputStream fos = new FileOutputStream("d:\\z.zip"); 7 //3.使用FileInputStream中的方法read(byte[]),一次读取多个字节 8 byte[] bytes = new byte[1024*100]; 9 int len = 0;//读取的字节有效个数10 while((len = fis.read(bytes))!=-1){11 //4.使用FileOutputStream中的方法write(byte[],0,len),一次写多个字节12 fos.write(bytes, 0, len);13 }14 //5.释放资源15 fos.close();16 fis.close();17 18 long e = new Date().getTime();19 System.out.println(e-s);20 }文件的复制:读取文件使用缓冲流+数组,写入数据使用缓冲流一次写入多个
*
* 数据源:c:\\1.jpg
* 数据目的地:d:\\1.jpg
*
* 操作步骤:
* 1.创建FileInputStream对象,绑定数据源
* 2.创建BufferedInputStream对象,构造方法中传入FileInputStream,提高FileInputStream的读取效率
* 3.创建FileOutputStream对象,绑定数据目的地
* 4.创建BufferedOutputStream对象,构造方法中传递FileOutputStream,提高FileOutputStream效率
* 5.使用BufferedInputStream中的方法read(byte[]),读取文件
* 6.使用BufferedOutputStream中的方法write(byte[],0,len),写入数据到缓冲区
* 7.使用BufferedOutputStream中的方法flush把缓冲区的数据,刷新到文件中
* 8.释放资源
1 public static void main(String[] args) throws Exception { 2 long s = System.currentTimeMillis(); 3 //1.创建FileInputStream对象,绑定数据源 4 FileInputStream fis = new FileInputStream("c:\\z.zip"); 5 //2.创建BufferedInputStream对象,构造方法中传入FileInputStream 6 BufferedInputStream bis = new BufferedInputStream(fis); 7 //3.创建FileOutputStream对象,绑定数据目的地 8 FileOutputStream fos = new FileOutputStream("d:\\z.zip"); 9 //4.创建BufferedOutputStream对象,构造方法中传递FileOutputStream,提高FileOutputStream效率10 BufferedOutputStream bos = new BufferedOutputStream(fos);11 //5.使用BufferedInputStream中的方法read(byte[]),读取文件12 /*int len = 0;13 while((len = bis.read())!=-1){14 //6.使用BufferedOutputStream中的方法write(byte[],0,len),写入数据到缓冲区15 bos.write(len);16 }*/17 byte[] bytes = new byte[1024*100];18 int len = 0;19 while((len = bis.read(bytes))!=-1){20 fos.write(bytes, 0, len);21 fos.flush();22 }23 24 //8.释放资源25 bos.close();26 bis.close();27 28 long e = new Date().getTime();29 System.out.println(e-s);30 }java.io.BufferedOutputStream:字节缓冲输出流 extends OutputStream
* 字节缓冲输出流作用:给基本流增加一个缓冲区,提高基本流的效率
*
* 继承自父类的公共的成员方法
* abstract void write(int b) 写入一个字节
* void write(byte[] b) 写入字节数组
* void write(byte[] b, int off, int len) 写入字节数组,off是开始的索引,len写几个
* void close() 关闭此输出流并释放与此流有关的所有系统资源。
*
* 构造方法:
* BufferedOutputStream(OutputStream out) 创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
* 参数:
* OutputStream out:字节输出流,可以使用FileOutputStream
* 参数传递时哪个字节输出流,就会给哪个字节输出流增加一个缓冲区,提高这个流的效率
* 使用步骤:
* 1.创建FileOutputStream对象,绑定数据目的地
* 2.创建BufferedOutputStream对象,构造方法中传递FileOutputStream,提高FileOutputStream效率
* 3.使用BufferedOutputStream中的方法write,把数据写入到缓冲区中
* 4.使用BufferedOutputStream中的方法flush,把缓冲区中的数据,刷新到文件中
* 5.释放资源
1 public static void main(String[] args) throws IOException { 2 //1.创建FileOutputStream对象,绑定数据目的地 3 FileOutputStream fos = new FileOutputStream("buffered.txt"); 4 //2.创建BufferedOutputStream对象,构造方法中传递FileOutputStream 5 BufferedOutputStream bos = new BufferedOutputStream(fos); 6 //3.使用BufferedOutputStream中的方法write,把数据写入到缓冲区中 7 bos.write(97); 8 9 bos.write("我是缓冲流".getBytes());10 //4.使用BufferedOutputStream中的方法flush,把缓冲区中的数据,刷新到文件中11 bos.flush();12 //5.释放资源13 bos.close();14 }java.io.BufferedInputStream:字节缓冲输入流 extends InputStream
* 作用:给基本字节输入流增加一个缓冲区,提高基本字节输入流的效率
*
* 继承自父类的公共发的成员方法:
* int read():读取一个字节并返回，没有字节返回-1.
* int read(byte[]): 读取一定量的字节数，并存储到字节数组中，返回读取到的字节数。
* void close() 关闭此文件输入流并释放与此流有关的所有系统资源。
*
* 构造方法:
* BufferedInputStream(InputStream in) 创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
* 参数:
* InputStream in:字节输入流,可以传递FileInputStream
* 参数传递的是哪个字节输入流对象,就会给哪个字节输入流对象增加一个缓冲区,提高该流的效率
*
* 使用步骤:
* 1.创建FileInputStream对象,绑定数据源
* 2.创建BufferedInputStream对象,构造方法中传入FileInputStream,提高FileInputStream的读取效率
* 3.使用BufferedInputStream中的方法read,读取文件
* 4.释放资源
*
* 总结:
* 字节流:操作的文件是非文本文件,文件的复制
* 字符流:操作的文件都是文本文件,一次读取一个字符,可以读取中文
* 文本文件:使用记事本打开,能看懂
1 public static void main(String[] args) throws IOException { 2 //1.创建FileInputStream对象,绑定数据源 3 FileInputStream fis = new FileInputStream("buffered.txt"); 4 //2.创建BufferedInputStream对象,构造方法中传入FileInputStream 5 BufferedInputStream bis = new BufferedInputStream(fis); 6 //3.使用BufferedInputStream中的方法read,读取文件 7 //int read():读取一个字节并返回，没有字节返回-1. 8 /*int len = 0; 9 while((len = bis.read())!=-1){10 System.out.println((char)len);11 }*/12 13 //int read(byte[]): 读取一定量的字节数，并存储到字节数组中，返回读取到的字节数。14 byte[] bytes = new byte[1024];15 int len = 0;16 while((len = bis.read(bytes))!=-1){17 System.out.println(new String(bytes,0,len));
18 }19 20 //4.释放资源21 bis.close();22 System.out.println("-------------------");23 BufferedReader br = new BufferedReader(new FileReader("buffered.txt"));24 while((len = br.read())!=-1){25 System.out.println((char)len);26 }27 }复制单层文件夹
*
* 数据源:c:\\demo
* 数据目的地:d:\\
*
* 操作流程:
* 1.判断d盘有没有demo文件夹,没有则创建
* 2.创建一个复制文件的方法
* 返回值类型:void
* 方法名:copyFile
* 参数列表:File src,File dest
* 3.遍历要复制的文件夹,获取文件夹中的每一个文件的路径(要复制文件的数据源)
* 4.使用file类中的方法getName拼接要复制文件的数据目的
* 5.调用copyFile复制的方法进行复制
1 public static void main(String[] args) throws IOException { 2 //1.判断d盘有没有demo文件夹,没有则创建 3 File file = new File("d:\\demo"); 4 if(!file.exists()){ 5 file.mkdirs(); 6 } 7 //3.遍历要复制的文件夹,获取文件夹中的每一个文件的路径(要复制文件的数据源) 8 File srcDirectory = new File("c:\\demo"); 9 File[] srcFiles = srcDirectory.listFiles();10 for (File srcFile : srcFiles) {11 //4.使用file类中的方法getName拼接要复制文件的数据目的12 String srcName = srcFile.getName();13 //使用File类的第三个构造方法创建目的地14 File destFile = new File(file, srcName);15 //5.调用copyFile复制的方法进行复制16 copyFile(srcFile, destFile);17 }18 }
위 내용은 IO 스트림의 예에 대한 자세한 설명의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!
![[웹 프런트엔드] Node.js 빠른 시작](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
