JAVASE----14----IO流

最新推荐文章于 2020-06-04 23:31:09 发布

雨之希留

最新推荐文章于 2020-06-04 23:31:09 发布

阅读量805

点赞数 1

分类专栏： JAVASE

本文链接：https://blog.csdn.net/lc635408136/article/details/8776120

版权

JAVASE 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

IO(Input Output)流:

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

·Java用于操作流的对象都在IO包中

·流按操作数据分为两种：字节流和字符流
·流按刘翔分为：输入流，输出流

IO流常用基类：

· 字节流的抽象基类:
`InputStream ,OutputStream

· 字符流的抽象基类:

`Reader ，Writer

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

如：Reader的子类FileReader

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

1，FileWriter

import java.io.FileWriter;
import java.io.IOException;


public class FileWriterDemo {

	/**
	 * 需求：在硬盘上，创建一个文件并写入一些文字数据
	 * 找到一个专门用于操作文件的Writer子类对象。FileWriter。后缀是父类名。前缀是该流对象的功能。
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		//创建一个FileWriter对象，该对象一被初始化就必须要明确被操作的文件。
		//而且该文件会被创建到指定目录下。如果该目录下已有同名文件，将被覆盖。
		//其实该步就是在明确数据要存放的目的地。
		FileWriter fw=new FileWriter("demo.txt");
		
		
		//调用write方法，将字符串写入到流中。
		
		fw.write("adsad");
		
		//刷新流对象的缓冲数据，将数据刷到目的地中。
		//fw.flush();
		
		/*关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据。
		将数据刷到目的地中，和flush区别：
		flash刷新后，流可以继续使用，close刷新后，会将流关闭*/
		fw.close();
		
		
		
		
		
             		
	}

}

2,IO异常处理方式：

import java.io.FileWriter;
import java.io.IOException;


public class FileWriterDemo2 {

	/**
	 * IO异常的处理方式
	 */
	public static void main(String[] args) {
		FileWriter fw=null;
		try {
		    fw=new FileWriter("k:\\demo.txt");   
			fw.write("adsad");
			
		} catch (IOException e) {
			// java.io.FileNotFoundException: k:\demo.txt (系统找不到指定的路径。)
			e.printStackTrace();
		}
		finally
		{
			try {
				if(fw!=null)
				fw.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

	}

}

3，文件数据的续写：

import java.io.FileWriter;
import java.io.IOException;


public class FileWriterDemo2 {

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

	}

}

4，FileReader1

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;


public class FileReaderDemo {

	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		//创建一个文件读取流对象，和指定名称的文件相关联。
		//要保证该文件是已经存在的，如果不存在，
		
			FileReader fr=new FileReader("demo.txt");
			//调用读取流对象的	read方法
			//read():一次读一个字符，而且会自动往下读
			int ch=0;
			while(( ch=fr.read())!=-1)
			{
				System.out.println((char)ch);
			}
			fr.close();
	}
	

}

FileReader2:

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;


public class FileReaderDemo {

	/**
	 * 第二种方式：通过字符数组进行读取
	 */
	public static void main(String[] args) throws IOException {
	
		
			FileReader fr=new FileReader("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();
			
	}
	

}

练习：

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;


public class CopyTest {

	/**
	 * 将C盘一个文件复制到D盘
	 * 复制原理：其实就是将C盘下的文件数据存储到D盘的一个文件中。
	 * 
	 * 步骤：
	 * 1，在D盘创建一个文件，用于存储C盘文件中的数据。
	 * 2，定义一个读取流和C盘文件关联。
	 * 3，通过不断的读写完成数据存储
	 * 4，关闭资源。
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
	    
		//copy_1();
		copy_2();
	}
	public static void copy_1() throws IOException
	{
		//创建目的地
		FileWriter  fw=new FileWriter("c:\\lc.txt");
		//与已有文件关联
		FileReader  fr=new FileReader("demo.txt");
		int ch=0;
		 while((ch=fr.read())!=-1)
		 {
			 fw.write(ch);
		 }
		 fw.close();
		 fr.close();
		//result: 成功复制
	}
	
	
	
	public static void copy_2()
	{
		FileWriter  fw=null;
		FileReader  fr=null;
		
		try {
			fw=new FileWriter("c:\\li.txt");
			fr=new FileReader("demo.txt");
			
			char[]buf=new char[1024];
			int len=0;
			while((len=fr.read(buf))!=-1)
			{
				fw.write(buf,0,len);
			}
		} catch (IOException e) {
			
			//e.printStackTrace();
			throw new RuntimeException("读写失败");
		}
		finally
		{
			if(fr!=null)
			{
				try {
					fr.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			
			if(fw!=null)
			{
				try {
					fw.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		//result: 成功复制
	}

}

字符流的缓冲区
`缓冲区的出现提高了对数据的读写效率。
`对应类：BufferedWriter

BufferedReader
·缓冲区要结合流才能使用
·在流的基础上对流的功能进行了增强

5，BufferedWriter：

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;


public class BufferedWriterDemo {

	/**
	 * 缓冲区的出现	是为了提高流的操作效率而出现的。
	 * 所以在创建缓冲区之前，必须要现有流对象。
	 */
	public static void main(String[] args) {
		// 创建一个字符写入流对象
		FileWriter fw=null;
		try {
		   fw=new FileWriter("c:\\BufferedDemo.txt");
			//为了提高字符写入流效率。加入了缓冲技术
			//只要将需要提高效率的流对象作为参数传递给缓冲区的构造函数即可
			BufferedWriter bw=new BufferedWriter(fw);
			bw.write("abcde");
			bw.newLine(); //跨平台换行符
			//记住，只要用到缓冲区，就要记得刷新
			//bw.flush();
			//其实关闭缓冲区就是在关闭缓冲区的流对象。
			bw.close();
		} catch (IOException e) {
			
			e.printStackTrace();
		}
		
		
		

	}

}

6，BufferedReader

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;


/* 字符读取流缓冲区
该缓冲区提供了一次毒一行的方法readline，方便对文本数据的获取。
当返回null时读到文件末尾。*/
public class BufferedReaderDemo {
	public static void main(String[] args) throws IOException {
	      //创建一个读取流对象和文件相关联
		FileReader fr=new FileReader("demo.txt");
		//为了提高效率，加入缓冲技术，将字符流读取对象作为参数传递给缓冲对象的构造函数
		BufferedReader br=new BufferedReader(fr);
		String line=null;
		while((line=br.readLine())!=null)
		{
			System.out.println(line);
		}
		
	}
}

练习：

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyTextMybuff {

	/**
	 * 通过缓冲区复制一个文件
	 */
	public static void main(String[] args) {
		BufferedWriter bufw = null;
		BufferedReader bufr = null;

		try {
			bufr = new BufferedReader(new FileReader("demo.txt"));
			bufw = new BufferedWriter(new FileWriter("copy.txt"));
			String line = null;
			while ((line = bufr.readLine()) != null) {
				bufw.write(line);
				bufw.newLine();
				bufw.flush();
			}
		} catch (IOException e) {

			e.printStackTrace();
		} finally {
			
			try {
				if (bufr != null)

					bufr.close();
			} catch (IOException e) {
			
				e.printStackTrace();
			}
			
			try {
				if (bufw != null)

					bufw.close();
			} catch (IOException e) {
			
				e.printStackTrace();
			}
		}

	}

}

7,readLine();

通过自写BufferedReader，了解一种设计模式。

import java.io.FileReader;
import java.io.IOException;


public class MyBufferedReader {

	private  FileReader r;
	public MyBufferedReader(FileReader r)
	{
	      this.r=r;
	}
	
	/*
	 * 明白了 BufferedReader.readLine()的原理后
	 * 可以自定义一个类中包含一个功能和readLine一致的方法来模拟 BufferedReader
	 */
	//可以一次读一行数据的方法
	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 static void main(String[] args) {
		FileReader fr=null;
		MyBufferedReader mr=null;
		try {
		 fr=new FileReader("demo.txt");
		 mr=new MyBufferedReader(fr);
		String line=null;
		while((line=mr.myReadLine())!=null)
		{System.out.println(line);}
		}
		catch (IOException e) {

			e.printStackTrace();
		}
		finally
		{
			try {
				fr.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	       
	}

}

public class PersonDemo {

	/**
	 * 装饰设计模式：
	 * 当想要对已有的对象进行功能增强时，可以定义类，将已有对象传入，基于已有的功能，
	 * 并提供加强功能。那么被定义的该类称为装饰类，
	 * 装饰类通常会通过构造方法接收被装饰对象，并基于被装饰的对象的功能，提供更强的功能。
	 * 
	 */
	
	public static void main(String[] args) {
	 Person p=new Person();
	 SuperPerson sp=new SuperPerson(p);
	 sp.supereat();
	 //吃饭
	 //甜点

	}

}


class Person
{
	public void eat()
	{
		System.out.println("吃饭");
	}
}

class SuperPerson
{
	private Person p;
	SuperPerson(Person p)
	{
		this.p=p;
		
	}
	public void supereat()
	{
		p.eat();
		System.out.println("甜点");
	}
}

8，衍生过程：

/*
MyReader //专门用于读取数据的类
  |--MyTextReader
      |--MyBufferTextReader
  |--MyMediaReader
      |--MyBufferMediaReader
  |--MyDataReader   
      |--MyBufferDataReader
      
--用继承体系设计太过臃肿，于是：

class MyBufferReader
{
    MyBufferReader(MyTextReader text){}
    MyBufferReader(MyMediaReader midia){}
}
--上面这个类扩展性很差
找到其参数的共同类型，通过多态的形式，可以提高扩展性。
class MyBufferReader extends  MyReader
{
  MyBufferReader(MyReader  r)
  {}
}


所以 衍生为：

MyReader //专门用于读取数据的类
  |--MyTextReader
  |--MyMediaReader
  |--MyDataReader   
  |--MyBufferReader   
*/

//装饰模式比继承要灵活，避免了继承体系臃肿，而且降低了类与类之间的关系。
//装饰类因为增强已有对象，具备的功能和已有是相同的，只不过提供了更强的功能，所以装饰类和被装饰类都属一个体系。

public class test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}

}

装饰类的例子，继承自BufferedReader的：

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.LineNumberReader;


public class LineNumberReaderDemo {

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

}

自己实现：

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

//自己实现：LineNumberReader
//在源代码中 LineNumberReader是继承了BufferedReader的。所以结合自定义的MyBufferedReader来实现。


class  MyLineNumberReader extends MyBufferedReader
{
 
      private int lineNumber;
      MyLineNumberReader(Reader r)
      {
    	  super(r);
      }
      public String myReadLine() throws IOException
      {
    	  lineNumber++;
    	  //源码中用的数组
     	  StringBuilder sb=new StringBuilder();
    	  return super.myReadLine();
      }
	public int getLineNumber() {
		return lineNumber;
	}
	public void setLineNumber(int lineNumber) {
		this.lineNumber = lineNumber;
	}
	
      
      
}

public class MyLineNumberReaderDemo {

	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		FileReader  fr= new FileReader("demo.txt");
		MyLineNumberReader mur=new MyLineNumberReader(fr);
		String line=null;
		mur.setLineNumber(100);
		while((line=mur.myReadLine())!=null)
		{
			System.out.println(mur.getLineNumber()+":"+line);
		}
		mur.myClose();
	}

}

9，字节流：

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;


public class FileStream {

	/**
	 * 字符流：FileReader  FileWriter
	 * BufferedReader  BufferedWriter
	 * 
	 * 字节流：
	 * InputStream OutputStream
	 * 
	 */
	public static void main(String[] args) throws IOException {
		writeFile(); //产生一个fos.txt的文件
		readFile();
		//d
		//a
		//s
		//d
		//a
		readFile_2(); //adasda
		readFile_3(); //adasda
	}
	public static void writeFile() throws IOException
	{
		FileOutputStream fos=new FileOutputStream("fos.txt");
		fos.write("adasda".getBytes());  //不需要刷新，直接操作字节
		fos.close();
	}
	public static void readFile() throws IOException
	{
		FileInputStream fis=new FileInputStream("fos.txt");
		int ch=0;
		while((ch=fis.read())!=-1)
		{
			System.out.println((char)ch);
		}
		fis.close();
		
	}
	public static void readFile_2() throws IOException
	{
		FileInputStream fis=new FileInputStream("fos.txt");
		byte[] buf=new byte[1024];
		int len=0;
		while((len=fis.read(buf))!=-1)
		{
			System.out.println(new String(buf,0,len));
		}
		fis.close();
	}
	
	public static void readFile_3() throws IOException
	{
		FileInputStream fis=new FileInputStream("fos.txt");
		byte[] buf=new byte[fis.available()]; //定义一个刚刚好的缓冲区，不用再循环
		//但是内存可能溢出，此方法要慎用。
		fis.read(buf);
		System.out.println(new String(buf));
	}
	

}

练习：

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

import javax.management.RuntimeErrorException;

public class CopyPic {

	/**
	 * 复制一个图片 思路： 1，用字节读取流对象和图片关联 2，用字节写入流创建一个图片文件，用于存储获取到的图片数据。
	 * 3，通过循环读写，完成数据的存储。 4，关闭资源。
	 * 
	 * @throws
	 */
	public static void main(String[] args) {
		FileOutputStream fos = null;
		FileInputStream fis = null;

		try {
			fos = new FileOutputStream("c:\\1.jpg");
			fis = new FileInputStream("D:\\photo\\雨之希留.jpg");
			byte[] buf = new byte[1024];
			int len = 0;
			while ((len = fis.read(buf)) != -1) {
				fos.write(buf, 0, len);
			}
		} catch (IOException e) {
			throw new RuntimeException("复制文件失败");

		} finally {
			try {
				if (fis != null) {

					fis.close();
				}
			} catch (IOException e) {
				throw new RuntimeException("读取关闭失败");
			}

			try {
				if (fos != null) {

					fos.close();
				}
			} catch (IOException e) {
				throw new RuntimeException("写入关闭失败");
			}
		}
	}

}

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;


public class CopyMp3 {

	/**
	 *通过缓冲区实现MP3的复制
	 *BufferedOutputStream
	 *BufferedInputStream
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException  {
		long start=System.currentTimeMillis();
		copy_01();
		long end=System.currentTimeMillis();
	 System.out.println((end-start)+"毫秒");
		
	}
	public static void copy_01() throws IOException
	{
		BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("C:\\haha.mp3"));
		BufferedInputStream bis=new BufferedInputStream(new FileInputStream("E:\\KuGou\\童丽 - 梦江南.mp3"));
		int by=0;
		while((by=bis.read())!=-1)
		{
			bos.write(by);
		}
		bos.close();
		bis.close();
	}

}

import java.io.IOException;
import java.io.InputStream;


public class MyBufferedInputStream {

	private InputStream in;
	private byte buf[]=new byte[1024];
	private int pos=0,count=0;
	MyBufferedInputStream(InputStream in)
	{
		this.in=in;
	}
	//一次读一个字节，从缓冲区(字节数组)获取
	public int myRead() throws IOException
	{
		//通过in对象读取硬盘上的数据，并存储到buf中
		if(count==0)
		{
		count=in.read(buf);
		if(count<-1)
			return -1;
		pos=0;
		byte b=buf[pos];
		count--;
		pos++;
		return b&255;
		}
		else if(count>0)
		{
			byte b=buf[pos];
			count--;
			pos++;
			return b&0xff;
		}
		return -1;
	}
	public void  myClose() throws IOException
	{
		in.close();
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}

}

/*
 * 这样读会取不到数据，因为可能连续读到8个 1.
 * 11111111 -->提升为Int 类型那不还是-1吗， 是1的原因是因为在8个1前面补的是1导致的。
 * 那么只要在前面补0，既可以保留原字节数据不变，又可以避免-1的出现。
 * 怎么补0呢？
   11111111  11111111  11111111  11111111 
 & 00000000  00000000  00000000  11111111 
 --------------------------------------------
   00000000  00000000  00000000  11111111 
 */

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;


public class CopyMp3 {

	/**
	 *通过缓冲区实现MP3的复制
	 *BufferedOutputStream
	 *BufferedInputStream
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException  {
		long start=System.currentTimeMillis();
		copy_02();
		long end=System.currentTimeMillis();
	 System.out.println((end-start)+"毫秒");  //3032 音乐能播放。
		
	}
	public static void copy_01() throws IOException
	{
		BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("C:\\haha.mp3"));
		BufferedInputStream bis=new BufferedInputStream(new FileInputStream("E:\\KuGou\\童丽 - 梦江南.mp3"));
		int by=0;
		while((by=bis.read())!=-1)
		{
			bos.write(by);
		}
		bos.close();
		bis.close();
	}
	public static void copy_02() throws IOException
	{
		BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("C:\\haha.mp3"));
		MyBufferedInputStream bis=new MyBufferedInputStream(new FileInputStream("E:\\KuGou\\童丽 - 梦江南.mp3"));
		int by=0;
		while((by=bis.myRead())!=-1)
		{
			bos.write(by);
		}
		bos.close();
		bis.myClose();
	}

}

10，键盘录入：

import java.io.IOException;
import java.io.InputStream;


public class ReadIn {

	/*读取键盘录入
	 * System.out:对应的是标准输出设备，控制台。
	 * System.in:对应的标准输入设备，键盘。
	 * 
	 * 需求：通过键盘录入数据。
	 * 当录入一行数据后，就将该行数据进行打印。
	 * 如果录入的数据是over，那么停止录入。
	 */
	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);
        }
         
         
	}

}

改进后的写法：

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
// 源：键盘录入。目的：控制台。

public class TransStreamDemo {

	/**
	 * 通过对前面的键盘录入一行数据并打印其大写，发现其实就是读一行数据的原理
	 * 也就是readLine方法。
	 * 能不能直接使用readLine方法来完成键盘录入的一行数据的读取呢？
	 * 
	 * readLine方法是字符流BufferedReader类中的方法，而键盘录入的read方法是
	 * 字节流 InputStream方法。
	 * 那么能不能讲字节流转成字符流再使用字符流缓冲区的readLine方法呢？
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		/*
		//获取键盘录入对象
		  InputStream in=System.in;
		  //将字节流对象转换成字符流对象，使用转换流。InputStreamReader
		  InputStreamReader isr=new InputStreamReader(in);
		  //为了提高效率，将字符流进行缓冲区技术的高效操作，使用BufferedReader
		  BufferedReader buf=new BufferedReader(isr);
		  
		  */
		//键盘录入的最常见写法
		BufferedReader buf=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=buf.readLine())!=null)
		  {
			  if("over".equals(line))
  				break;
			  bufw.write(line.toUpperCase());
			  bufw.newLine();
			  bufw.flush();
		  }
		  buf.close();
	}

}

总结：
流操作的基本规律：流对象有很多，不知道该用哪一个。
通过三个明确来完成.

1,明确源和目的。
源：输入流。 InputStream Reader
目的：输出流。 OutputStream Writer

2，操作的数据是否是纯文本。
是：字符流
不是：字节流

3，当体系明确后，再明确要使用哪个具体对象
通过设备来进行区分：
源设备：内存，硬盘，键盘。
目的设备：内存，硬盘，控制台。

例子：

1,将一个文本文件中数据存储到另一文件中，复制文件。
源：因为是源，所以使用读取流，InputStream Reader
是不是操作文本文件。
是！这时就可以选择Reader，这样体系就明确了。

接下来明确要使用该体系的哪个对象。
明确设备：硬盘。、上一个文件。
Reader体系中可以操作文件的对象是 FileReader

是否需要提高效率：是！加入Reader体系中的缓冲区BufferedReader

FileReader fr=new FileReader("a.txt");
BufferedReader burr =new BufferedReader (fr);

目的： OutputStream Writer
是否是纯文本
是！ Writer
设备：硬盘，一个文本文件
Writer 体系中可以操作文件的对象是 FileWriter

是否需要提高效率：是！加入Writer体系中的缓冲区BufferedWriter

FileWriter fw=new FileWriter("b.txt")

BufferedWriter bufw =new BufferedWriter (fw);

2, 需求：将键盘录入的数据保存到一个文件中
这个需求中有源和目的都存在
那么分别分析
源：InputStream Reader
是不是纯文本？是！ Reader

设备：键盘。对应的对象是System.in.
不是选择Reader吗？ System.in对应的不是字节流吗？
为了操作键盘的文本数据方便。转成字符流按照字符串操作是最方便的。
所以既然明确了Reader，就将System.in转换成Reader。用了Reader体系中的转换流，InputtreamReader。
InputStreamReader isr= new InputStream（System.in）;
需要提高效率吗？需要！ BufferedReader
BufferedReader bufr=new BufferedReader (isr);

目的: OutputStream Writer
是否是纯文本？是！ Writer
设备：硬盘，一个文件。使用FileWriter。
FileWriter fw =new FileWriter（"c.txt"）;
需要提高效率吗？需要！
BufferedWriter bufw=new BufferedWriter(fw);

扩展一下：想要把指定的数据按照指定的编码表（utf-8），将数据存到文件中

目的: OutputStream Writer
是否是纯文本？是！ Writer
设备：硬盘，一个文件。使用FileWriter。

但是FileWriter是使用的默认编码表，GBK。

但是存储时，需要加入指定的编码表utf-8，而指定的编码表只有转换流可以指定。
所以要使用的对象时OutputStreamWriter
而该转换流对象要接受一个字节输出流，而且还可以操作文件的字节输出流，FileOutputStream

OutputStramWriter osw=new OutputStramWriter （newFileOutputStream（"d.txt"）,"UTF-8"）;

需要提高效率吗？需要！
BufferedWriter bufw=new BufferedWriter(osw);

所以：记住，转换流什么时候使用，字符和字节之间的桥梁，通常涉及到字符编码转换时，
需要用到转换流。

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;


public class TransStreamDemo2 {

	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		BufferedReader buf=new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter bufw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("hehe2.txt"),"UTF-8"));
		  String line=null;
		  while((line=buf.readLine())!=null)
		  {
			  if("over".equals(line))
  				break;
			  bufw.write(line.toUpperCase());
			  bufw.newLine();
			  bufw.flush();
		  }
		  buf.close();
	}
	

}

创建日志信息：

import java.io.IOException;
import java.io.PrintStream;
import java.text.SimpleDateFormat;
import java.util.Date;


public class ExceptionInfo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		try
		{
			int arr[]=new int[2];
			System.out.println(arr[3]);
		}
		catch(Exception e)
		{
			try {
				Date d=new Date();
				SimpleDateFormat  sdf=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
				String s=sdf.format(d);
				
				PrintStream ps=new PrintStream("exeception.log");
				ps.println(s);
				System.setOut(ps);
				//会产生这个日志文件。
			} catch (IOException e1) {
				throw new RuntimeException("日志文件创建失败");
			
			}
			e.printStackTrace(System.out);
		
		}
	}

}

打印虚拟机启动的信息：

import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.util.Properties;


public class SystemInfo {

	/**
	 * @param args
	 * @throws FileNotFoundException 
	 */
	public static void main(String[] args) throws FileNotFoundException {
	Properties prop=System.getProperties();
	prop.list(new PrintStream("sysinfo.txt"));

	}

}

至此，IO流主要部分介绍完毕。

雨之希留

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVASE----14----IO流

IO(Input Output)流:· IO流用来处理设备之间的数据传输·Java对数据的操作是通过流的方式·Java用于操作流的对象都在IO包中·流按操作数据分为两种：字节流和字符流·流按刘翔分为：输入流，输出流IO流常用基类：· 字节流的抽象基类:`InputStream ,OutputStream· 字符流的抽象基类:`Rea
复制链接

扫一扫