奋斗黑马程序员----Java之IO简介

----------android培训、java培训、期待与您交流！ ----------

/**
 * Java之IO流小结：
 */

/** 1 ：java之IO流
 * 
 * 1，什么是流：
 *   流是一个抽象的概念。当Java程序需要从数据源读取数据时，会开启一个到数据源的流。
 * 数据源可以是文件，内存或者网络等。同样，当程序需要输出数据到目的地时也一样会开
 * 启一个流，数据目的地也可以是文件、内存或者网络等。流的创建是为了更方便地处理数
 * 据的输入输出。
 * 
 * 
 * 	IO流用来处理设备之间的数据传输（也称数据流）
 * 	Java对数据的操作时通过流的方式
 * 	Java用于操作流的对象都在IO包中
 * 
 * 2,流的分类：
 * 
 * A:流按操作数据分为两种：字节流和字符流 
 * 	   1,字节流也称为原始数据，需要用户读入后进行相应的编码转换，字节流由InputStream
 * 和OutputStream处理。
 *     2,字符流的实现是基于自动转换的，读取数据时会把数据按照JVM的默认编码自动转换成字符。
 * 而字符流由Reader和Writer处理。Reader和Writer是Java后加入的处理类，出于让数据的处理
 * 更方便的目的。
 * 
 * 
 * 	   早期的javaIO流都是字节流的。无论内存还是硬盘上的数据都是字节组成的。那为什么
 * 又出现了字符流呢？
 * 	   为了便于处理一些文本文件，用字符流。。ASCII表。。汉字的表：GB2312（早期），
 * 扩容后叫：GBK（有2万多），后期会讲。
 *    国际标准码表：unicode表，后期转换后，叫utf-8.(优化后的表）
 * 	   不同格式导致的乱码，在java中内部指定了
 * 	   通用：字节流，字符流基于字节流。
 * 
 * B:流按流向分为：输入流和输出流
 * 
 * 字节流的抽象基类：
 * 	InputStream(输入)，OutputStream(输出)
 * 字符流的抽象基类：
 * 	Reader(输入)，Writer(输出)
 * **注意，由这四个类派生出来的子类名称都是以其父类名最为子类名的后缀。。
 *   如：InputStream的子类FileInputStream
 * 	 如：Reader的子类FileReader
 * 
 * IO流就是围绕读写来展开的。
 * 
 */



/** 2 ：Filewriter
 * 
 *    public abstract class Writer extends Object implements Appendable, Closeable, 
 * Flushable，写入字符流的抽象类。子类必须实现的方法仅有 write(char[], int, int)、
 * flush() 和 close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或
 * 其他功能。
 * 
 *    public class FileWriter extends OutputStreamWriter，用来写入"字符文件"的便捷类。
 * 此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的。要自己指定这
 * 些值，可以先在 FileOutputStream 上构造一个 OutputStreamWriter。  
 *  
 * 
 * 	字节流的两个基类：InputStream OutputStream
 * 
 * 	字符流的两个基类：Reader Writer
 * 
 * 	先学习下字符流的特点：
 * 	既然IO流是用于操作数据的。那么数据的最常见的体现形式是：文件
 * 	那么先以操作文件为主来演示：
 * 	
 * 	需求：在硬盘上创建一个文件，并写入写文字数据。
 * 	
 *  前缀名是功能，后缀名是父类名
 *  
 *    找到一个专门用于操作文件对象的Writer子类：FileWriter，后缀名是父类名，
 * 前缀名是该流对象的功能。
 */
import java.io.*;
public class FileWriterDemo {
	public static void main(String[] args) throws IOException 
	{
		/* 第一步：创建一个FileWriter对象，该对象一被初始化就必须要明确要操作的文件
		 * 构造函数为非空的。
		 * 而且该文件会被创建到指定目录下。如果该目录下已有同名文件，将被覆盖。
		 * 其实这一步就是在明确数据要存放的目的地。
		 */
		FileWriter fw = new FileWriter("Demo.txt"); //文件的路径会有问题。所以要抛异常
		
		
		/*第二部：写数据
		 * 调用write方法，将字符串写入到“流”中，非文件中。那怎么把数据写到文件中呢?
		 */
		fw.write("abcde");
		
		/* 刷新流对象中的缓冲中的数据
		 * 将数据刷到目的地中：flush();方法
		 */
		fw.flush();	//写完了记得要刷一下
		
		fw.write("o(∩∩)o...哈哈，我好过来了");	//还可一继续写数据
		fw.flush();	//必须要刷一次
		/* close();
		 * 关闭流资源，但是关闭之前会刷新一次内部的缓冲的数据.将数据刷到目的地中，
		 * 
		 * 和flush的区别是：flush刷新后，流可以继续使用，close刷新后，会将流关闭。
		 */
		
		fw.close();	
		
		/*
		 * 其实，java本身是不能向系统中写数据的，是靠系统的程序操作数据的。
		 * 所以，用完后，必须要有关闭动作，最后使用。
		 */
		
		/**
		 * 在IO体系当中，IO异常是最为常见的异常。
		 */
		
		//但是怎么操作这些数据呢？
	}
}


/** 3 ：专业的异常处理：IO异常的处理方式。
 * 
 */
import java.io.*;
public class FileWriterDemo2 {
	public static void main(String[] args) //throws IOException
	{
		/*
		 * 凡是和设备处理的，无论读还是写，都会发生IO异常
		 * 比如：设备出故障，文件找不到。。。。
		 */
		FileWriter fw = null;
		try{			
			//FileWriter fw = new FileWriter("Demo1.txt");
			/*替换：
			 * 在外慢建立引用，在try进行初始化。
			 * 
			 */
			fw = new FileWriter("Demo1.txt");
			fw.write("jdsajfl");
			fw.flush();
			/*
			 * 这三句代码要放到一起try，否则，前面的任意一句出现问题，后面的就挂了。
			 */
		}
		catch(IOException e)
		{
			System.out.println(e.toString());
		}
		finally
		{
			//一定会被执行的。如果fw初始化失败，则此处还会抛出空指针异常。为了程序的健壮行，进行如下更该。
			try{				
				if(fw != null)	//一定要有。
				{					
					fw.close();	//fw引用无效。
				}
			}
			catch(IOException e)
			{
				System.out.println(e.toString());
			}
		}	
	}
}


/** 4 ：FileWriter：实现对已有文件的数据续写。
 * 
 *    public FileWriter(String fileName,boolean append) throws IOException，
 * 根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象。 
 *    append - 一个 boolean 值，如果为 true，则将数据写入文件末尾处（即最后一
 * 个字符的下一个字符），而不是写入文件开始处。
 * 
 */
import java.io.*;
public class FileWriterDemo3 {
	public static void main(String[] args) throws IOException //老毕求简洁，不try了
	{
		/*传递一个true参数，代表不覆盖已有的文件。并在已有文件的末尾处进行数据续写。
		 * 
		 */
		FileWriter fw = new FileWriter("Demo.txt",true);
		//在windows里面，换行符有'\n','\r',在linux里面，只有'\n'
		fw.write("这是续\n写数据");	//linux中可以这么写。
		//fw.write("windows要这么写\r\n啊啊啊啊啊");
		
		fw.close();
	}
}


/** 5 ：文件的读取方式一
 * 
 *   public abstract class Reader extends Object implements Readable, Closeable
 *   用于读取字符流的抽象类。子类必须实现的方法只有 read(char[], int, int) 和 close()。
 * 但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。
 * 
 *   public class InputStreamReader extends Reader
 *   InputStreamReader 是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将
 * 其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。 
 *   每次调用 InputStreamReader 中的一个 read() 方法都会导致从底层输入流读取一个或多
 * 个字节。要启用从字节到字符的有效转换，可以提前从底层流读取更多的字节，使其超过满
 * 足当前读取操作所需的字节。
 *   
 *   为了达到最高效率，可要考虑在 BufferedReader 内包装 InputStreamReader。例如： 
 *   BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
 *   
 *   public class FileReader extends InputStreamReader
 *   用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都
 * 是适当的。要自己指定这些值，可以先在 FileInputStream 上构造一个 InputStreamReader。 
 *   FileReader 用于读取字符流。要读取原始字节流，请考虑使用 FileInputStream。
 * 
 */
import java.io.*;
public class FileReaderDemo {
	public static void main(String[] args) throws IOException
	{
		FileWriter fw = new FileWriter("Demo2.txt");
		fw.write("adjoaad");
		fw.close();
		
		/*创建一个文件读取流对象，和指定名称的文件相关联
		 * 要保证该文件是已经存在的，如果不存在，会发生异常：FileNotFoundException(IO异常的子类）
		 * 
		 */
		FileReader fr = new FileReader("Demo2.txt");
		
		/*调用读取流对象的方法。
		 * 
		 * public int read() throws IOException,读取单个字符。
		 * read();一次读一个，且自动向下读。
		 * 当读到流的结尾时，会返回-1
		 */
		
		/*
		int ch = fr.read();	//一次只能读一个。
		System.out.println("ch="+(char)ch);
		
		int ch1 = fr.read();	//一次只能读一个。
		System.out.println("ch="+(char)ch1);
		*/
		
		/*第一次优化
		 * 替换为下面的
		 */
		/*
		while(true)
		{
			int ch = fr.read();
			if(ch==-1)
				break;
			System.out.println("ch="+(char)ch);
		}
		*/
		/*
		 * 第二次优化
		 */
		int ch = 0;
		while((ch=fr.read())!=-1)
		{
			System.out.println("ch="+(char)ch);
		}
		
		fr.close();
	}
}


/** 6 ：文件的第二种读取方式。
 * 
 *   public int read(char[] cbuf,int offset,int length) throws IOException
 *   将字符读入数组中的某一部分。
 *   cbuf - 目标缓冲区
 *   offset - 从其处开始存储字符的偏移量
 *   length - 要读取的最大字符数 
 *   返回读取的字符数，如果已到达流的末尾，则返回 -1 
 *   
 * 通过字符数组进行读取。
 */
import java.io.*;
public class FileReaderDemo2 {
	public static void main(String[] args) throws IOException
	{
		FileReader fr = new FileReader("Demo2.txt");
		/*
		 * 定义一个字符数组，用于存储读到的字符，该Reader(char[])返回的是读到的字符个数。
		 */
		char[] buf = new char[1024];	//长度不好定义。。但通常定义成1024的整数倍。2k
		/*
		int num = fr.read(buf);		
		System.out.println("num="+num+"....."+new String(buf));
		
		int num1 = fr.read(buf);		
		System.out.println("num1="+num1+"....."+new String(buf));
		
		*/
		/**
		 * 从此处开始就就会读多了。
		 */
		/*
		int num2 = fr.read(buf) ;		
		System.out.println("num2="+num2+"....."+new String(buf));
		
		int num3 = fr.read(buf); //num3=-1		
		System.out.println("num3="+num3+"....."+new String(buf));
		
		System.out.println(fr.read());
		*/
		
		/*
		 * 循环输出，
		 */
		int num = 0;
		while((num=fr.read(buf))!=-1)  //num=-1时，就是到了文件的结尾。
		{
			System.out.println(num);
			System.out.println(new String(buf,0,num));
		}
		
		fr.close();
	}
}


/** 7 ：FileReader练习，
 * 
 */
import java.io.*;
public class FileReaderText {
	public static void main(String[] args) throws IOException
	{
		FileReader fr = new FileReader("DateDemo.java");
		
		char[] buf = new char[1024];
		
		int num = 0;
		while((num=fr.read(buf))!=-1)	
		/*
		 * num正好是文件中的字符数，如果num=-1，那么说明到了文件的结尾。
		 * 
		 */
		{
			System.out.print(new String(buf,0,num));	
			/*此处不能使用println，如果buf里的数据超过了1024，那么在1024处会出现回车了。
			 * 
			 */
		}
		
		fr.close();	//这个一定不要忘了
	}
}

/** 8 ：练习，文件的拷贝
 * 
 * 将c盘的一个文本文件复制到d盘
 * 
 * 复制的原理：
 * 	其实就是讲c盘下得文件数据存储到d盘的一个文件中
 * 
 * 步骤：
 * 	1，在d盘创建一个文件，用于存储c盘文件中的数据。
 * 	2，定义读取流和c盘文件关联
 * 	3，通过不断的读写完成数据存储，
 * 	4，关闭资源
 */
import java.io.*;
public class CopyText {
	public static void main(String[] args) throws IOException
	{
		//copy_1();
		copy_2();
	}
	/*
	 * 从c盘读取一个字符，就往d盘写一个字符
	 * 这种方法效率低
	 */
	public static void copy_1() throws IOException
	{
		//创建目的地
		FileWriter fw = new FileWriter("RuntimeDemo_copy.txt");
		
		//与已有文件关联
		FileReader fr = new FileReader("RuntimeDemo.java");
		int ch = 0;
		while((ch=fr.read())!=-1)
		{
			fw.write(ch);
		}
		fw.close();
		fr.close();
	}
	/*
	 * 
	 */
	public static void copy_2()
	{
		FileWriter fw = null;
		FileReader fr = null;
		try{
			fw = new FileWriter("SystemDemo.txt");
			fr = new FileReader("SystemDemo.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
		{
			/**
			 * 此处要分开结束，即要分开try
			 */
			if(fr!=null)
			{
				try{
					fr.close();
				}
				catch(IOException e)
				{
					
				}
			}
			if(fw!=null)
			{
				try{
					fw.close();
				}
				catch(IOException e)
				{
					
				}
			}
		}
	}
}

/**小结：
 * 1，java IO流概述。
 * 2，使用FileWriter
 * 3，流异常处理的方式
 * 4，用FileWriter实现对已有文件的续写。
 * 5，文件的读取方式（Reader及其子类）
 * 6，FileReader练习
 * 
 * 提示：流有很多子类，容易搞混，切记要分好类。
 */

----------android培训、java培训、期待与您交流！----------

　　详细请查看：http://edu.csdn.net/heima/