IO流——字符流输入输出

字符流和字节流：

字符流两个基类：

InputStream和OutputStream

 

字节流两个基类：

Reader和Writer

 

先学一下字符流的特点

 

既然IO流是用于操作数据的，那么数据的最常见体现形式是：文件

 

那么先以操作文件为主来演示。

/*需求：在硬盘上，创建一个文件并写入一些文字数据。
找到一个专门用于操作文件的Writer子类对象，FileWriter。后缀名是父类名，前缀名是该流对象的功能
*/

import java.io.*;

class FileWriterDemo
{
	public static void main(String[] args) throws IOException
	{
		//创建一个FileWriter对象，该对象一被初始化就必须要明确被操作的文件
		//而且该文件会被创建到指定目录下。如果该目录下已有同名文件，将被覆盖
		//其实该步就是在明确数据要存放的目的地
		FileWriter fw = new FileWriter("Demo.txt");

		//调用writer方法，将字符串写入到流中
		fw.write("agdgd");

		//刷新流对象中的缓冲中的数据，将数据刷到目的地中
		fw.flush();

		fw.write("lala");
		fw.flush();

		//关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据，将数据刷到目的地
		//和flush的区别：flush刷新后，流可以继续使用。close刷新后，会将流关闭
		fw.close();
		//fw.write("lala");
		//fw.close();//出错
	}
}

1.

<span style="color:#333333;">/*
文本文件的读取方式
*/
import java.io.*;

class FileReaderDemo2
{
	public static void main(String[] args) throws IOException
	{
		//创建一个文件读取流对象，和指定名称的文件相关联。
		//要保证该文件是已经存在的，如果不存在，会发生异常FileNotFoundException
		FileReader fr = new FileReader("demo.txt");

		//调用读取流对象的read方法
		/</span><span style="color:#009900;">/read()：一次读一个字符，而且自动往下读.如果已达到流的末尾，返回-1.</span><span style="color:#333333;">
		int ch = 0;
		while((ch = fr.read())!=-1)
		{
			System.out.println("ch="+(char)ch);
		}

		/*
		while(true)
		{
		 	int ch = fr.read();

			if(ch == -1)
				break;

			System.out.println("ch="+(char)ch);
		}
		*/

		fr.close();
	}
}</span>

2.

/*
文本文件的第二种读取方式：<span style="color:#009900;">通过字符数组进行读取</span>
*/
import java.io.*;

class FileReaderDemo2
{
	public static void main(String[] args) throws IOException
	{
		FileReader fr = new FileReader("demo.txt");

		//定义一个字符数组，用于存储读到的字符
		//<span style="color:#009900;">该read(char[])返回的是读到的字符个数</span>
		char[] buf = new char[1024];

		int num = 0;
		while((num = fr.read(buf))!=-1)
		{
			System.out.print(new String(buf,0,num));
		}


		fr.close();
	}
}

/*
将C盘一个文本文件复制到D盘

复制原理：
就是将C盘下的文件数据存储到D盘的一个文件中

步骤：
1.在D盘创建一个文件，用于存储C盘文件中的数据
2.定义读取流和C盘文件关联
3.通过不断的读写完成数据存储
4.关闭资源
*/
import java.io.*;

class CopyText
{
	public static void main(String[] args) throws IOException
	{
		copy_1();
		copy_2();
	}
	public static void copy_2()
	{
		FileWriter fw = null;
		FileReader fr = null;
		try
		{
			fw = new FileWriter("FileWriterDemo_copy.txt");
			fr = new FileReader("FileWriterDemo.java");

			char[] buf = new char[1024];

			int len = 0;
			while((len = fr.read(buf))!= -1)
			{
				fw.write(buf,0,len);	
			}
		}
		catch(IOException e)
		{
			throw new RuntimeException("读写失败");
		}
		finally
		{
			if(fr!=null)
				try
				{
					fr.close();
				}
				catch(IOException e)
				{
				
				}
			if(fw!=null)
				try
				{
					fw.close();
				}
				catch(IOException e)
				{
				
				}
		}
	}

	//从C盘读一个字符，就往D盘写一个字符
	public static void copy_1() throws IOException
	{
		//创建目的地
		FileWriter fw = new FileWriter("RuntimeDmeo_copy.txt");

		//与已有文件关联
		FileReader fr = new FileReader("FileWriterDemo.java");

		int ch = 0;

		while((ch = fr.read())!= -1)
		{
			fw.write(ch);
		}

		fw.close();
		fr.close();
		
	}
}

字符流的缓冲区

/*
缓冲区的出现是为了<span style="color:#cc0000;">提高流的操作效率</span>而出现的。
所以在创建缓冲区之前，必须要先有流对象。

该缓冲区中提供了一个跨平台的换行符：newLine();
*/

import java.io.*;

class BufferedWriterDemo
{
	public static void main(String[] args) throws IOException
	{
		//创建一个字符写入流对象
		FileWriter fw = new FileWriter("buf.txt");

		//为了提高字符写入流效率，加入了缓冲技术，
		//只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可。
		BufferedWriter bufw = new BufferedWriter(fw);
	
		for(int x = 1;x < 5;x++)
		{
			bufw.write("agdf"+x);
			bufw.newLine();
			//只要用到缓冲区，就要记得刷新
			bufw.flush();
		}
		//其实关闭缓冲区，就是关闭缓冲区中的流对象。
		bufw.close();

		//fw.close();//就不需要了
	}

}

/*
 通过缓冲区复制一个.java文件
 */
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyTextByBuf {

	public static void main(String[] args) {
		BufferedReader bufr = null;
		BufferedWriter bufw = null;

		try {
			bufr = new BufferedReader(new FileReader("BufferedWriterDemo.java"));
			bufw = new BufferedWriter(new FileWriter("bufWriter_copy.txt"));

			String line = null;

			while ((line = bufr.readLine()) != null) {
				bufw.write(line);
				bufw.newLine();
				bufw.flush();
			}
		} catch (IOException e) {
			throw new RuntimeException("读写失败");
		} finally {
			try {
				if (bufr != null)
					bufr.close();
			} catch (IOException e) {
				throw new RuntimeException("读取关闭失败");
			}
			try {
				if (bufw != null)
					bufw.close();
			} catch (IOException e) {
				throw new RuntimeException("写入关闭失败");
			}
		}
	}
}