黑马程序员---IO流

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

IO（Input Output）流

IO流用来处理设备之间的数据传输

Java对数据流的操作是通过流的方式

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

流按操作数据分为两种：字节流与字符流

流按流向分为：输入流、输出流

IO流常用基类：

字节流的抽象基类：

InputStream    、    OutputStream

字符流的抽象基类：

Reader   、  Writer

注：由着四个类派生出的子类名称都是以其父类作为子类名的后缀。如：InputStream的子类FileInputStream，Reader的子类FileReader

Writer流的使用如下：

package com.study;
import java.io.*;
public class IO {
	
	public static void main(String[] args) throws IOException {
		//创建一个FileWriter对象，该对象一被初始化，就必须要明确被操作的文件。
		//而且该文件会被创建到指定的目录下。如果该目录下已有同名文件，将被覆盖。
		//其实该部就是在明确数据要存放的目的地。
		FileWriter fw=new FileWriter("demo.txt");
		
		//调用Write方法，将字符串写入到流中（内存中）
		fw.write("abcd");
		
		//刷新流对象中的缓冲中的数据
		//将数据刷新到目的地
		//fw.flush();
		
		//关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据
		//将数据刷到目的地中
		//和flush区别：flush刷新后，流可以继续使用，close刷新后，会将流关闭(释放流资源)。
		fw.close();
		
	}

}

结果为：

对于出现的异常的专业处理：

package com.study;
import java.io.*;
public class IO2 {
	public static void main(String[] args) {
		
		FileWriter fw=null;
		//异常处理try{}catch{}finally{}
		//三个代码块
		try {
			
			fw=new FileWriter("demo.txt");
			fw.write("abc");
			
			
		} catch (IOException e) {
			System.out.println(e.toString());
		}
		finally{
	
			try {
				//防止出现空指针异常
				//流关闭时要分别关闭，不要加& |等
				if(fw!=null){
					fw.close();
				}
		
			} catch (Exception e) {
				e.printStackTrace();
			}
		}

	}

}

对于目标文件的续写：

/*
 * 对已有文件的数据续写
 */

package com.study;
import java.io.*;
public class IO3{
	public static void main(String[] args) {
		
		FileWriter fw=null;
		//异常处理try{}catch{}finally{}
		//三个代码块
		try {
			//对目标文件的内容进行续写(换行：\r\n）
			fw=new FileWriter("demo.txt",true);
			fw.write("\r\nhehe");
			
			
		} catch (IOException e) {
			System.out.println(e.toString());
		}
		finally{
	
			try {
				//防止出现空指针异常
				//流关闭时要分别关闭，不要加& |等
				if(fw!=null){
					fw.close();
				}
		
			} catch (Exception e) {
				e.printStackTrace();
			}
		}

	}

}

效果为：

read流的使用：

单个字符的读取：

package com.study;
import java.io.*;
public class read {
	public static void main(String[] args) throws IOException {
		//创建一个文件读取流对象，和指定名称的文件相关联
		//要保证该文件是已经存在的，如果不存在，会发生异常FileNotFoundException
		FileReader fr=null;
		try {
			fr = new FileReader("demo.txt");
			//调用读取流对象的read方法
			//read（）：一次只读一个字符，而且会自动往下读
			//如果以达到流的末尾，则返回-1
			int ch=0;
			while((ch=fr.read())!=-1){
				System.out.println("ch="+(char)ch);
			}
			
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{

			try {
				//防止出现空指针异常
				//流关闭时要分别关闭，不要加& |等
				if(fr!=null){
					fr.close();
				}
		
			} catch (Exception e) {
				e.printStackTrace();
			}
			
		}
		
	}

}

效果为：

字符串的读取：

package com.study;
import java.io.*;
public class read2 {
	public static void main(String[] args) throws IOException {
		//创建一个文件读取流对象，和指定名称的文件相关联
		//要保证该文件是已经存在的，如果不存在，会发生异常FileNotFoundException
		FileReader fr=null;
		try {
			fr = new FileReader("demo.txt");
			
			//定义一个字符数组，用于存储读到的字符（缓冲区：2K）
			char[] buf=new char[1024];
			
			//该read（char[]）返回的是读到的字符个数
			int num=0;
			
			while((num=fr.read())!=-1){
			//从0-num，全部都读出来
			System.out.println("num="+num+"...."+new String (buf,0,num));
			}
			
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{

			try {
				//防止出现空指针异常
				//流关闭时要分别关闭，不要加& |等
				if(fr!=null){
					fr.close();
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
			
		}
	}

}

效果为：

IO流的应用：复制文件

/*
 * 1，在D盘创建一个文件，用于存储c盘文件中的数据
 * 2，定义读取流和C盘文件关联
 * 3，通过不断的读写完成数据存储
 * 4，关闭资源
 */
package com.study;
import java.io.*;
public class copy {

	public static void main(String[] args) {

		FileWriter fw=null;
		FileReader fr=null;
		try {
		    //分别创建输入流、输出流
			fw=new FileWriter("D:\\read_copy.txt");
			
			fr=new FileReader("C:\\read.txt");
			//创建一个缓冲区
			char[] buf=new char[1024];
			
			int len=0;
			//当len不等于-1时，继续复制
			while((len=fr.read(buf))!=-1){
				fw.write(buf,0,len);
				//打印出来
			    System.out.println(new String(buf,0,len) );
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
		    
		    //分别处理异常
			try {
				//防止出现空指针异常
				//流关闭时要分别关闭，不要加& |等
				if(fr!=null){
					fr.close();
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
			try {
				//防止出现空指针异常
				//流关闭时要分别关闭，不要加& |等
				if(fw!=null){
					fw.close();
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}

}

字符流的缓冲区：

意义：提高了对数据的读写效率,也提高了流的操作效率。所以，在创建缓冲区之前，必须要有流对象。

对应类：BufferedWriter、BufferedReader

缓冲区要结合流才可以使用。

在流的基础上对流的功能进行了增强。

应用：

BufferedWriter：

package com.study;
import java.io.*;
public class buf {

	public static void main(String[] args) throws IOException {
		//创建一个字符写入流对象
		FileWriter fw=new FileWriter("buf.txt");
		
		//为了提高字符写入流效率，加入了缓冲技术
		//只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可。
		BufferedWriter bw=new BufferedWriter(fw );
		
		for (int i = 0; i < 5; i++) {
			bw.write("abc"+i);
			//该缓冲区提供一个跨平台的换行符
			bw.newLine();
			bw.flush();
		}		
		//记住：只要用到缓冲区，就要记得刷新。
		bw.flush();
		
		//其实关闭缓冲区，就是在关闭缓冲区中的对象
		bw.close();

	}

}

效果：

BufferedReader：

package com.study;
import java.io.*;
public class buf2 {

	public static void main(String[] args) throws IOException {
		//创建一个读取流对象和文件相关联
		FileReader fr=new FileReader("buf.txt");
		
		//为了提高效率，加入缓冲技术，将字符读取流对象作为参数传递给缓冲对象构造函数。
		BufferedReader br=new BufferedReader(fr);
		
		String line=null;
		//该缓冲区提供了一个一次读取一行的方法readline，方便对文本数据的获取
		//当返回null时，表示读取完成
		//readline只返回换行符之前的数据，所以不要忘了用newline（）方法换行
		while((line=br.readLine())!=null){
			System.out.println(line);
		}
		br.close();
	}

}

readline方法的原理：
无论是读取一行，还是读取多个字符，其实最终都是在硬盘上一个一个读取。所以最终使用的还是read方法一次读一个的方法。