黑马程序员——IO流

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

< 今日心情 >放掉懒惰，再加上一份坚持

一、字符流

数据以字节的形式存储在计算机中的。

计算机上显示的文字（中文、英文、特殊符号等等）都是字符，每一个字符对应着若干的字节。

字符流是以字符为操作对象

1.Writer

import java.io.*;
class FileWriterDemo 
{
	public static void main(String[] args) 
	{
		FileWriter fw=null;
		/*
		向文件中写入数据，首先打开文件
		按照面向对象的思想，需要寻找一个能够打开文件的对象，没有就创建一个
		FileWriter类描述了打开文件的行为，可以创建一个该类的对象
		通过该对象可以对字符进行操作并写入打开的文件
		当所有操作对象完成以后，打开的文件需要关闭
		*/
		try
		{
		/*
		打开文件的操作在创建该对象的同时完成，也就是在构造函数中完成
		该路径下有同名文件则被覆盖
		其实构造函数中传入的就是文件的路径
		该过程可能抛出IOException异常
		*/
			fw=new FileWriter("filewritertest.txt");
			fw.write("bigniu");
			//fw.flush();刷新流——将流中的数据写入文件
		}
		catch (IOException e)
		{
			//简单的处理
			e.printStackTrace();
		}
		finally
		{
			//文件一旦被打开就必须关闭，无论是否发生异常
			if(fw!=null)
			{
				try
				{
					//关闭文件可能抛出IOException异常
					fw.close();
				}
				catch (IOException e)
				{
					e.printStackTrace();
				}
			}
		}

	}
}

内容

内容

2.Reader

import java.io.*;
class  FileReaderDemo
{
	public static void main(String[] args) 
	{
		//FileReader对象是一个能够在文件中读取数据的对象
		FileReader fr=null;
		try
		{
			//创建对象可能抛出NotFoundException异常。
			fr=new FileReader("filewritertest.txt");
			/*
			read() 读取单个字符，同时准备对下一个字符进行读取
			返回的int型对应该字符的字节
			读到文件末尾时返回-1；
			可能抛出IOException异常
			*/
			for(int i=fr.read();i!=-1;i=fr.read())
			{
				System.out.print((char)i);
			}
			System.out.println();
		}
		catch (FileNotFoundException e)
		{
			e.printStackTrace();
		}
		catch(IOException e)
		{
			e.printStackTrace();
		}
		finally
		{
			if(fr!=null)
			{
				try
				{
					fr.close();
				}
				catch (IOException e)
				{
					e.printStackTrace();
				}
			}
		}
	}
}
import java.io.*;
class  FileReaderDemo
{
	public static void main(String[] args) 
	{
		//FileReader对象是一个能够在文件中读取数据的对象
		FileReader fr=null;
		try
		{
			//创建对象可能抛出NotFoundException异常。
			fr=new FileReader("filewritertest.txt");
			/*
			read(char[] ch) 一次读取多个字符，同时准备下一次读取
			返回的int型为本次读取的字符个数。
			本次读取没有数据时返回-1；
			可能抛出IOException异常
			*/
			int p=0;
			for(char ch[]=new char[1024];;)
			{
				p=fr.read(ch);
				if(p==-1)
				{
					System.out.println();
					break;
				}
				System.out.print(new String(ch,0,p));
			}
		}
		catch (FileNotFoundException e)
		{
			e.printStackTrace();
		}
		catch(IOException e)
		{
			e.printStackTrace();
		}
		finally
		{
			if(fr!=null)
			{
				try
				{
					fr.close();
				}
				catch (IOException e)
				{
					e.printStackTrace();
				}
			}
		}
	}
}

3.BufferWriter

import java.io.*;
class  BufferedWriterDemo
{
	public static void main(String[] args) throws IOException
	{
		/*创建缓冲区可以提高文件 写入效率
		1.创建一个写数据字符流对象，传入要读取的文件
		2.创建一个写数据字符流缓冲区对象，将读数据的字符流对象传入
		3.字符流缓冲区对象的newLine()方法可以在文件中创建一个新的写入行
		*/
		FileWriter fw=new FileWriter("filewritertest.txt");
		BufferedWriter bfw=new BufferedWriter(fw);
		for(int i=0;i<10;i++)
		{
			bfw.write("bigniu:"+i);
			bfw.newLine();
			bfw.flush();
		}
	}
}

4.BufferReader

import java.io.*;
class  BufferedReaderDemo
{
	public static void main(String[] args) throws IOException
	{
		/*创建缓冲区可以提高文件读取效率
		1.创建一个读数据字符流对象，传入要读取的文件
		2.创建一个读数据字符流缓冲区对象，将读数据的字符流对象传入
		3.字符流缓冲区对象的readLine()方法可以读取文件中一行的数据
		*/
		FileReader fr=new FileReader("filewritertest.txt");
		BufferedReader bfr=new BufferedReader(fr);
		for(String line=bfr.readLine();line!=null;line=bfr.readLine())
			System.out.println(line);
	}
}

5.LineNumberReader

import java.io.*;
class MyLineNumberReader
{
	private int ln=0;
	private BufferedReader br=null;
	public MyLineNumberReader(FileReader fr) throws IOException
	{
		br=new BufferedReader(fr);
	}
	public String readLine() throws IOException
	{
		if(br!=null)
		{
			ln++;
			return br.readLine();
		}
		return null;
	}
	public int getLine()
	{
		return ln;
	}
	public void setLine(int ln)
	{
		this.ln=ln;
	}
}
class  MyLineNumberReaderDemo
{
	public static void main(String[] args) throws IOException
	{
		MyLineNumberReader mlnr=new MyLineNumberReader(new FileReader("filewritertest.txt"));
		mlnr.setLine(100);
		for(int i=0;i<15;i++)
		{
			System.out.println(mlnr.getLine()+":"+mlnr.readLine());
		}
	}
}

二、字节流

import java.io.*;
class  StreamTest
{
	/*通过字节流的方式可以实现对图片、音乐等进行复制操作
	1.找到读文件和写文件的对象，该对象以字节的形式操作数据
	2.选择读取方式，一个字节的读取和一个字节组的读取，显然后者更有利于读写的切换（减少切换次数）
	3.关闭流
	4.对可能引发的异常进行处理
	
	*/
	public static void main(String[] args)
	{
		FileOutputStream fos=null;
		FileInputStream fis=null;
		try
		{
			fos=new FileOutputStream("D:/bigniu02.bmp");
			fis=new FileInputStream("F:/bigniu.bmp");
			int i=0;
			for(byte[] b=new byte[1024];;)
			{
				i=fis.read(b);
				if(i==-1)
					break;
				fos.write(b,0,i);
				fos.flush();
			}
		}
		catch (FileNotFoundException e)
		{
			e.printStackTrace();
		}
		catch(IOException e)
		{
			e.printStackTrace();
		}
		finally
		{
			if(fos!=null)
			{
				 try
				 {
					fos.close();
				 }
				 catch (IOException e)
				 {
					 e.printStackTrace();
				 }
			}
			if(fis!=null)
			{
				try
				{
					fis.close();
				}
				catch (IOException e)
				{
					e.printStackTrace(); 
				}
			}
		}
	}
}
import java.io.*;
class MyBufferedInputStream
{
	private FileInputStream fis=null;
	private byte[] buf=new byte[1024*2];
	private int count=0,pos=0;
	public MyBufferedInputStream(FileInputStream fis)
	{
		this.fis=fis;
	}
	public int myRead() throws IOException
	{
		if(count==0)
		{
			pos=0;
			count=fis.read(buf);
		}
		if(count==-1)
			return -1;
		count--;
		return buf[pos++]&0xff;

	}
	public void myClose() throws IOException
	{
		fis.close();
	}
}
class  StreamTest
{
	/*通过字节流的方式可以实现对图片、音乐等进行复制操作
	1.找到读文件和写文件的对象，该对象以字节的形式操作数据
	2.选择读取方式，一个字节的读取和一个字节组的读取，显然后者更有利于读写的切换（减少切换次数）
	3.加入缓冲流提高效率
	4.关闭流
	5.对可能引发的异常进行处理
	
	*/
	public static void main(String[] args)
	{
		BufferedOutputStream bufos=null;
		MyBufferedInputStream bufis=null;
		try
		{
			bufos=new BufferedOutputStream(new FileOutputStream("D:/bigniu03.bmp"));
			bufis=new MyBufferedInputStream(new FileInputStream("F:/bigniu.bmp"));
			for(int i=bufis.myRead();i!=-1;i=bufis.myRead())
				bufos.write(i);
		}
		catch (FileNotFoundException e)
		{
			e.printStackTrace();
		}
		catch(IOException e)
		{
			e.printStackTrace();
		}
		finally
		{
			if(bufos!=null)
			{
				 try
				 {
					bufos.close();
				 }
				 catch (IOException e)
				 {
					 e.printStackTrace();
				 }
			}
			if(bufis!=null)
			{
				try
				{
					bufis.myClose();
				}
				catch (IOException e)
				{
					e.printStackTrace(); 
				}
			}
		}
	}
}

三、操作流的步骤

1.明确目标

2.选择操作流的方式

3.思考程序安全性及效率

四、数据流的转换

import java.io.*;
class  TransStreamDemo
{
	/*
	通过查询API可以看到，System.in是一个InputStream类引用,它的目标是键盘,这是一个标准输入流
	System.out是PrintStream类引用，它的目标是控制台，这是一个标准输出流
	并且两个标准流都是字节流
	当需要将这两个流的目标改成字符流的操作方式时，就可以用转换流来完成。
	InputStreamReader:将输入字节流转成输入字符流
	OutputStreamWriter:将输出字节流转成输出字符流
	*/
	public static void main(String[] args) 
	{
		/*将标准输入输出流转换成字符流，完成行的读写操作
		1.目标：
			键盘，控制台
		2.操作流的方式：
			字符流，由于要使用标准输入输出流，需要转换
		3.异常和效率
			异常必须处理
			加入缓冲流提高效率，同时获得对行操作的功能
		*/

		BufferedReader br=null;
		BufferedWriter bw=null;
		try
		{
			br=new BufferedReader(new InputStreamReader(System.in));
			bw=new BufferedWriter(new OutputStreamWriter(System.out));
			bw.write(br.readLine().toUpperCase());
			bw.newLine();
			bw.flush();
		}
		catch (IOException e)
		{
		}
		finally
		{
			if(br!=null)
			{
				try
				{
					br.close();
				}
				catch (IOException e)
				{
				}
			}
			if(bw!=null)
			{
				try
				{
					bw.close();
				}
				catch (IOException e)
				{
				}
			
			}
		}
	}
}