java笔记-IO流-IO基本操作

IO(Input Output)流

1.IO流用来处理设备之间的数据传输

2.java对数据的操作是通过流的方式

3.java用于操作流的对象都在IO包中

4.流按照操作数据分为两种：字节流和字符流

5.流按照流向分为：输入流；输出流

常用基类：

1.字节流的抽象基类：

InputStream，OutputStream

2.字符流的抽象基类

Reader，Writer

创建FileWriter对象时，该对象一旦被初始化就必须明确被操作的文件，而且该文件会被创建到指定目录，如果该目录下已经有同名文件，将被覆盖，创建FileWriter的步骤就是明确数据要存放的位置。

将数据写入文件

import java.io.*;
class  FileWriterDemo
{
	public static void main(String[] args) throws IOException
	{
		//创建FileWriter对象，该对象一旦被初始化就必须要明确被操作的文件，无空参。
		//该文件会被创建到指定目录，如果该目录下已经有同名文件将会被覆盖。
		//该过程就是明确数据存放的位置。存储过程可能存在异常，需try或者抛。
		FileWriter fw=new FileWriter("Demo.txt");
		//调用write方法将数据写到指定的文件中。
		fw.write("hi cs !");
		//刷新流中的数据到文件中。
		//刷新流后，流可以继续使用，可以继续写入数据。
		fw.flush();
		//刷新数据后若不再使用，需关闭该流，执行如下操作会自动将流中的数据刷新到指定的文件中。
		//关闭流后将不能再往里面写数据。
		fw.close();
	}
}

文件写异常捕捉

/*
 文件的创建，写，关闭均有可能出现异常，需要对具体操作的语句进行异常捕捉。
*/
import java.io.*;
class  IOExceptionDemo
{
	public static void main(String[] args) 
	{
		FileWriter fw=null;
		try{
			//FileWriter fw=new FileWriter("Demo.txt");	//若在此处定义，则try执行完后fw作用域就没有了。需要在语句外定义。
			fw=new FileWriter("Demo.txt",true);			//此处加入true表明，若Demo.txt存在则追加数据，若不存在，新建Demo.txt
			fw.write("File write:\r\nIO Exception！");	//加入\r\n可以换行。
		}
		catch(Exception e){
			System.out.println(e.toString());
		}
		finally{
			//只有当fw不为空时才需要执行close()
			if(fw!=null){
				try{
					//在执行close时仍有可能发生异常。
					fw.close();
				}
				catch(Exception e){
					System.out.println(e.toString());
				}
			}

		}
	}
}

读取文件

/*
 文件的读操作。
*/
import java.io.*;
class  FileReaderDemo
{
	public static void main(String[] args) throws IOException	//暂时在此处抛异常。
	{
		FileReader fr=new FileReader("FileReaderDemo.java");
		//向字符数组中读字符。
		char[] chs=new char[512];	//每次读取1k。
		int num=0;
		while((num=fr.read(chs))!=-1){
			//若数据较多，最后可能装不满chs数组，所以输出时，只输出0-num的字符。
			System.out.print(num+".....\n"+new String(chs,0,num));
		}
		fr.close();
	}
}

文件复制和异常处理

import java.io.*;
class CopyFileDemo 
{
	public static void main(String[] args) throws IOException
	{
		copyFileSingle();
	}
	public static void copyFileSingle() throws IOException{
		FileReader fr=null;
		FileWriter fw=null;
		try{
			fr=new FileReader("CopyFileSingle.java");
			fw=new FileWriter("CopyFileSingleCopy.java");
			char[] ch=new char[512];
			int num=0;
			while((num=fr.read(ch))!=-1){
				//最后读取的字符个数不一定是512个，所以从0-num
				fw.write(ch,0,num);
			}
			fw.write("copy file!");
		}
		catch(IOException e){
				throw new RuntimeException("读写失败："+e);
		}
		finally{
			if(fr!=null)
				try{
					fr.close();
				}
				catch(IOException e){
					throw new RuntimeException("读失败："+e);
				}
			if(fw!=null)
				try{
					fw.close();
				}
				catch(IOException e){
				throw new RuntimeException("写失败："+e);
			}
		}
		
	}
}

字符流的缓冲区

缓冲区的出现提高了对数据的读写能力，

对应类：

BufferedWriter

BufferedRead

缓冲区要结合流才可以使用

在流的基础上对流的功能进行了增强。

字符流读缓冲区

/*
 字符流读缓冲区。
 该缓冲区提供了一次读取一行的操作，方便了问吧的读取，当返回空的时候读
 到文件的末尾，readLine();该方法返回换行符之前的内容，不保罗换行符。
*/
import java.io.*;
class  BufferedReadDemo
{
	public static void main(String[] args) throws IOException
	{
		FileReader fr=new FileReader("buf.txt");
		BufferedReader bufread=new BufferedReader(fr);
		String str=null;
		while((str=bufread.readLine())!=null){
			System.out.println(str);
		}
		bufread.close();
	}
}

字符流写缓冲区

/*
 在创建缓冲区之前，必须要创建流对象。
 缓冲区提供了一个跨平台的换行符，newLine();
*/
import java.io.*;
class  BufferedWriterDemo
{
	public static void main(String[] args) throws IOException
	{
		FileWriter fw=new FileWriter("buf.txt");
		BufferedWriter bufwriter=new BufferedWriter(fw);
		bufwriter.write("hello .");
		for(int x=0;x<6;x++){
			bufwriter.write("hi");
			bufwriter.flush();
			bufwriter.newLine();
		}
	}
}

通过缓冲区复制文件

/*
 通过缓冲区复制文件。
*/
import java.io.*;
class CopyDemo
{
	public static void main(String[] args) 
	{
		BufferedReader bufr=null;
		BufferedWriter bufw=null;
		try{
			//新建读写缓冲区。
			bufr=new BufferedReader(new FileReader("123.mp3"));
			bufw=new BufferedWriter(new FileWriter("123Copy.mp3"));
			String str=null;
			//一行一行的读取。
			while((str=bufr.readLine())!=null){
				bufw.write(str);
				//添加换行符。
				//bufw.newLine();
				//刷现缓冲区。
				bufw.flush();
			}
		}
		catch(IOException e){
			throw new RuntimeException(e);	
		}
		//最后必须执行的语句。
		finally{
			try{
				if(bufr!=null){
					bufr.close();
				}
			}
			catch(IOException e){
				throw new RuntimeException(e);
			}
			try{
				if(bufw!=null){
					bufw.close();
				}
			}
			catch(IOException e){
				throw new RuntimeException(e);
			}
		}
	}
}

重写BuferedRead中的ReadLine方法

/*
 重写BufferedRead中的ReadLine方法。
*/
import java.io.*;

class MyBufferedReaderDemo
{
	public static void main(String[] args) throws IOException
	{
		MyBufferedReader bufr=null;
		
		String str=null;
		try{
			//新建读写缓冲区。
			bufr=new MyBufferedReader(new FileReader("buf.txt"));
			//一行一行的读取。
			while((str=bufr.MyReadLine())!=null){
				System.out.println(str);
				//System.out.println("hello cs");

				//str.flush();
			}
		}
		catch(IOException e){
			throw new RuntimeException(e);	
		}
		//最后必须执行的语句。
		finally{
			try{
				if(bufr!=null){
					bufr.MyClose();
				}
			}
			catch(IOException e){
				throw new RuntimeException(e);
			}
		}
	}
}
class MyBufferedReader
{
	private FileReader fr;
	//在创建对象时，直接传递参数。
	MyBufferedReader(FileReader fr){
		this.fr=fr;
	}
	public String MyReadLine()throws IOException{
		int ch=0;
		//使用字符缓冲区存储数据。
		StringBuilder sb=new StringBuilder();
		//判断是否仍有数据可读。
		while((ch=fr.read())!=-1){
			//判断行末尾符号
			if(ch=='\r')
				continue;
			//判断行末尾符号
			if(ch=='\n')
				//读取到换行时，将字符缓冲区的数据转化为字符串。
				return sb.toString();
			else{
				//不是行尾，则向缓冲区中追加数据。
				sb.append((char)ch);
			}
		}
		//最后判断时，文件的结尾不一定有‘\n’换行符号，此时需要在末尾判断
		//字符流缓冲区中是否有数据，可根据数据流的长度判读。妙呀！！！！
		if(sb.length()!=0){
			return sb.toString();
		}
		return null;
	}
	public void MyClose()throws IOException{
		fr.close();
	}
}