Java系列（45）——IO 流中的字符流

最新推荐文章于 2024-08-04 17:03:27 发布
原创 最新推荐文章于 2024-08-04 17:03:27 发布 · 689 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #IO流

本文深入讲解Java中的IO流概念，包括流的分类、字符流的使用，如FileWriter和FileReader，以及如何利用BufferedWriter和BufferedReader进行高效文件操作。通过实例演示，读者将学会如何读写文本文件，复制文件，并掌握高效缓存区流的运用。

本系列博客汇总在这里：Java系列_汇总

目录

一、IO 流概述

  1. IO（Input/Output）:输入和输出，指的是某个设备或环境进行数据的输入或者输出。例如：键盘的输入，再比如显示器就是输出设备，输出图像。
  2. 对于java来说输入输出问题，java将它抽象成流对象来解决。
  3. 以游戏程序为中心读取文件就是输入，写入文件是输出。
    在这里插入图片描述

二、IO 流在 java 中的分类

在这里插入图片描述

三、字符流简介

  1. 输出流
    （1）字符输出流的超类：Writer；
    （2）子类 ：FileWriter，BufferedWriter，…
    在这里插入图片描述

  2. 输出流
    （1）字符输入流的超类：Reader；
    （2）子类： FileReader，BufferedReader，…
    在这里插入图片描述

  3. 使用字符流向一个文件输入helloworld
    步骤：
    （1）创建文件；
    （2）创建输出流对象；
    （3）把流指向指定的文件；
    （4）释放资源。

四、字符输出流 FileWriter

  1. FileWriter 的普通构造器（会覆盖原有内容）
    在这里插入图片描述
    构造器一

    //创建文件
File file = new File("a.txt");

FileWriter fw = null;
try
{
	//创建输出流的对象
	fw = new FileWriter(file);
	//把内容写入文件
	fw.write("helloworld");
	//字符流的特点：清空缓冲区，把内容写入到文件中
	fw.flush();
} catch (IOException e)
{
	// TODO 自动生成的 catch 块
	e.printStackTrace();
}finally 
{
	if(fw != null)
	{
		try
		{
			//close关闭输出流时会自动清理缓冲区
			fw.close();
		} catch (IOException e)
		{
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
	}
}

    在这里插入图片描述
    构造器二

    //可以不用手动创建文件对象
//File file = new File("a.txt");

FileWriter fw = null;
try
{
	//创建输出流的对象
	fw = new FileWriter("a.txt");
	//把内容写入文件
	fw.write("helloworld");
	//字符流的特点：清空缓冲区，把内容写入到文件中
	fw.flush();
} catch (IOException e)
{
	// TODO 自动生成的 catch 块
	e.printStackTrace();
}finally 
{
	if(fw != null)
	{
		try
		{
			//close关闭输出流时会自动清理缓冲区
			fw.close();
		} catch (IOException e)
		{
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
	}
}

    在这里插入图片描述

  2. flush 的使用注意事项

    FileWriter fw = null;
try
{
	//创建输出流的对象
	fw = new FileWriter("b.txt");
	
	//向文件中写入100个helloworld
	for (int i = 0; i < 100; i++)
	{
		//把内容写入文件
		//把文本写入文件中 \n 代表换行,同时为了兼容记事本，建议使用 \r\n
		fw.write("helloworld\n");
		if(i%10 == 0)
		{
			//清空缓冲区，把内容写入到文件中,当数据量较大，不应该在最后才清空缓冲区，但也不应该频繁清空缓冲区
			fw.flush();
		}
	}
	//把缓冲区最后残留的数据写入文件
	fw.flush();
} catch (IOException e)
{
	// TODO 自动生成的 catch 块
	e.printStackTrace();
}finally 
{
	if(fw != null)
	{
		try
		{
			//close关闭输出流时会自动清理缓冲区
			fw.close();
		} catch (IOException e)
		{
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
	}
}

    在这里插入图片描述

  3. FileWriter 的追加构造器
    在这里插入图片描述
    示例

    FileWriter fw = null;
try
{
	//创建输出流的对象的两种方式
	fw = new FileWriter("b.txt",true);//推荐使用
	//fw = new FileWriter(new File("b.txt"),true);
	
	//向文件中写入100个helloworld
	for (int i = 0; i < 100; i++)
	{
		//把内容写入文件
		//把文本写入文件中 \n 代表换行,同时为了兼容记事本，建议使用 \r\n
		fw.write("weiyuxuan\n");
		if(i%10 == 0)
		{
			//清空缓冲区，把内容写入到文件中,当数据量较大，不应该在最后才清空缓冲区，但也不应该频繁清空缓冲区
			fw.flush();
		}
	}
	//把缓冲区最后残留的数据写入文件
	fw.flush();
} catch (IOException e)
{
	// TODO 自动生成的 catch 块
	e.printStackTrace();
}finally 
{
	if(fw != null)
	{
		try
		{
			//close关闭输出流时会自动清理缓冲区
			fw.close();
		} catch (IOException e)
		{
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
	}
}

    在这里插入图片描述
    注意：输出换行不同的环境下换行的方式也不一样！
    （1）Windows: \r\n（使用 \n\r 时由于 \r 的作用会多空出一行，当记事本打开的时候，应该使用 \r\n 才能按预期显示）
    （2）Linux: \n
    （3）Mac: \r

四、FileWriter 的五种写入功能

在这里插入图片描述

  • 示例
    FileWriter fw = null;
try
{
	//创建输出流的追加对象
	fw = new FileWriter("text.txt");
	
	/**
	 * 第一种（写入字符数组）
	 */
	char[] cha = {'a','b','c','d'};
	fw.write(cha);
			
	
	/**
	 * 第二种
	 */
	//把一部分的字符数组写入到文件，第一个参数是字符数组，第二个参数是开始索引，第三个参数是从开始索引开始取得字符串的长度
	fw.write(cha, 1, 3);
	
	/**
	 * 第三种
	 */
	//通过int值写入相应的字符
	fw.write(100);
	
	/**
	 * 第四种 
	 */
	//写入字符串			
	fw.write("100");
	
	/**
	 * 第五种
	 */
	//截取字符串
	fw.write("weiyuxuan", 2, 3);
				
	//清空缓冲区，把内容写入到文件中
	fw.flush();

} catch (IOException e)
{
	// TODO 自动生成的 catch 块
	e.printStackTrace();
}finally 
{
	if(fw != null)
	{
		try
		{
			//close关闭输出流时会自动清理缓冲区
			fw.close();
		} catch (IOException e)
		{
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
	}
}
    在这里插入图片描述

五、字符输入流 FileReader

  1. FileReader 并不是 Reader 的直接子类
    在这里插入图片描述

  2. FileReader 的构造器
    在这里插入图片描述
    构造器类似 FileWriter ，第一种构造器同之前一样，需要预先创建文件对象，推荐使用第二种构造器！

  3. 范例：读取文件 helloworld.txt 打印到控制台
    （1）创建出入流对象 FileReader；
    （2）读取数据；
    （3）关闭输入流。

  4. 读取字符的方法
    在这里插入图片描述
    第一种读取方式：读取单个字符,返回的是字符的ASCII码

    //创建文件读取对象
FileReader fr = new FileReader("text.txt");

/*			
//第一次读取第一个字符
int num = fr.read();
System.out.println((char)num);
//第二次读取第二个字符
num = fr.read();
System.out.println((char)num);			
*/			

//如果整个文本读取完毕，最后没有字符会返回 -1
int num = 0;
//通过循环来读取字符，判断跳出循环的标志是 num=-1
while((num = fr.read()) != -1)
{
	System.out.print((char)num);
}

    在这里插入图片描述
    第二种读取方式：把字符读入数组，返回读取到的字符数量

    //创建文件读取对象
FileReader fr = new FileReader("text.txt");							

//读取5个字符放入到字符数组中（包括换行符）
char[] chs = new char[15];

//第一次读取
System.out.println("-------------------------------------");
int num = fr.read(chs);
String str = new String(chs);
System.out.println(num);
System.out.println(str);

//第二次读取
System.out.println("-------------------------------------");
num = fr.read(chs);
str = new String(chs);
System.out.println(num);
System.out.println(str);

//第三次读取
System.out.println("-------------------------------------");
//为什么要如下这样做?
//因为读取字符类似分批读取处理的，当字符数量不足一批，此处就是不足15的话，假如说到最后只剩12个字符了由于
//机制上是覆盖原数据上一批的数据，但是由于只有12个字符可供读取，所以从13开始将无法覆盖上一批的字符，当然
//也就保留上一批的字符了，所以我们需要进行如下操作:
num = fr.read(chs);
if( num < 15)
{
	//读取剩余字符
	str = new String(chs,0,num);
}	
System.out.println(num);
System.out.println(str);

    FileReader fr = null;
	
//创建文件读取对象
fr = new FileReader("text.txt");							

//读取5个字符放入到字符数组中（包括换行符）
char[] chs = new char[15];

//第一次读取
System.out.println("-------------------------------------");
int num = fr.read(chs);
String str = new String(chs,0,num);
System.out.println(num);
System.out.println(str);

//第二次读取
System.out.println("-------------------------------------");
num = fr.read(chs);
str = new String(chs,0,num);
System.out.println(num);
System.out.println(str);

//第三次读取
System.out.println("-------------------------------------");
num = fr.read(chs);		
str = new String(chs,0,num);
System.out.println(num);
System.out.println(str);

    输出在这里插入图片描述

    //创建文件读取对象
FileReader fr = new FileReader("text.txt");							

//读取1024个字符放入到字符数组中（包括换行符）
char[] chs = new char[1024];
int len = -1;
//循环条件判断的边界是fr.read(chs)返回-1，说明文件已经读取完毕
while((len = fr.read(chs)) != -1)
{
	System.out.println(new String(chs,0,len));
}

    在这里插入图片描述

六、文本文件的复制

  1. 使用字符流来做文件的拷贝。

  2. 范例：把一个java文件拷贝到项目根目录。
    （1）创建字符输入流的对象；
    （2）创建字符输出流对象；
    （3）把输出流输入的数据写入输出流中；
    （4）关闭资源。

  3. 示例

    Reader reader = null;
Writer writer = null;		
try
{
	//创建读文件对象
	reader = new FileReader("src/cn/wyx/io/cha/IODemo.java");
	
	//创建写文件对象
	writer = new FileWriter("IODemo.java");
	
	
	int num = -1;
	while((num = reader.read()) != -1)
	{
		writer.write(num);
	}						
} 
catch (FileNotFoundException e)
{
	// TODO 自动生成的 catch 块
	e.printStackTrace();
} 
catch (IOException e)
{
	// TODO 自动生成的 catch 块
	e.printStackTrace();
}
finally
{
	//释放资源
	try
	{
		if(writer != null)
		{
			writer.close();
		}
		if(reader != null)
		{
			reader.close();
		}
	} 
	catch (IOException e)
	{
		// TODO 自动生成的 catch 块
		e.printStackTrace();
	}
}

    在这里插入图片描述

    public static void copyFile()
{
	Reader reader = null;
	Writer writer = null;		
	try
	{
		//创建读文件对象
		reader = new FileReader("src/cn/wyx/io/cha/IODemo.java");
		
		//创建写文件对象
		writer = new FileWriter("IODemo.java");
		
		//定义每次读取长度的对象
		int len = -1;
		
		//定义存储内容的数组
		char[] chs = new char[1024];
		
		//当 len!=-1 就一直读
		while((len = reader.read(chs)) != -1)
		{
			//把读取的文件写入到目标文件中
			writer.write(chs,0,len);
		}						
	} 
	catch (FileNotFoundException e)
	{
		// TODO 自动生成的 catch 块
		e.printStackTrace();
	} 
	catch (IOException e)
	{
		// TODO 自动生成的 catch 块
		e.printStackTrace();
	}
	finally
	{
		//释放资源
		try
		{
			if(writer != null)
			{
				writer.close();
			}
			if(reader != null)
			{
				reader.close();
			}
		} 
		catch (IOException e)
		{
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}	
	}	
}

    在这里插入图片描述

七、BufferedWriter 高效缓存区输出流

在这里插入图片描述

  1. 将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
  2. 构造器
    在这里插入图片描述
  3. 示例
    /**
 * 
 * 描述：使用高效缓冲区流来将 text.txt 的文件中写入“临渊羡鱼，不如退而织网”
 */
public static void writer()
{
	//创建文件输出流
	FileWriter fw = null;
	BufferedWriter bw = null;
	try
	{		
		fw = new FileWriter("text.txt");
		
		//创建高效缓冲区的流对象
		bw = new BufferedWriter(fw);
		
		//输出数据
		bw.write("临渊羡鱼，不如退而织网");
		
		//清空缓冲区
		bw.flush();
		
	} catch (IOException e)
	{
		// TODO 自动生成的 catch 块
		e.printStackTrace();
	}
	finally
	{
		if(bw != null)
		{
			try
			{
				//释放资源
				bw.close();
			} catch (IOException e)
			{
				// TODO 自动生成的 catch 块
				e.printStackTrace();
			}
		}
	}
}
    在这里插入图片描述

八、BufferedReader 高效缓存区输入流

在这里插入图片描述

  1. 从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
  2. 构造器
    在这里插入图片描述
  3. 使用高效缓冲区输入流来读取文件中的内容。
  4. 示例
    /**
 * 
 * 描述：使用高效缓冲区流来将 text.txt 文件中的内容读出来
 */
public static void reader()
{
	//创建文件输入流
	FileReader fr = null;
	
	BufferedReader br = null;
	try
	{		
		fr = new FileReader("text.txt");
		
		//创建高效缓冲区的流对象
		br = new BufferedReader(fr);
		
		char[] chs = new char[1024];
		
		int len = -1;
		
		while((len = br.read(chs)) != -1)
		{
			System.out.print(new String(chs,0,len));
		}
		
	} catch (IOException e)
	{
		// TODO 自动生成的 catch 块
		e.printStackTrace();
	}
	finally
	{
		if(br != null)
		{
			try
			{
				//释放资源
				br.close();
			} catch (IOException e)
			{
				// TODO 自动生成的 catch 块
				e.printStackTrace();
			}
		}
	}
}
    在这里插入图片描述

九、高效缓存区的扩展方法

  1. 输出流
    在这里插入图片描述
    示例

    fw = new FileWriter("text.txt");
			
//创建高效缓冲区的流对象
bw = new BufferedWriter(fw);

for (int i = 0; i < 10; i++)
{
	//输出数据
	bw.write("临渊羡鱼，不如退而织网");
	//换行，相当于\r\n,该方法能兼容记事本！
	bw.newLine();				
}			
//清空缓冲区
bw.flush();

  2. 输入流
    在这里插入图片描述
    示例

    //创建文件读取对象
FileReader fr = new FileReader("text.txt");							

//创建高效缓冲区的流对象
BufferedReader br = new BufferedReader(fr);

String line = br.readLine();

//高效输入流可以读取一行数据
while((line = br.readLine()) != null)
{
	System.out.println(line);
}

十、使用高效缓存区流复制文件

  • 示例
    public static void copyFile()
{
	Reader reader = null;
	BufferedReader br = null;
	BufferedWriter bw = null;	
	Writer writer = null;		
	try
	{
		//创建读文件对象
		reader = new FileReader("src/cn/wyx/io/cha/IODemo.java");
		
		//创建高效缓冲区的输入流
		br = new BufferedReader(reader);
		
		//创建写文件对象
		writer = new FileWriter("IODemo.java");
		
		//创建高效缓冲区的输出流
		bw = new BufferedWriter(writer);
				
		String line = null;
		
		//读取数据并且写入另一个文件中
		while((line= br.readLine()) != null)
		{
			bw.write(line);
			bw.newLine();
		}	
		//清空缓冲区
		bw.flush();
	} 
	catch (FileNotFoundException e)
	{
		// TODO 自动生成的 catch 块
		e.printStackTrace();
	} 
	catch (IOException e)
	{
		// TODO 自动生成的 catch 块
		e.printStackTrace();
	}
	finally
	{
		//释放资源
		try
		{
			if(writer != null)
			{
				writer.close();
			}
			if(reader != null)
			{
				reader.close();
			}
		} 
		catch (IOException e)
		{
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}		
	}		
}
    最后注意：当前学习的字符流只能对文本文件进行操作！

如有错误，欢迎指正！

IO-字符流
weixin_45063957的博客
05-12 163
字符流= 字节流+编码表； 1、编码问题 用字节流复制文本时，文本文件会有中文，此时不会乱码，因为最终底层操作系统会自动进行字节拼接成 中文 识别中文的方式： 汉字在存储的时候，不论选择哪种编码方式，第一个字节都是负数； 编码表：计算机中存储的信息都是用二进制表示的， 编码与解码 编码与解码应当是同一种方式； 字符集：是一个系统支持的所有字符的集合，包括各个国家的文字，符号等 ascii字符集；使用七位表示一个字符，共128位，扩展后使用八位表示，共256位； GB是中文的编码字符集；..
Java学习——IO流
最新发布
qq_24992377的博客
07-07 789
特性字节流字符流基类ReaderWriter处理单位8位字节16位Unicode字符适用场景图片、视频、网络通信等二进制数据文本文件（.txt, .csv, .xml）缓冲类等等编码处理不转换编码自动处理字符编码（如UTF-8）选择原则二进制文件（如图片）→ 字节流文本文件→ 字符流 +显式指定编码（如UTF-8）大文件操作→ 必须用缓冲流（性能提升显著）网络通信→ 字节流为主，文本内容通过转换完整代码示例参考：https://gist.github.com。
Java IO之字符流
jandroid
10-13 181
1. 字符流 在程序中一个字符等于两个字节，Java为我们提供了Reader和Writer两个专门操作字符流的类 1) 字符输出流：Writer Writer是一个字符流，它是一个抽象类，所以要使用它，也必须通过其子类来实例化它后才能使用它。 Writer类的常用方法 方法名称 描述 public abstract void close()...
JAVA 流 的ppt课件
05-26
关于流的PPT课件理解流的概念及分类 掌握常用流的体系结构 运用字节流读写文本文件 运用字符流读写文本文件 使用文件类操作文件及目录
IO字符流
二丑的博客
12-09 275
/* import java.io.File; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; /* 字节流：字节流读取的是文件中的二进制数据，读到的数据并不会帮你转换成你看得懂的字符。   字符流： 字符流会把读取到的二进制的数据进行对应
java——IO流技术.pdf
04-03
Java中的IO流主要位于`java.io`包中，该包包含了用于处理各种类型数据的流类。其中最重要的是五个类和三个接口： - **File**: 文件类，用于处理文件和目录的操作。 - **InputStream**: 字节输入流，用于从数据源...
浅谈java IO流——四大抽象类
08-26
java IO流是java语言中用于输入输出操作的基本类库，IO流是Java程序中最基本也最重要的一部分，java IO流主要可以分为两大类：字节流和字符流。在java中，四大抽象类是IO流的基础，它们分别是InputStream、...
java基础——IO流及File-RandomAccessFile对象.docx
01-02
### Java基础——IO流及File、RandomAccessFile对象 #### IO流概述 在Java中，IO流主要用于处理设备上的数据，这里的“流”可以被理解为数据的流动过程，即数据从一个地方移动到另一个地方的过程。Java中的IO流通过...
java之IO篇——File、字节流、字符流
2202_75483664的博客
08-04 1517
IO流是用于读写文件中的数据，要读写文件之前可以创建文件获取文件对象再创建IO流，正文会先介绍File类，通过File类的构造方法获取文件的对象，创建文件或目录以及File类的一些方法获取文件对象的属性。后面还介绍了相关的IO流体系，字节流和字符流的区别用法。目录前言一、File1.常用的成员方法(1) 判断、获取(2)创建、删除(3)获取并遍历2. 实操(1)遍历C盘下的以.avi结尾的文件(2)删除一个多级文件夹（里面的有些文件有内容）(3)统计各种文件的数量二、IO流分类三、IO体系1.字节流。
IO---字符流
andy的博客
06-30 180
字符流概述 在IO开发过程中，我们传输最频繁的数据为字符，而以字节方式传输字符需要每次将字符串转换成字节再处理，而且也丧失了程序员对数据内容的判断(因为程序员只认识字符，不认识字节)。 所以，为了让程序员方便对字符进行操作，Java提供了专门以字符作为操作单位的类——字符流，其底层仍然为字节流。 显然，字符流只能操作字符，无法操作其他数据，如...
IO：字符流
pp_hu的博客
10-13 156
字符流字符流的缓冲区 字符流的缓冲区 缓冲区的出现提高了对数据的读写效率，缓冲区要结合流才可以使用，在流的基础上对流的功能进行了增强。 对应类： BufferedWriter BufferedReader Demo1:字符写入缓冲区 /* 缓冲区的出现是为了提高流的操作效率而出现的。 所以在创建缓冲区之前，必须要先有流对象。 该缓冲区当中提供了一个跨平台的换行符：newLine(); windows系统的换行是"\r\n",linux是"\n"; */ import java.io.*; class Bu
IO流（字符流）
weixin_56504344的博客
09-03 547
IO流（字符流） 字符流 一.字符流是什么 字符流是可以直接读取字符的IO流 字符流读取字符，就要先读去到字节数据，然后转为字符，如果要写出字符，需要把字符转为字节再写出 FileReader FileReader类的read()方法可以按照字符大小读取 import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; public class Demo1_FileReader
Java IO：深入理解字符流操作（下）
"本文主要介绍了Java IO中的字符流，特别是关注于文件操作的字符流——FileReader类。字符流在处理文本数据时尤其有用，因为它能够处理特定编码下的字符，而不是简单的字节序列。" 在Java中，IO流分为字节流和字符...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值