黑马程序员java之IO_1



------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

IO流：用于处理设备上数据。

流：可以理解数据的流动，就是一个数据流。IO流最终要以对象来体现，对象都存在IO包中。

流也进行分类：

1：输入流（读）和输出流（写）。

2：因为处理的数据不同，分为字节流和字符流。

字节流：处理字节数据的流对象。设备上的数据无论是图片或者dvd，文字，它们都以二进制存储的。

字符流：因为每个国家字符编码都不一样，为了方便于文字的解析，所以将字节流和编码表封装成对象，这个对象就是字符流。

流的操作只有两种：读和写。

字节流：InputStream OutputStream

字符流：Reader Writer

package pract;

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

public class ReaderAndWriter {
	/** 
 	 将C盘一个文本文件复制到D盘。
	复制的原理：
	其实就是将C盘下的文件数据存储到D盘的一个文件中。

	步骤：
	1，在D盘创建一个文件。用于存储C盘文件中的数据。
	2，定义读取流和C盘文件关联。
	3，通过不断的读写完成数据存储。
	4，关闭资源。
	*/
	public static void main(String[] args)throws IOException {
		//读、写都会发生IO异常,所以我们需要对异常进行处理throws or try
		copy_1();
		}
	public static void copy_1()throws IOException
	{
		/*
		1：创建一个字符输出流对象，用于操作文件。该对象一建立，就必须明确数据存储位置，是一个文件。
		2：对象产生后，会在堆内存中有一个实体，同时也调用了系统底层资源，在指定的位置创建了一个存储数据的文件。
		3：如果指定位置，出现了同名文件，文件会被覆盖。
		*/ 
		FileWriter fw = 
				new FileWriter("C:\\Users\\zety-li\\Desktop\\入学测试\\ReaderAndWriter.java");
		
		//创建可以读取文本文件的流对象，FileReader让创建好的流对象和指定的文件相关联。
		FileReader fr = 
				new FileReader("E:\\javawork\\Text03\\src\\pract\\ReaderAndWriter.java");

		int ch = 0;
		//read():一次读一个字符。而且会自动往下读。
		while((ch=fr.read())!=-1)//条件是没有读到结尾
		{
			/*
			调用Writer类中的write方法写入字符串。字符串并未直接写入到目的地中，而是
			写入到了流中，(其实是写入到内存缓冲区中)。怎么把数据弄到文件中？
			*/
			fw.write(ch);
			fw.flush();// 刷新缓冲区，将缓冲区中的数据刷到目的地文件中。
		}
		
		fw.close();// 关闭流，其实关闭的就是java调用的系统底层资源。在关闭前，会先刷新该流。
		fr.close();//同上，流都要关闭

	}
	public static void copy_2(){//这个是进行try处理的代码
		FileWriter fw = null;
		FileReader fr = null;
		try{
			fw = new FileWriter("C:\\Users\\zety-li\\Desktop\\入学测试\\ReaderAndWriter.java");
			fr = new FileReader("E:\\javawork\\Text03\\src\\pract\\ReaderAndWriter.java");

			char[] buf = new char[1024];//定义一个字符数组

			int len = 0;
			while((len=fr.read(buf))!=-1){//把读到的数据都存入数组中。该read(char[])返回的是读到字符个数。
				fw.write(buf,0,len);//从数组中取出数据
				//fw.flush();刷新，当资源关闭时候也会刷新，所以这个可以不写
			}
		}
		catch (IOException e){
			throw new RuntimeException("读写失败");
		}
		finally{
			if(fr!=null)//关闭读取流资源，一般关闭资源写在finally内，保证资源释放
				try{
					fr.close();
				}
				catch (IOException e){
					throw new RuntimeException("fr关闭失败");
				}
			if(fw!=null)//关闭写入流资源
				try{
					fw.close();
				}
				catch (IOException e){
					throw new RuntimeException("fw关闭失败");
				}
		}
	}


}

IO中的使用到了一个设计模式：装饰设计模式。

装饰设计模式解决：对一组类进行功能的增强。

包装：写一个类(包装类)对被包装对象进行包装；

 * 1、包装类和被包装对象要实现同样的接口；

 * 2、包装类要持有一个被包装对象；

 * 3、包装类在实现接口时，大部分方法是靠调用被包装对象来实现的，对于需要修改的方法我们自己实现；

class MyBufferedReader extends Reader{
		
		private Reader r;
		MyBufferedReader(Reader r){
			this.r = r;
		}
	}

字符流：

Reader：用于读取字符流的抽象类。子类必须实现的方法只有 read(char[], int, int) 和 close()。

    |---BufferedReader：从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。

       |---LineNumberReader：跟踪行号的缓冲字符输入流。此类定义了方法setLineNumber(int)和getLineNumber()，它们可分别用于设置和获取当前行号。

    |---InputStreamReader：是字节流通向字符流的桥梁：它使用指定的charset读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。

       |---FileReader：用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。要自己指定这些值，可以先在 FileInputStream 上构造一个 InputStreamReader。

    |---CharArrayReader：

    |---StringReader：

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

Writer：写入字符流的抽象类。子类必须实现的方法仅有 write(char[], int, int)、flush()和 close()。

    |---BufferedWriter：将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。

    |---OutputStreamWriter：是字符流通向字节流的桥梁：可使用指定的charset将要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。

       |---FileWriter：用来写入字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的。要自己指定这些值，可以先在 FileOutputStream 上构造一个 OutputStreamWriter。

    |---PrintWriter：

    |---CharArrayWriter：

    |---StringWriter：

缓冲区是提高效率用的，给谁提高呢？

BufferedWriter：是给字符输出流提高效率用的，那就意味着，缓冲区对象建立时，必须要先有流对象。明确要提高具体的流对象的效率。BufferedReader是给读取刘提高效率的

package pract;

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

public class BufferRWDemo {
	/**
	4、复制指定目录下的文件
	*/
	public static void main(String[] args) {
		//提供需要复制的文件
		File yuan = new File("C:\\Users\\zety-li\\Desktop\\25题\\Demo7.java");
		//提供需要复制到那的路径并提供文件名
		File mudi = new File("C:\\Users\\zety-li\\Desktop\\25题\\day04\\Demo7.java");

		copy_2( yuan, mudi);
	}
	public static void copy_2(File file , File mudi){
		BufferedReader bufr = null;//定义字符流缓冲区
		BufferedWriter bufw= null;//定义缓冲区，为了通高效率

		try{
			//将需要复制的文件和操作文件集合FileReader相关联并一起传给缓冲区
			bufr = new BufferedReader(new FileReader(file));
			//把复制文件的路径关联写入流FileWriter并传给缓冲区
			bufw = new BufferedWriter(new FileWriter(mudi));

			String line = null;
				
			while((line=bufr.readLine())!=null){//字符缓冲区内有一个readLine（）方法
				//读取字符时可以一次性读一行。
				bufw.write(line);//把读取字符内容的line写入到缓冲区内。
			}

		}
		catch (Exception e){
			throw new RuntimeException("复制失败，请重新复制");
		}
		finally{
			try{
				if(bufr!= null)//关闭写入资源。
					bufr.close();
				if(bufw!=null)//关闭输出流资源，并刷新缓冲区
					bufw.close();
			}
			catch (Exception e){
				throw new RuntimeException("关闭失败 ");
			}
		}
	}

}

字节流：

InputStream：是表示字节输入流的所有类的超类。

    |---FileInputStream：从文件系统中的某个文件中获得输入字节。哪些文件可用取决于主机环境。FileInputStream用于读取诸如图像数据之类的原始字节流。要读取字符流，请考虑使用 FileReader。

    |--- FilterInputStream：包含其他一些输入流，它将这些流用作其基本数据源，它可以直接传输数据或提供一些额外的功能。

       |--- BufferedInputStream：该类实现缓冲的输入流。

       |--- Stream：

    |--- ObjectInputStream：

    |--- PipedInputStream：

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

OutputStream：此抽象类是表示输出字节流的所有类的超类。

    |---FileOutputStream：文件输出流是用于将数据写入File或FileDescriptor的输出流。

    |--- FilterOutputStream：此类是过滤输出流的所有类的超类。

       |--- BufferedOutputStream：该类实现缓冲的输出流。

       |--- PrintStream：

       |--- DataOutputStream：

    |--- ObjectOutputStream：

    |--- PipedOutputStream：

InputStream和OutputStream属于字节输入和输出流，处理字节数据的流对象。设备上的数据无论是图片或者dvd，文字，它们都以二进制存储的。他同样可以处理字符数据。但是字符流却不能处理字节流数据。不过字符流推荐使用字符流操作。

package pract;

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

public class InputStreamDemo {
	/**
	 * 复制一个图片，
	 * 
	 * 思路：复制图片，可以知道选字节流，
	 * */
	public static void main(String[] args) {
		
		long start1 = System.currentTimeMillis();
		copy_1();
		long end2 = System.currentTimeMillis();
		
		long start3 = System.currentTimeMillis();
		copy_2();
		long end4 = System.currentTimeMillis();
		System.out.println((end2-start1)-(end4-start3)+"-毫秒");
		//我计算了两个程序的运行时间差，结果很让我意外，加入高效缓冲的copy_1运行时间比较长，
		//我很意外，我一定要弄明白。结算结果大约在19毫秒附近。如果高效产生的话应该是负数的。
	}
	public static void copy_1(){//加入缓冲的代码
		
		BufferedInputStream bufis =null;
		BufferedOutputStream bufos =null;
		try {
			bufis =  new BufferedInputStream(new FileInputStream("c:\\123.png"));
			bufos =  new BufferedOutputStream(new FileOutputStream("c:\\1.png"));
			
			int by = 0;

			while((by=bufis.read())!=-1){//读一个字节写入一个字节
				bufos.write(by);
			}
			
		} catch (Exception e) {
			throw new RuntimeException("复制失败");
		}
		finally{//关闭资源
			try {
				if(bufos!=null)
					bufos.close();
			} catch (Exception e2) {
				throw new RuntimeException("输出流关闭失败");
			}
			try {
				if(bufis!=null)
					bufis.close();
			} catch (Exception e2) {
				throw new RuntimeException("读取流关闭失败");
			}
			

		}			
		
	}
	public static void copy_2(){//没有加入缓冲区
		FileOutputStream fos = null;
		FileInputStream fis = null;
		try
		{
			fos = new FileOutputStream("c:\\123.png");
			fis = new FileInputStream("c:\\1.png");

			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("写入关闭失败");
			}
		}
	}
}