IO流

xumingjie1

于 2013-09-19 16:12:58 发布

阅读量751

点赞数

分类专栏：日记文章标签： io流

本文链接：https://blog.csdn.net/xu_code/article/details/11830933

版权

日记专栏收录该内容

43 篇文章 0 订阅

订阅专栏

IO流用来处理设备之间的数据传输，Java对数据的操作时通过流的方式

Java用于流的对象都包括在IO包中，流按操作流数据分为两种：字节流与字符流，按流向分为：输入流，输出流

字节流的抽象基类：

InputStream ,OutputStream

字节流的抽象基类：

Reader, Writer

由这四个类派生出来的子类名称都是以其父类名做为子类名的后缀，例如：InputStream的子类FileInputStream

package cn.baidu.com;

import java.io.*;

public class FileWriterDemo {

	public static void main(String[] args) throws IOException
	{
		// TODO Auto-generated method stub
		//创建一个FileWriter对象，该对象一被初始化就必须要明确被操作的文件。
		//而且该文件会被创建到指定目录下，如果该目录下已有同名文件，将被覆盖
		//其实该步骤就是在明确要存放的目的地。
		FileWriter fw=new FileWriter("F:\\Demo.txt");
		//调用write方法，将字符串写入到流中
		fw.write("nidaye de");
		//刷新流对象中的缓冲中的数据
		//将数据刷到目的地中
		//fw.flush();
		
		//关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据
		//将数据刷到目的地中
		//和flush的区别:flush刷新后，流可以继续使用，close刷新后，流会关闭
		fw.close();
		
	}

}

IO 异常的处理方式

package cn.baidu.com;

import java.io.*;

public class FileWriterDemo2 {

	public static void main(String[] args) {
		FileWriter fw=null;
		try
		{
			fw=new FileWriter("F:\\Demo.txt");
			fw.write("sdafda");
			fw.close();
		}
		catch(IOException e)
		{
			System.out.println("catch"+e.toString());
		}
		finally
		{
			try
			{
				if(fw!=null)fw.close();
			}
			catch(IOException e)
			{
				System.out.println("catch"+e.toString());
			}
		}
		
	}

}

在已有数据文件中续写：在文件中追加数据

package cn.baidu.com;
import java.io.*;
public class FileWriterDemo3 {

	public static void main(String[] args) {
		//传递一个true参数，代表不覆盖已有的文件，并在已有文件的末尾处进行续写
		
		FileWriter fw=null;
		try
		{
			fw=new FileWriter("F:\\Demo.txt",true);
			fw.write("sdafda\r\nsdfs");
		}
		catch(IOException e)
		{
			System.out.println("catch"+e.toString());
		}
		finally
		{
			try
			{
				if(fw!=null)fw.close();
			}
			catch(IOException e)
			{
				System.out.println("catch"+e.toString());
			}
		}
	}

}

读取文件

读取方式一：

package cn.baidu.com;
import java.io.*;
public class FileReaderDemo {

	public static void main(String[] args) {
		
		//创建一个文件读取流对象，和指定的名称相关联。
		//要保证该文件时已经存在的，如果不存在，会发生异常FileNotFoundException
		FileReader fr=null;
		try {
			fr= new FileReader("F:\\Demow.txt");
	
		} 
		catch (FileNotFoundException e) {
			
			try {
				//调用读取流对象的read()方法
				//read() 一次读取一个字符，而且会自动往下读。
				int ch=0;
				while((ch=fr.read())!=-1)
				{
					System.out.println((char)ch);
				}
			} 
			catch (IOException e1) {
				e1.printStackTrace();
			}
		}
		finally
		{
			try {
					fr.close();
				} 
			catch (IOException e) {
					e.printStackTrace();
			}
		}
		
		
	}

}

读取文件方式二：通过字符数组读取

package cn.baidu.com;

import java.io.*;

public class FileReaderDemo2 {

	public static void main(String[] args) throws IOException
	{
		FileReader fr=new FileReader("F:\\Demo.txt");
		//定义一个字符数组，用于存储读到的字符
		//该read(char[]) 返回的是读到的字符个数
		char[] buf=new char[1024];
		int num =0;
		while((num =fr.read(buf))!=-1)
		{
			System.out.println(new String(buf,0,num));
		}
		fr.close();

	}

}

读取一个JAVA文件，并显示在控制台上

package cn.baidu.com;

import java.io.*;

public class FileReaderDemo2 {

	public static void main(String[] args) throws IOException
	{
		FileReader fr=new FileReader("F:\\Demo.txt");
		//定义一个字符数组，用于存储读到的字符
		//该read(char[]) 返回的是读到的字符个数
		char[] buf=new char[1024];
		int num =0;
		while((num =fr.read(buf))!=-1)
		{
			System.out.println(new String(buf,0,num));
		}
		fr.close();

	}

}

文件的复制

package cn.baidu.com;

import java.io.*;

public class CopyText {

	public static void main(String[] args) throws IOException {
		copy_2();

	}
	public static void copy_1() throws IOException
	{
		//创建文件
		FileWriter fw=new FileWriter("F:\\Demoq.txt");
		//与已有文件关联
		FileReader fr=new FileReader("F:\\Demo.txt");
		int ch=0;
		while((ch=fr.read())!=-1)
		{
			fw.write(ch);
		}
		fw.close();
		fr.close();
				
	}
	public static void copy_2() throws IOException
	{
		FileWriter fw=null;
		FileReader fr=null;
		try
		{
			fw=new FileWriter("F:\\Demos.txt");
			fr=new FileReader("F:\\Demo.txt");
			
			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)
				{
					
				}
				finally
				{
					
				}
			}
			if(fw!=null)
			{
				try
				{
					fw.close();
				}
				catch(IOException e)
				{
					
				}
			}
		}
	}
	
	

}

图片的复制

package cn.baidu.com;

import java.io.*;

public class CopyText {

	public static void main(String[] args) throws IOException {
		copy_2();

	}
	public static void copy_1() throws IOException
	{
		//创建文件
		FileWriter fw=new FileWriter("F:\\Demoq.txt");
		//与已有文件关联
		FileReader fr=new FileReader("F:\\Demo.txt");
		int ch=0;
		while((ch=fr.read())!=-1)
		{
			fw.write(ch);
		}
		fw.close();
		fr.close();
				
	}
	public static void copy_2() throws IOException
	{
		FileWriter fw=null;
		FileReader fr=null;
		try
		{
			fw=new FileWriter("F:\\Demos.txt");
			fr=new FileReader("F:\\Demo.txt");
			
			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)
				{
					
				}
				finally
				{
					
				}
			}
			if(fw!=null)
			{
				try
				{
					fw.close();
				}
				catch(IOException e)
				{
					
				}
			}
		}
	}
	
	

}

字符流的缓冲区

对应类：BufferedWriter BufferedReader

缓冲区要结合流才可以使用，在流的基础上对流的基础进行了增强

package cn.baidu.com;

import java.io.*;

/*
 * 缓冲区的出现是为了提高流的操作效率而出现的。
 * 所以在创建缓冲区之前，必须要先有流对象
 * 该缓冲区中提供了一个跨平台的换行符 newLine()
 */
public class BufferedWriterDemo {

	public static void main(String[] args) throws IOException {
		//创建一个字符写入流对象
		FileWriter fw=new FileWriter("F:\\Demow.txt");
		//为了提高字符写入流效率，加入了缓冲技术，只要将需要提高的流
		//对象传递给缓冲区的构造函数即可。
		BufferedWriter bufw=new BufferedWriter(fw);
		
		for(int x=1;x<5;x++)
		{
			bufw.write("而卧对的撒sdfssfd"+x);
			//只要用到缓冲区，就要记得刷新
			bufw.newLine();
			bufw.flush();
		}
		//其实关闭缓冲区，就是在关闭缓冲区中的流对象
		bufw.close();
	}


}

字符读取流缓冲区

package cn.baidu.com;

import java.io.*;

/*
 * 字符读取流缓冲区
 * 该缓冲区提供了一个一次读一行的方法 readLine 方法于对文本数据的获取
 * 当返回null，表示读到文件的末尾
 * readLine方法返回的时候只返回回车符之前的数据内容，并不返回回车符
 */

public class BufferedReaderDemo {

	public static void main(String[] args) throws IOException {
		//创建一个读取流对象和文件相关联
		FileReader fr=new FileReader("F:\\Demo.txt");
		//为了提高效率，加入缓冲技术，将字符读取流对象作为参数传递给缓冲对象的构造函数
		BufferedReader butr=new BufferedReader(fr);
		String line=null;
		while((line=butr.readLine())!=null)
		{
			System.out.println(line);
		}
		
		butr.close();
		
	}

}

通过缓冲区复制一个文件

package cn.baidu.com;
/*
 * 通过缓冲区复制一个.java文件
 */
import java.io.*;
public class CopyTextByBuf {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		BufferedReader bufr=null;
		BufferedWriter bufw=null;
		try
		{
			bufr=new BufferedReader(new FileReader("F:\\Demo.txt"));
			bufw=new BufferedWriter(new FileWriter("F:\\Demonew.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("写关闭失败");
			}
			
		}
	}

}

自己写的MyBufferedReader

package cn.baidu.com;
/*
 * 在明白了BufferedReader类中特有方法readLine类中特有方法readLinde的原理后
 * 可以自定义一个类中包含一个功能和readLine一致的方法，来模拟一下bufferedReader
 */
import java.io.*;
class MyBufferedReader 
{
	private FileReader r;
	MyBufferedReader(FileReader r)
	{
		this.r=r;
	}
	//可以一次读一行数据的方法
	public String myReadLine() throws IOException
	{
		//定义一个临时容器，原BufferedReader封装的是字符数组
		//为了演示方便，定义一个StringBuilder容器，因为最终还是要将数据变成字符串
		StringBuilder sb=new StringBuilder();
		int ch=0;
		while((ch=r.read())!=-1)
		{
			if(ch=='\r')
			{
				continue;
			}
			if(ch=='\n')
			{
				return sb.toString();//到行结尾，把一行字符返回
			}
			else
			{
				sb.append((char)ch);//继续读
			}
		}
		if(sb.length()!=0)//处理结尾没有回车符的情况
		{
			return sb.toString();
		}
		return null;//到文件结尾，无数据了
	}
	public void myClose() throws IOException
	{
		r.close();
	}

}

public class MyBufferedReaderDemo {

	public static void main(String[] args) throws IOException {
		FileReader fr=new FileReader("F:\\Demo.txt");
		MyBufferedReader mybuf=new MyBufferedReader(fr);
		String line=null;
		while((line=mybuf.myReadLine())!=null)
		{
			System.out.println(line);
		}
		mybuf.myClose();
	}

}

装饰设计模式

/*
* 装饰设计模式比继承更灵活，避免了继承体系的臃肿
* 而且降低了类与类之间的关系
*
* 装饰类因为增强已有对象，具备的功能和已有的是形同的，只不过提供了更强的功能
* 所以装饰类和被装饰类都是属于一个体系中的。
*
* 当想到要对已有的对象进行功能增强时。
* 可以定义类，将已有对象传入，基于已有的功能，并提供加强功能
* 那么自定义的该类称为装饰类
*
* 装饰类通常会通过构造方法接收被装饰的对象
* 并基于被装饰的对象提供更强的功能
*/

package cn.baidu.com;

class Person
{
	public void eat()
	{
		System.out.println("吃饭");
	}
}
class SuperPerson
{
	private Person p;
	SuperPerson(Person p)
	{
		this.p=p;
	}
	public void supereat()
	{
		System.out.println("开胃菜");
		System.out.println("喝红酒");
		p.eat();
		System.out.println("唱K");
	}
}
public class PersonDemo {

	public static void main(String[] args) {
		 Person p=new Person();
		 SuperPerson sp=new SuperPerson(p);
		 sp.supereat();
	}

}

package cn.baidu.com;

import java.io.*;

public class LineNumberReaderDemo {

	public static void main(String[] args) throws IOException
	{
		FileReader fr=new FileReader("F:\\Demo.txt");
		LineNumberReader lnr=new LineNumberReader(fr);
		
		String line=null;
		lnr.setLineNumber(100);
		while((line=lnr.readLine())!=null)
		{
			System.out.println(lnr.getLineNumber()+":"+line);
		}
		lnr.close();
		

	}

}

在明白其原理后，自己写一个

MyLineNumberReader

package cn.baidu.com;

import java.io.*;
/*
class MyLineNumberReader
{
	private Reader r;
	private int lineNumber;
	MyLineNumberReader(Reader r)
	{
		this.r=r;
	}
	public void setLineNumber(int lineNumber)
	{
		this.lineNumber=lineNumber;
	}
	public String myReadLine() throws IOException
	{
		lineNumber++;
		StringBuilder sb=new StringBuilder();
		int ch=0;
		while((ch=r.read())!=-1)
		{
			if(ch=='\r')
				continue;
			if(ch=='\n')
				return sb.toString();
			else
				sb.append((char)ch);
		}
		if(sb.length()!=0)
			return sb.toString();
		return null;
	}
	public int getLineNumber()
	{
		return lineNumber;
	}
	public void myClose() throws IOException
	{
		r.close();
	}
}
*/
class MyLineNumberReader extends MyBufferedReader
{
	private Reader r;
	private int lineNumber;
	MyLineNumberReader(FileReader r)
	{
		super(r);
	}
	public String myReadLine() throws IOException
	{
		lineNumber++;
		return super.myReadLine();
		
	}
	public int getLineNumber()
	{
		return lineNumber;
	}
	public void setLineNumber(int lineNumber)
	{
		this.lineNumber=lineNumber;
	}
}

public class MyLineNumberReaderDemo {

	public static void main(String[] args) throws IOException 
	{
		FileReader fr=new FileReader("F:\\Demo.txt");
		MyLineNumberReader mylnr=new MyLineNumberReader(fr);
		String line=null;
		mylnr.setLineNumber(100);//初始行号设置为100
		while((line=mylnr.myReadLine())!=null)
		{
			System.out.println(mylnr.getLineNumber()+":"+line);
		}
		mylnr.myClose();
		

	}

}

/*
* 字符流
* FileReader
* FileWriter
* BufferedReader
* BufferedWriter
*
* 字节流：
* InputStream OutputStream
* 需求：想要操作图片数据，这是就要用到字节流
*/

package cn.baidu.com;

import java.io.*;
public class FileOutStreamDemo {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		//writeFile();
		readFile_2();
	}
	public static void readFile_3() throws IOException
	{
		FileInputStream fis=new FileInputStream("F:\\Demoaaaa.txt");
		byte[] buf=new byte[fis.available()];//定义一个刚刚好的缓冲区，不用再循环了
		fis.read(buf);
		System.out.println(new String(buf));
		fis.close();
		
	}
	public static void readFile_2() throws IOException
	{
		byte[] buf=new byte[1024];
		int len=0;
		FileInputStream fis=new FileInputStream("F:\\Demoaaaa.txt");
		while((len=fis.read(buf))!=-1)
		{
			System.out.println(new String(buf,0,len));
		}
	}
	public static void readFile_1() throws IOException
	{
		FileInputStream fis=new FileInputStream("F:\\Demoaaaa.txt");
		int ch=0;
		while((ch=fis.read())!=-1)
		{
			System.out.println((char)ch);
		}
	}
	public static void writeFile() throws IOException
	{
		FileOutputStream fos=new FileOutputStream("F:\\Demoaaaa.txt");
		fos.write("大哥，我想你".getBytes());
		fos.close();
	}

}

/*
* 复制一个图片
* 思路：
* 1.用字节流读取流对象和图片关联
* 2.用字节写入流对象创建一个图片文件，用于存储获取的图片数据
* 3.通过循环读写，完成数据的存储
*/

package cn.baidu.com;

import java.io.*;
public class CopyPic {

	public static void main(String[] args) {
		FileOutputStream fos=null;
		FileInputStream fis=null;
		try
		{
			fis =new FileInputStream("F:\\old.jpg");//读取目标文件
			fos =new FileOutputStream("F:\\new.jpg");//写入新文文件

			
			byte[] buf=new byte[1024];
			int len=0;
			while((len=fis.read(buf))!=-1)
			{
				fos.write(buf,0,len);
			}
		}
		catch(Exception e)
		{
			throw new RuntimeException("复制文件失败");
		}
		finally
		{
			try
			{
				if(fis!=null)
				{
					fis.close();
				}

			}
			catch(Exception e)
			{
				throw new RuntimeException("读取关闭失败失败");
			}
			try
			{
				if(fos!=null)
				{
					fos.close();
				}

			}
			catch(Exception e)
			{
				throw new RuntimeException("写入关闭失败失败");
			}
		}
	}

}

------------------------------------------------------------------------------------------------------------

* 读取键盘录入
* System.out对应的是标准输出流，控制台
* 需求：
* 通过键盘录入数据，就将该行数据进行打印
* 如果录入的数据是over,那么停止录入

package cn.baidu.com;
import java.io.*;

public class Readin {

	public static void main(String[] args) throws IOException {
		InputStream in=System.in;
		StringBuilder sb=new StringBuilder();
		while(true)
		{
			int ch=in.read();
			
			if(ch=='\r')
				continue;
			if(ch=='\n')
			{
				String s=sb.toString();
				if("over".equals(s))
					break;
				System.out.println(s.toUpperCase());
				sb.delete(0,sb.length());
				
			}
			else
				sb.append((char)ch);		
		}

	}

}

转换流

package cn.baidu.com;
import java.io.*;
public class TransStreamDemo {

	public static void main(String[] args) throws IOException {
		//获取键盘录入对象
		InputStream in=System.in;
		//将字节流对象转成了字符流对象，使用转换流。InputStreamReader
		InputStreamReader isr=new InputStreamReader(in);
		//为了提高效率，将字符串进行缓冲区高效操作，使用BufferedReader
		BufferedReader buff=new BufferedReader(isr);
		String line=null;
		while((line=buff.readLine())!=null)
		{
			if("over".equals(line))
				break;
			System.out.println(line.toUpperCase());
		}
		buff.close();
	}

}

package cn.baidu.com;
import java.io.*;
public class TransStreamDemo2 {

	public static void main(String[] args) throws IOException {
		//获取键盘录入对象
		//InputStream in=System.in;
		//将字节流对象转成了字符流对象，使用转换流。InputStreamReader
		//InputStreamReader isr=new InputStreamReader(in);
		//为了提高效率，将字符串进行缓冲区高效操作，使用BufferedReader
		//BufferedReader buff=new BufferedReader(isr);
		
	    //键盘录入最常见写法
		BufferedReader buff=
				new BufferedReader(new InputStreamReader(System.in));
		
		//OutputStream out=System.out;
		//OutputStreamWriter osw =new OutputStreamWriter(out);
		//BufferedWriter bufw=new BufferedWriter(osw);
		
		BufferedWriter bufw=
				new BufferedWriter(new OutputStreamWriter(System.out));
		
		String line=null;
		
		while((line=buff.readLine())!=null)
		{
			if("over".equals(line))
				break;
			bufw.write(line.toUpperCase());
			bufw.newLine();
			bufw.flush();
		}
		buff.close();
	}

}

/*
* 1.需求：想把键盘录入的数据存储到一个文件中。
* 源：键盘
* 目的：文件
* 2.需求：想要将一个文件的数据打印在控制台上
* 源：文件
* 目的：控制台
*
* 流操作的基本规律
* 通过两个明确来完成
* 1.明确源和目的
* 源：输入流 InputStream Reader
* 目的：输出流 OutputStream Writer
* 2.操作的数据是否是纯文本
* 是：字符流
* 不是：字节流
* 3.当体系明确后，在明确要使用哪个具体的对象
* 通过设备来进行区分
* 源设备：内存、硬盘、键盘
* 目的设备：内存、硬盘、控制台
*
* 1.将一个文本文件中数据存储在另外一个文件中，复制文件
* 源：因为是源，所以使用读取流。InputStream Reader
* 是不是操作文本文件。
* 是这时选择Reader
* 这样体系就明确了
*
* 接下来明确要使用该体系中的哪个对象
* 明确设备：硬盘上一个文件
* Reader体系中可以操作文件的对象时FileReader
*
* 是否需要提高效率：是加入Reader体系中缓冲区 BufferedReader
*
*
* FileReader fr=new FileReader("a.txt");
* BufferedReader bufr=new BufferedReader(fr);
*
* 目的：OutputStream Writer
* 是否是纯文本
* 设备：硬盘一个文件
* Writer体系中可以操作文件的对象FileWriter
*
* FileWriter fr=new FileWriter("b.txt");
* BufferedWriter bufw =new BufferedWriter(fw);
*
*
*
* 2.需求：将键盘录入的数据保存到一个文件中
* 源：InputStream Reader
* 是不是纯文本是 Reader
* 设备：键盘，对应的对象时System.in
* 为了操作键盘文本数据方便，转成字符串操作是最方便的
* 用了Reader体系中转换流，InputStreamReader
*
* InputStreamReader isr=new InputStreamReader(System.in);
* 提高效率 BufferedReader
* BufferedReader buff=new BufferedReader(isr);
*
* 目的: OutputStream Writer
* 是否是纯文本是 Writer
* 设备：硬盘一个文件使用FileWriter
*
* 存储时，需要加入指定编码表，而指定的编码表只有转换流可以指定
* 所以要使用的对象时OutputStreamWriter
* 而该转换流对象要接收一个字节输出流，而且还可以操作的文件的字节输出流，FileOutputStream
* OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("d.txt"),"UTF-8");
*
* 考虑效率
* BufferedWriter bufw =new BufferedWrier(osw);
* 转换流怎么使用，字符和字节之间的桥梁，通常，涉及到字符编码转换时，需要用到转换流
*
*
*FileWriter fw=new FileWriter("c.txt");
*效率 BufferedWriter
*BufferedWriter bufw=new BufferedWriter(fw);
*

package cn.baidu.com;
import java.io.*;

public class TransStreamDemo3 {

	public static void main(String[] args) throws IOException {
	    //键盘录入最常见写法
		BufferedReader buff=
				new BufferedReader(new InputStreamReader(System.in));
		
		BufferedWriter bufw=
				new BufferedWriter(new OutputStreamWriter(new FileOutputStream("F:\\out.txt")));
		
		String line=null;
		
		while((line=buff.readLine())!=null)
		{
			if("over".equals(line))
				break;
			bufw.write(line.toUpperCase());
			bufw.newLine();
			bufw.flush();
		}
		buff.close();
	}

}

建立日志文件，写入程序运行信息

package cn.baidu.com;
import java.io.*;
import java.text.SimpleDateFormat;
import java.util.*;

public class ExceptionInfo {

	public static void main(String[] args) throws IOException {
		Properties Prop=System.getProperties();
		Prop.list(new PrintStream("F:\\sysinfo.txt"));//把系统信息写入到日志文件中
		try
		{
			int[] arr=new int[2];
			System.out.println(arr[3]);
		}
		catch(Exception e)
		{
			try
			{
				Date d=new Date();
				SimpleDateFormat sdf=new SimpleDateFormat("yy-MM-dd HH-mm-ss");
				String s=sdf.format(d);
				PrintStream ps=new PrintStream("F:\\exeception.log");
				ps.print(s);
				System.setOut(ps);
			}
			catch(IOException ex)
			{
				throw new RuntimeException("日志文件创建失败");
				
			}
			
			e.printStackTrace(System.out);
		}
	}

}