新手小白学JAVA IO流 File 字节流字符流

Posted 2021-05-21 程序媛泡泡

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了新手小白学JAVA IO流 File 字节流字符流相关的知识，希望对你有一定的参考价值。

IO简介

1 流Stream

在学习IO流之前,我们首先需要学习的概念就是Stream流
为了方便理解,我们可以把数据的读写操作抽象成数据在"管道"中流动,但需注意:
1.流只能单方向流动
2.输入流用来读取 → in
3.输出流用来写出 → out
4.数据只能从头到尾顺序的读写一次
所以以程序的角度来思考,In/out 相对于程序而言的输入(读取)/输出(写出)的过程.
在这里插入图片描述

2 IO流的继承结构

在java中,根据处理的数据单位不同,可以把流分为字节流和字符流
字节流 : 针对二进制文件
字符流 : 针对文本文件,读写容易出现乱码的现象,在读写时,最好指定编码集为UTF-8
在结合对应类型的输入和输出方向,常用的流有:

File

字节流:针对二进制文件

InputStream

FileInputStream

BufferedInputStream

ObjectInputStream

OutputStream

FileOutputStream

BufferedOutputStream

ObjectOutputStream

字符流:针对文本文件

Reader

FileReader

BufferedReader

InputStreamReader

Writer

FileWriter

BufferedWriter

OutputStreamWriter

PrintWriter一行行写出

3 File文件流

3.1概述

封装一个磁盘路径字符串,对这个路径可以执行一次操作
可以封装文件路径、文件夹路径、不存在的路径

3.2创建对象

File(String pathname)通过将给定路径名字符串转换为抽象路径名来创建一个新的File实例
new File(“d:/abc/a.txt”);
new File(“d:/abc”,”a.txt”);

3.3常用方法

在这里插入图片描述

3.4 练习：测试常用方法

创建包: cn.tedu.file
创建类: TestFile.java

package cn.tedu.file;

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

/*本类用来测试文件类 File*/
public class TestFile {
    public static void main(String[] args) throws IOException {
        //1.创建File文件对象
        /*1.构造函数的参数是String类型的pathname(路径名)
        * 这个路径可以是文件路径,也可以是文件夹路径*/
        /*2.\\在代码中有特殊的意义,所以想要真正表示这是一个\\,需要用\\进行转义*/
        //注意:此处需要自己手动在D盘创建对应目录下的1.txt,并添加内容
        //注意:创建1.txt时,需要设置系统显示文件后缀名,如果没设置,文件名应该是1
        //注意:File需要导包:import java.io.File;
        File file = new File("D:\\\\ready\\\\1.txt");

        //2.测试常用方法
        //2.1文件与文件夹属性测试
        System.out.println(file.length());//12,获取指定文件的字节量大小
        System.out.println(file.exists());//true,判断指定文件是否存在
        System.out.println(file.isFile());//true,判断指定内容是否为文件
        System.out.println(file.isDirectory());//false,判断指定内容是否为文件夹
        System.out.println(file.getName());//1.txt,获取指定内容的名字
        System.out.println(file.getParent());//D:\\ready,获取指定内容的上级
        System.out.println(file.getAbsolutePath());//D:\\ready\\1.txt,获取指定内容的绝对路径

        //2.2创建与删除
        file = new File("D:\\\\ready\\\\2.txt");
        /*如果指定创建文件的文件夹不存在,会报错:java.io.IOException
        * 系统找不到指定的路径,由于可能会发生异常,所以调用时需要抛出异常 */
        //在windows中创建不存在的文件2.txt,成功返回true
        System.out.println(file.createNewFile());//true

        file = new File("D:\\\\ready\\\\m");
        System.out.println(file.mkdir());//true,创建不存在的单层文件夹m
        file = new File("D:\\\\ready\\\\a\\\\b\\\\c");
        System.out.println(file.mkdirs());//true,创建不存在的多层文件夹a/b/c

        System.out.println(file.delete());//c被删除,删除文件或者空文件夹
        file  = new File("D:\\\\ready\\\\a");
        System.out.println(file.delete());//false,因为a目录里还有b目录
        file  = new File("D:\\\\ready\\\\2.txt");
        System.out.println(file.delete());//true,删除2.txt文件成功

        //2.3 文件列表测试
        file = new File("D:\\\\ready");
        String[] listName = file.list();
        System.out.println(Arrays.toString(listName));

        File[] fs = file.listFiles();
        System.out.println(Arrays.toString(fs));
        System.out.println(fs[0].length());

    }
}

4 字节流读取

字节流是由字节组成的,字符流是由字符组成的.
Java里字符由两个字节组成.字节流是基本，主要用在处理二进制数据。
流式传输主要指将整个音频和视频及三维媒体等多媒体文件经过特定的压缩方式解析成一个个压缩包，由视频服务器向用户计算机顺序或实时传送。在采用流式传输方式的系统中，用户不必像采用下载方式那样等到整个文件全部下载完毕，而是只需经过几秒或几十秒的启动延时即可在用户的计算机上利用解压设备对压缩的A/V、3D等多媒体文件解压后进行播放和观看。此时多媒体文件的剩余部分将在后台的服务器内继续下载。

4.1 InputStream抽象类

此抽象类是表示字节输入流的所有类的超类/抽象类,不可创建对象哦

常用方法：
abstract int read() 从输入流中读取数据的下一个字节
int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中
int read(byte[] b, int off, int len) 将输入流中最多 len 个数据字节读入 byte 数组,off表示存时的偏移量
void close() 关闭此输入流并释放与该流关联的所有系统资源

4.2 FileInputStream子类

直接插在文件上，直接读取文件数据

创建对象
FileInputStream(File file)—直接传文件对象
通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定FileInputStream(String pathname)—传路径
通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定

4.3 BufferedInputStream子类

BufferedInputStream 为另一个输入流添加一些功能，即缓冲输入以及支持 mark 和 reset 方法的能力。在创建 BufferedInputStream 时，会创建一个内部缓冲区数组(默认8k大小)。在读取或跳过流中的字节时，可根据需要从包含的输入流再次填充该内部缓冲区，一次填充多个字节。

创建对象
BufferedInputStream(InputStream in)
创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。

4.4 练习：字节流读取案例

创建包: cn.tedu.file
创建类: TestIn.java

package cn.tedu.file;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

/**本类用于测试文件的读取 D:\\\\ready\\\\1.txt*/
public class TestIn {
	public static void main(String[] args) {
		//method();//字节流的读取
		method2();//高效字节流的读取
	}
	public static void method2() {
		try {
			//1.创建高效字节流的读取对象
			//BufferedInputStream是高效的读取流,原因在于底层维护了一个byte[]
			//InputStream in = new BufferedInputStream(new FileInputStream(new File("D:\\\\ready\\\\1.txt")));
			InputStream in = new BufferedInputStream(new FileInputStream("D:\\\\ready\\\\1.txt"));
			//2.开始读取,read()每次读取一个字节,如果读取到了数据的末尾,返回-1
//			System.out.println( in.read() );//97
//			System.out.println( in.read() );//98
//			System.out.println( in.read() );//99
//			System.out.println( in.read() );//-1
//			System.out.println( in.read() );//-1
			
			//3.开始读取,read()每次读取一个字节,所以我们现在需要重复的读取读取文件中的所有字节
			//3.1定义变量,记录读到的数据
			int b ;
			//3.2开始循环,直到没有内容,结束循环
			while((b=in.read())!=-1) {
				System.out.println(b);
			}
			
			//4.释放资源
			in.close();
			
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public static void method() {
		try {
			//1.创建字节流的读取对象
			//InputStream in = new InputStream();//报错:原因:InputStream是字节流读取的父类,而且是抽象类,不能new
			//InputStream in = new FileInputStream(new File("D:\\\\ready\\\\1.txt"));//传入的是File对象
			InputStream in = new FileInputStream("D:\\\\ready\\\\1.txt");//传入的是路径
			
			//2.开始读取,read()每次读取一个字节,如果读取到了数据的末尾,返回-1
//			System.out.println( in.read() );//97
//			System.out.println( in.read() );//98
//			System.out.println( in.read() );//99
//			System.out.println( in.read() );//-1
//			System.out.println( in.read() );//-1
			
			//3.需求:重复的读取文件中的所有字节
			int b ;//3.1定义变量,记录读到的数据
			while((b = in.read()) != -1) {//3.2返回值为-1的时候,表示没有数据了,循环结束
				System.out.println(b);//3.3打印每次循环读取到的内容
			}
			
			//4.释放资源
			in.close();
			
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

5 字符流读取

常用于处理纯文本数据

5.1 Reader抽象类

用于读取字符流的抽象类。

常用方法：
int read() 读取单个字符
int read(char[] cbuf) 将字符读入数组
abstract int read(char[] cbuf, int off, int len) 将字符读入数组的某一部分
int read(CharBuffer target) 试图将字符读入指定的字符缓冲区
abstract void close() 关闭该流并释放与之关联的所有资源

5.2 FileReader子类

用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。要自己指定这些值，可以先在 FileInputStream 上构造一个 InputStreamReader。

创建对象
FileReader(String fileName) 在给定从中读取数据的文件名的情况下创建一个新 FileReader
FileReader(File file) 在给定从中读取数据的 File 的情况下创建一个新 FileReader

5.3 BufferedReader子类

从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。

创建对象
BufferedReader(Reader in) 创建一个使用默认大小输入缓冲区的缓冲字符输入流

5.4 练习：字符流读取案例

创建包: cn.tedu.file
创建类: TestIn2.java

package cn.tedu.file;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

/**本类用于测试字符流读取*/
public class TestIn2 {
	public static void main(String[] args) {
		//method();//普通字符流读取
		method2();//高效字符流读取
	}

	public static void method() {
		try {
			//1.创建字符流的读取对象
			//Reader in = new Reader();//Reader是字符流读取的父类,而且是一个抽象类,不能new
			//Reader in = new FileReader(new File("D:\\\\ready\\\\1.txt"));//传入的是file对象
			Reader in = new FileReader("D:\\\\ready\\\\1.txt");//传入的是路径
			
			//2.开始读取,read()每次读取一个字符,如果读取到了数据的末尾,返回-1
//			System.out.println(in.read());//97
//			System.out.println(in.read());//98
//			System.out.println(in.read());//99
//			System.out.println(in.read());//100
//			System.out.println(in.read());//-1
			
			//3.需求:重复的读取文件中的所有内容
			//3.1定义变量,记录读取到的数据
			int b;
			//3.2循环读取文件中所有内容,只要不是-1,就表示还有数据,继续循环
			while( (b = in.read()) != -1) {
				System.out.println(b);
			}
			//4.释放资源
			in.close();
			
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public static void method2() {
		try {
			//1.创建高效的字符流的读取对象
			//Reader in = new Reader();//Reader是字符流读取的父类,而且是一个抽象类,不能new
			//BufferedReader是高效的字符读取流,原因是底层维护了一个char[],默认的容量也是8*1024字节8k
			Reader in = new BufferedReader(new FileReader("D:\\\\ready\\\\1.txt"));//传入的是路径
			
			//2.开始读取,read()每次读取一个字符,如果读取到了数据的末尾,返回-1
//			System.out.println(in.read());//97
//			System.out.println(in.read());//98
//			System.out.println(in.read());//99
//			System.out.println(in.read());//100
//			System.out.println(in.read());//-1
			
			//3.需求:重复的读取文件中的所有内容
			//3.1定义变量,记录读取到的数据
			int b;
			//3.2循环读取文件中所有内容,只要不是-1,就表示还有数据,继续循环
			while( (b = in.read()) != -1) {
				System.out.println(b);
			}
			//4.释放资源
			in.close();
			
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

6 字节流写出

6.1 OutputStream抽象类

此抽象类是表示输出字节流的所有类的超类.输出流接受输出字节并将这些字节发送到某个接收器.

常用方法:
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) 将指定的字节写入此输出流

6.2 FileOutputStream 子类

直接插在文件上,直接写出文件数据

构造方法(创建对象):
FileOutputStream(String name)
创建一个向具有指定名称的文件中写入数据的文件输出流
FileOutStream(File file)
创建一个向指定File对象表示的文件中写入数据的文件输出流
FileOutStream(File file,boolean append)—如果第二个参数为true,表示追加,不覆盖
创建一个向指定File对象表示的文件中写入数据的文件输出流,后面的参数是指是否覆盖原文件内容

6.3 BufferedOutputstream 子类

该类实现缓冲的输出流,通过设置这种输出流,应用程序就可以将各个字节写入底层输出流中,而不必每次针对字节写出调用底层系统

构造方法(创建对象):
BufferedOutputStream(OutputStream out)
创建一个新的缓冲输出流,用以将数据写入指定的底层输出流

6.4 练习: 字节输出流测试:

创建包: cn.tedu.out
创建类: TestOutputStream.java

package cn.tedu.out;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

/**本类用于测试字节输出流*/
public class TestOutputStream {
	public static void main(String[] args) {
		//method();//1.创建使用普通字节输出流对象输出数据
		method2();//2.创建使用高效字节输出流对象输出数据
	}
	public static void method2() {
		//5.声明在此方法内部都生效的局部变量,并且局部变量需要初始化,对象的默认值是null
		OutputStream out = null;
		try {
			//0.用来测试的路径必须是文件路径,不是文件夹路径,而且文件得存在
			//1.创建高效字节输出流对象
			//OutputStream out =new BufferedOutputStream(new FileOutputStream(new File("D:\\\\ready\\\\out.txt")));
			out =new BufferedOutputStream(new FileOutputStream("D:\\\\ready\\\\out.txt"));
			
			//2.开始写出数据
			out.write(100);//ascii码表存在对应关系:100-d
			out.write(100);//ascii码表存在对应关系:100-d
			out.write(100);//ascii码表存在对应关系:100-d
			out.write(100);//ascii码表存在对应关系:100-d

		} catch (IOException e) {
			e.printStackTrace();
		} finally {/**3.要保证代码一定会被执行,就通通放在finally代码块中*/
			//4.释放资源
			try {
				out.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	public static void method() {
		//4.声明在此方法内部都生效的局部变量,并且局部变量必须初始化,对象的默认值是null
		OutputStream out=null;
		try {
			//0.需要在windows环境下创建一个文件,路径:D:\\ready\\out.txt用来查看输出的数据
			/**注意:指定的路径是文件路径,不是文件夹路径,而且文件得存在*/
			//1.创建字节输出流对象
			//new OutputStream();//报错:原因:OutputStream是字节输出流的抽象父类,不能实例化
			//OutputStream out = new FileOutputStream(new File("D:\\\\ready\\\\out.txt"));
			out = new FileOutputStream("D:\\\\ready\\\\out.txt");
			
			//2.开始写出数据
			out.write(97);//ascii码表对应的关系:97--a
			out.write(98);//ascii码表对应的关系:98--b
			out.write(99);//ascii码表对应的关系:99--c
			
		} catch (IOException e) {
			e.printStackTrace();
		} finally {/**如果要保证代码一定会执行,就通通放在finally代码块中*/
			//3.释放资源
			try {
				out.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

7 字符流写出

7.1 Writer 抽象类

写入字符流的抽象类

常用方法:
Abstract void close() 关闭此流,但要先刷新它
Void write(char[ ] cbuf) 写入字符数组
Void write(int c) 写入单个字符
Void write(String str) 写入字符串
Void write(String str,int off,int len) 写入字符串的某一部分
Abstract void write(char[] cbuf,int off,int len)写入字符数组的某一部分

7.2 FileWriter 子类

用来写入字符文件的便捷类,此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的.如果需要自己自定义这些值,可以先在FileOutputStream上构造一个OutputStreamWriter.

构造方法(创建对象):
FileWriter(String filename)
根据给定的文件名构造一个FileWriter对象
FileWriter(String filename,boolean append)
根据给定的文件名以及指示是否附加写入数据的boolean值来构造FileWriter

7.3 BufferedWriter子类

将文本写入字符输出流,缓冲各个字符,从而提供单个字符,数组和字符串的高效写入.可以指定缓冲区的大小,或者接受默认的大小,在大多数情况下,默认值就足够大了

构造方法(创建对象):
BufferedWriter(Writer out)
创建一个使用默认大小输出缓冲区的缓冲字符输出流

7.4 练习: 字符输出流测试:

创建包: cn.tedu.out
创建类: TestWriter.java

package cn.tedu.out;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

/**本类用于测试字符输出流*/
public class TestWriter {
	public static void main(String[] args) {
		method1();//普通字符输出流
		method2();//高效字符输出流
	}

	/**高效字符输出流*/
	public static void method2() {
		Writer out = null;
		try {
			//1.创建高效字符输出流对象,并且数据输出的方式是追加
			//默认状态是不追加,也就是覆盖原有数据
			//out2 = new BufferedWriter(new FileWriter(new File("D:\\\\ready\\\\out.txt")));
	out = new BufferedWriter(new FileWriter("D:\\\\ready\\\\out.txt",true));
			//2.输出数据
			out.write(97);
			out.write("hello");
			out.write("io");
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			//3.释放资源
			try {
				out.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	/**普通字符输出流*/
	public static void method1() {
		Writer out = null;
		try {
			//0.在路径D:\\\\ready\\\\out.txt下创建对应的文件.查看输出的数据
			//1.创建流对象
			//new Writer();//报错:Writer是抽象父类,不可以创建对象
			//Writer out2 = new FileWriter(new File("D:\\\\ready\\\\out.txt"));
			//out = new FileWriter("D:\\\\ready\\\\out.txt");//默认覆盖
			/**需求:保持原有的数据
			 * 在不改变原数据的基础上,在它的末尾添加新数据*/
			/**
			 * 此构造函数的第二个参数表示,是否覆盖写出文件中的原有数据
			 * 默认覆盖,如果不想覆盖,就把这个参数的值设置为true
			 * */
			out = new FileWriter("D:\\\\ready\\\\out.txt",true);
			//2.输出数据
			out.write(97);
			out.write(98);
			out.write(99);
			out.write(100)java学习之字符流与字节流的转换
 io系列之字节流
 Java IO-file(读写查)字节流字符流
 JAVA零基础小白免费学习教程day16-字节流&字符流
 JAVA零基础小白免费学习教程day16-字节流&字符流
 JAVA学习之字节流字符流

新手小白学JAVA IO流 File 字节流 字符流

IO简介

1 流Stream

2 IO流的继承结构

File

字节流:针对二进制文件

InputStream

FileInputStream

BufferedInputStream

ObjectInputStream

OutputStream

FileOutputStream

BufferedOutputStream

ObjectOutputStream

字符流:针对文本文件

Reader

FileReader

BufferedReader

InputStreamReader

Writer

FileWriter

BufferedWriter

OutputStreamWriter

PrintWriter一行行写出