黑马程序员-Java基础-IO总结

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------

 * IO:就是输入（input）和输出（output），IO流用来处理设备之间的数据传输。Java中对数据的操作是通过流的方式进行的。
      * 1、操作的数据分为：字节流和字符流
      * 2、根据输入输出分为：输入流和输出流
      * 字节流的抽象基类：
      * InputStream 
      * OutputSream
      * 字符流的抽象基类：
      * Reader
      * Writer

IO中的派生类都是以其父类名作为子类名的后缀。

字符串缓冲区：提供一个临时的存储区域，方便字符数据的读取，提高读写效率

      BufferedWriter

      BufferedReader

      BufferedInputStream

      BufferedOutputStream

缓冲区的出现是为了提高流的操作效率而出现的，

* 所以在创建缓冲区之前，必须要先有流对象。
 * BufferedWiter提供了一个跨平台的换行符newLine()方便换行。
 * readLine()方法返回的时候只返回回车符之前的数据内存，并不返回回车符。
 * BufferedReader提供了一个一次读取一行的方法readLine(),方便于对文本数据的获取，
当返回null时，读到文件末尾。

注意：在文本文件读取时，必须明确源文件和目的文件，明确设备（内存或硬盘），明确具体的操作对象。

文本文件读取有三种方式；

1、单个字节读取

2、字符数组读取

3、带缓冲区读取

 InputStream中的重要方法 
int available():读取的字节长度 
void close（）：关闭输入流 
int read():读取字节，虽然是int类型，但实际上读取的是byte

OutputStream 常用方法 
void write（int b）：像流中写入一个byte值

void close（）：关闭输出流 

void flush（）：强制输出数据 

操作的基本规律：
 * 通过三个明确来完成：
 * 1、明确源和目的、
 *     源：输入流  InputStream Reader
 *     目的：输出流 OutputStream Writer
 * 2、操作的数据是否是纯文本
 *     是：字符流
 *     不是：字节流
 * 3、当体系明确后，再明确要使用哪个具体的对象，
 *     通过设备来进行区分
 *     源设备：内存，硬盘，键盘
 *     目的设备：内存，硬盘，键盘
 *     
 * 下面以文本文件复制举例说明
 * 源：读取流，InputStream Reader
 *   使操作文本文件：Reader，体系明确了。
 *   明确对象：
 *   设备：硬盘，上一个文件，Reader体系中可以操作文件的对象是FileReader
 *   FileReader fr = new FileReader("a.txt");
 *   BufferedReader bufr = new BufferedReader(fr);
 *   是否需要提高效率，加入Reader体系中的BufferedReader
 * 目的：OutputStream Writer
 *   是文本文件：Writer
 *   设备：硬盘  一个文件
 *   Writer体系中可以操作文件 的对象FileWriter
 *   FileWriter fw = new FileWriter("b.txt");
 *   BufferedWriter bufw = new BufferedWriter(fw);
 *   是否需要提高效率，加入Writer体系中的BufferedWriter

示例1，文本文件的复制，代码如下：

package blog.Javase.IO;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/**
 * 举例：
 * 文本文件的复制
 * 
 *复制原理：
 *就是将D盘下的文件数据存储到E盘的一个文件中
 *
 *步骤：
 *1、在F盘创建一个文件，用于存储D盘文件中的数据
 *2、定义读取流和D盘文件关联
 *3、通过不断的读写完成数据存储。
 *4、关闭资源
 * @author kevin
 *
 */
public class IODemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) throws IOException
	{
		//copy_02	();
		copy_3();
	}
	//第二种方式，带缓冲区的写法
	public static void copy_02()
	{
		FileWriter fw = null;
		FileReader fr = null;

		try {
			fw = new FileWriter("E:\\Copy_IODemo.java");
			fr = new FileReader("D:\\IODemo.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) {
				throw new RuntimeException("IO关闭异常");
			}
			if(fr!=null)
			try {
				fw.close();
				
			} catch (IOException e) {
				throw new RuntimeException("IO关闭异常");
			}
		}
	}
	//读一个字符，就往F盘写一个字符.方式一，写入单个字符
	public static void copy_1() throws IOException
	{
	   //创建目的文件
		FileWriter fw = new FileWriter("E:\\Copy_IODemo.java");
		
		//与已有文件关联
		FileReader fr = new FileReader("D:\\IODemo.java");
		int ch = 0;
		while((ch = fr.read())!=-1)
		{
		fw.write(ch);
		}
		fw.close();
		fr.close();
		
	}
	//方式三，带缓冲区的文本文件复制
	public static void copy_3() throws IOException
	{
		BufferedReader bufr = null;
	       BufferedWriter bufw = null;
	       try
	       {
	    	   bufr = new BufferedReader(new FileReader("FileCopy.java"));
	    	   bufw = new BufferedWriter(new FileWriter("Buf_Copy.java"));
	    	   String line = null;
	    	   while((line = bufr.readLine())!=null)
	    	   {
	    		   System.out.println(line);
	    		   bufw.write(line);
	    		   bufw.newLine();
	    		   bufw.flush();
	    	   }
	       }
	       catch(IOException e)
	       {
	    	   throw new RuntimeException("读写错误！");
	       }
	       finally
	       {
				if (bufr != null)
					try {
						bufr.close();
					}
				    catch (IOException e)
				    {
						throw new RuntimeException("读取关闭失败！");
					}
				if (bufw != null)
					try 
					{
						bufw.close();
					}
				    catch (IOException e) 
					{
						   throw new RuntimeException("写入关闭失败!");
					}
	       }
	}
}

示例2，使用字节流复制MP3音频文件，代码如下：

package com.itheima.day19;

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

public class Mp3Copy 
{

	/**
	 * 演示MP3复制，通过缓冲区
	 * BufferedOutputStream
	 * BufferedInputStream
	 * 
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException
	{
		long start = System.currentTimeMillis();
		copyFile();
		long end = System.currentTimeMillis();
		System.out.print(end-start+"毫秒");
	}
	//通过字节流缓冲区实现拷贝
	public static void copyFile() 
	{
		BufferedInputStream bis = null;
		BufferedOutputStream bos = null;
		try {
			bis = new BufferedInputStream(new FileInputStream("01.黎明时分.MP3"));
			bos = new BufferedOutputStream(new FileOutputStream("Copy_黎明时分.MP3.mp3"));
			int ch = 0;
			try {
				while((ch = bis.read())!=-1)
				{
					bos.write(ch);
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		finally
		{
			if(bos!=null)
			try {
				bos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
			if(bis!=null)
			try {
				bis.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

示例3，图片文件的复制，代码如下：

package com.itheima.day19;

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

public class PictureCopy 
{
	/**
	 *复制一个图片
	 *思路：
	 *1、用字符读取流对象和图片关联
	 *2、用字节写入流对象创建一个图片文件，用于存储获取到的图片数据
	 *3、通过循环读写，完成数据的存储
	 *4、关闭资源
	 */
	public static void main(String[] args)
	{
		FileRead();
	}
	public  static void FileRead()
	{
		FileOutputStream fos = null;
		FileInputStream fis = null;
		try
		{
			fos = new FileOutputStream("2.jpg");
			fis = new FileInputStream("1.jpg");
			byte[] buf = new byte[1024];
			int len = 0;
			while((len = fis.read(buf))!=-1)
			{
				fos.write(buf);
			}
		}
		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("写入关闭失败");
			}
		}
	}

}

示例4，字节流和字符流之间的转化用法，代码如下：

package com.itheima.day19;

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 
{

	/**
	 * newLine()方法只有在BufferedWriter中才有，所以如果字节流想要使用它，
	 * 就必须要转换为字符流，这时就会用到InputStreamReader进行转换。
	 * 
	 * 将字节流对象转换为字符流对象，使用转换流，InputStreamReader
	 * 将字符流转换为字节流，使用转换流     outputStreamWriter
	 * 
	 * 
	 * output-----writer
	 * input------reader
	 * 
	 * 键盘录入改写
	 * 
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException 
	{
	  //获取键盘录入对象
      //InputStream in = System.in;
      
      //将字节流对象转换为字符流对象，使用转换流，InputStreamReader
      //InputStreamReader isr = new InputStreamReader(in);
      
      //为了提高效率，将字符串进行缓冲区技术高效操作，使用BufferedReader
      //BufferedReader bufr = new BufferedReader(isr);
      
    
      //读取键盘输入流，以下为最常见写法
      BufferedReader bufr = new BufferedReader(
    		   new InputStreamReader(System.in));
       
      //OutputStream out = System.out;
      //将字符流转换为字节流，使用转换流     outputStreamWriter
      //OutputStreamWriter  osw = new OutputStreamWriter(out); 
      //BufferedWriter bufw = new BufferedWriter(osw);
      
      
      //输出键盘语句常见写法
      BufferedWriter bufw = new BufferedWriter(
    		  new OutputStreamWriter(System.out));
      //记住：
    
      String line = null;
      while((line = bufr.readLine())!= null)
      {
    	  if("over".equals(line))
    		  break;
    	  //System.out.println(line.toUpperCase());
    	  bufw.write(line.toUpperCase());//输出内容，功能同上一句
    	  bufw.newLine();
    	  bufw.flush();
      }
      bufr.close();
   }

}

示例5，异常信息通过IO流技术保存为日志文件。代码如下：

package com.itheima.day19;

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

public class ExceptionLog 
{

	/**
	 * 保存异常信息日志
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) 
	{
		try
		{
			
			char[] arr = new char[2];
			System.out.println(arr[3]);
		}
		catch(Exception e)
		{
			try {
				Date d = new Date();
				SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 E HH:mm:ss");
				String time = sdf.format(d);
				PrintStream ps = new PrintStream("ExceptionLog.log");
				ps.println(time);
				System.setOut(ps);
			} catch (IOException e1) {
				throw new RuntimeException("日志文件创建失败");
			}
			e.printStackTrace(System.out);
		}
	}

}

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------