Java学习笔记——学习IO流

最新推荐文章于 2024-05-21 21:56:43 发布

black_wangyk

最新推荐文章于 2024-05-21 21:56:43 发布

阅读量219

点赞数

分类专栏： Java学习笔记文章标签： java

本文链接：https://blog.csdn.net/ThisisK/article/details/107649666

版权

Java学习笔记专栏收录该内容

25 篇文章 1 订阅

订阅专栏

输入 input ：输入到java程序
输出 output ：java程序输出

分类：
按照传输内容分：字节流、字符流
按照传输方向分：输入流、输出流

字节流

主要是传输字节（byte）数据，例如：音视频、图片等二进制文件

输入字节流

InputStream 是字节输入流的所有类的超类。是抽象类

FIleInputStream 是字节输入流的常用类

构造方法：

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

演示：

public void testConstructor() throws FileNotFoundException{
	//构造方法1 : 传入String类型的文件路径
	FileInputStream fis1 = new FileInputStream("E:/A/B2/a.txt");
	//构造方法2 ：传入File类型的文件对象参数
	FileInputStream fis2 = new FileInputStream(new File("E:/A/B2/a.txt"));
}

常用方法：
public int read([byte[] b[, int off, int len]]) throws IOException ：

无参数时，从此输入流中读取一个数据字节。
有参数b时，从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。
有全部参数时，从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。b - 存储读取数据的缓冲区；off - 目标数组 b 中的起始偏移量；len - 读取的最大字节数。

读取字节：

演示：

//读取一个字节
public void testInput() throws IOException {
	FileInputStream fis1 = new FileInputStream("E:/A/B2/a.txt");
	//读取一个字节
	int b1 = fis1.read();
	System.out.println((char)b1);
	//读取一个字节
	int b2 = fis1.read();
	System.out.println((char)b2);
	//读取一个字节
	int b3 = fis1.read();
	System.out.println((char)b3);
}
public void testInputPlus() throws IOException {
	FileInputStream fis1 = new FileInputStream("E:/A/B2/a.txt");
	try{
		while((int b = fis1.read()) != -1){
			System.out.print((char)b);
		}
	}finally{
		fis1.close();//关流
	}
}
//读取字节数组
public void testInputArray() throws IOException {
	FileInputStream fis1 = new FileInputStream("E:/A/B2/a.txt");
	//定义一个数组，长度是文件字节大小，如果长度小于字节大小时，每次读入数组长度
	byte[] arr = new byte[10];
	try{
		//int num = fis1.read(byte[] b);num是字节的个数
		while((int b = fis1.read(arr)) != -1){
			System.out.print("读入的字节个数为：" + b);
		}
		System.out.println(Array.toString(arr));
	}finally{
		fis1.close();//关流
	}
}
public void testInputArrayPlus() throws IOException {
	FileInputStream fis1 = new FileInputStream("E:/A/B2/a.txt");
	byte[] arr = new byte[3];
	try{
		while((int b = fis1.read(arr,0,arr.length)) != -1){
			System.out.print("读入的字节个数为：" + b);
		}
		System.out.println(Array.toString(arr));
	}finally{
		fis1.close();//关流
	}
}
public void testAvailable() throws IOException {
	FileInputStream fis1 = new FileInputStream("E:/A/B2/a.txt");
	int available = fis1 .available();//返回文件字节数
	System.out.println(available);
}

输出字节流

OutputStream 输出字节流,抽象类.
常用实现类 FileOutputStream 字节输出流.

构造方法：

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

注意：

OutputStream 创建对象时，如果没有该文件，会创建一个新的，然后再写入
如果构造方法不传第二个参数时，默认就是false，即不和该文件原来的内容拼接，会将原来的内容覆盖
如果构造方法指定append为true，会和该文件原来的内容拼接

public void testConstructor() throws FileNotFoundException{
	
	//构造方法1
	FileOutputStream fos1 = new FileOutputStream("E:/A/B2/a.txt",true);
	//构造方法2
	FileOutputStream fos2 = new FileOutputStream((new File("E:/A/B2/a.txt"));
}

常用方法：
public void write(int b || [byte[] b[, int off, int len]]) throws IOException ：

参数是“int b”时，将指定字节写入此文件输出流。
参数是“byte[] b”时，将 b.length 个字节从指定 byte 数组写入此文件输出流中。
参数是“byte[] b, int off, int len”时，将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。

public void addDate() throws Exception{
	FileOutputStream fos1 = new FileOutputStream("E:/A/B2/a.txt");
	//输出一个字节
	fos1.write(97);
	fos1.close();
}
public void addArray() throws Exception{
	FileOutputStream fos1 = new FileOutputStream("E:/A/B2/a.txt",true);
	byte[] bytes = {66,67,68,69,70};
	//输出一个数组内容的数据
	fos1.write(bytes);
	fos1.close();
}
public void addArrayPlus() throws Exception{
	FileOutputStream fos1 = new FileOutputStream("E:/A/B2/a.txt",true);
	byte[] bytes = {71,72,73,74,75};
	//输出一个数组内容的数据
	/**
	 *参数1 bytes   存储数据的数组
	 *参数2 偏移量  从数组的那个下标开始
	 *参数3 长度    读取数据的个数
	 */
	fos1.write(bytes,1,3);
	fos1.close();
}

缓冲字节输入流（BufferedInputStream）

在创建 BufferedInputStream 时，会创建一个内部缓冲区数组

public BufferedInputStream(InputStream in, int size) ：创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。创建一个长度为 size 的内部缓冲区数组并将其存储在 buf 中。可以不指定size，默认为8K。

public void test1() throws Exception{
	FileInputStream fis = new FileInputStream("E:/A/B2/a.txt");
	BufferedInputStream bis = new BufferedInputStream(fis);
	while((int b = bis.read())!=-1){
		System.out.println(b);
	}
	bis.close();
}

缓冲字节输出流（BufferedOutputStream）

public BufferedOutputStream(OutputStream out, int size) ：创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流。

public void flush() throws IOException ：刷新此缓冲的输出流。这迫使所有缓冲的输出字节被写出到底层输出流中。可以不指定size，默认为8K。

public void test1() throws Exception{
	FileOutputStream fos = new FileOutputStream("E:/A/B2/a.txt");
	BufferedOutputStream bos = new BufferedOutputStream(fis);
	while((int b = bos.read())!=-1){
		System.out.println(b);
	}
	fos.close();
	bos.close();
}

字符流

输入字符流

Reader抽象类，FileReader实现类

构造方法：

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

常用方法：

public abstract int read(char[] cbuf, int off, int len) throws IOException ：

无参数时，读取单个字符。。
有参数char[] cbuf时，将字符读入数组。
有全部参数时，将字符读入数组的某一部分。在某个输入可用、发生 I/O 错误或者到达流的末尾前，此方法一直阻塞。cbuf - 目标缓冲区；off - 开始存储字符处的偏移量；len - 要读取的最多字符数。

public void testRead() throws Exception{
	//输入字符流
	FileReader fr = new FileReader("E:/A/B2/a.txt");
	//读一个字符，返回值是int
	int read = fr.read();
	System.out.println(read);
	//连续多次，一次读取一个字符
	int b = 0;
	while((b = fr.read())!=-1){
		System.out.println((char)b);
	}
	
	fr.close();
}
public void testReadPlus() throws Exception{
	//输入字符流
	FileReader fr = new FileReader("E:/A/B2/a.txt");
	
	//一次读取字符数组长度的字符
	char[] chars = new char[];
	int b = 0;
	while((b = fr.read(chars))!=-1){
		System.out.println(chars);
	}
	
	fr.close();
}

输出字符流

Writer抽象类，FileWriter实现类

构造方法：

public FileWriter(File file[, boolean append]) throws IOException ：根据给定的 File 对象构造一个 FileWriter 对象。如果第二个参数为 true，则将字节写入文件末尾处，而不是写入文件开始处。第二个参数可以不写，默认为false。
public FileWriter(String fileName, boolean append) throws IOException ：根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象。如果第二个参数为 true，则将字节写入文件末尾处，而不是写入文件开始处。第二个参数可以不写，默认为false。

public void testWrite() throws Exception{
	//创建输出字符流
	FileWriter fw = new FileWriter("E:/A/B2/aa.txt");
	//输出单个字符
	fw.write('我');
	char[] chars = new char[]{'你','好','j','a','v','a'};
	//输出字符数组
	fw.write(chars);
	//输出字符串
	fw.write("你好，java！");
	//输出字符数组中指定内容
	fw.write(chars,2,4);
	//输出字符串中指定内容
	fw.write("你好，java！",2,6);
}

缓冲字符输入流（BufferedReader）

public BufferedReader(Reader in, int sz) ：创建一个使用指定大小输入缓冲区的缓冲字符输入流。可以不指定sz，默认为8K。

public String readLine() throws IOException ：读取一个文本行。通过下列字符之一即可认为某行已终止：换行 (’\n’)、回车 (’\r’) 或回车后直接跟着换行。返回：包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null

public static void main(String[] args) throws IOException {
		FileReader fr = new FileReader("C:\\A\\B\\d.txt");
		BufferedReader br = new BufferedReader(fr);
		
		int b = 0;
		// 从缓冲区中一次读取一个 输出
//		while((b = br.read()) != -1) {
//			System.out.println((char)b);
//		}
//		fr.close();
		// 从缓冲区中一次读一行 输出,不会读取换行符
		String s = null;
		while((s = br.readLine()) != null) {
			System.out.println(s);
		}
		fr.close();
		
	}

缓冲字符输出流（BufferedWreader）

public BufferedReader(Reader in, int sz) ：创建一个使用指定大小输入缓冲区的缓冲字符输入流。可以不指定sz，默认为8K。

    public static void main(String[] args) throws IOException {
		/**
		 * 使用缓冲字符流 进行 文本复制
		 */
		// 创建 缓冲输入字符流
		FileReader fr = new FileReader("C:\\A\\B\\d.txt");
		BufferedReader br = new BufferedReader(fr);
		// 创建 缓冲输出字符流
		FileWriter fw = new FileWriter("C:\\A\\B\\d_copy.txt");
		BufferedWriter bw = new BufferedWriter(fw);
		
//		int b = 0;
//		// 从缓冲区读一个字符,会读取 换行符
//		while((b = br.read()) != -1) {
//			bw.write(b);
//		}
		
		String s = null;
		// 从缓冲区读一行.没有读取换行符
		while((s = br.readLine()) != null) {
			// 写一行
			bw.write(s);
			// 换行
			bw.newLine();
		}
		
		bw.close();
		br.close();
		
	}

black_wangyk

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java学习笔记——学习IO流

输入 input ：输入到java程序输出 output ：java程序输出分类：按照传输内容分：字节流、字符流按照传输方向分：输入流、输出流字节流主要是传输字节（byte）数据，例如：音视频、图片等二进制文件输入字节流InputStream 是字节输入流的所有类的超类。是抽象类FIleInputStream 是字节输入流的常用类构造方法：FileInputStream(String name) ：通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过
复制链接

扫一扫