黑马程序员_java基础学习笔记08_IO流

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

IO流是实现设备之间的数据传输,主要是文件的上传和下载.数据从一个设备,传到另一个设备上.

IO流分类: A 按照操作的文件类型分类

第一类   字节流，一次操作1个字节，8个二进制位，可以操作任意文件
          第二类   字符流，一次操作2个字节, 16个二进制位，默认查询本机编码表GBK
          只能操作文本文件，不能操作文本以外的文件
          文本文件，是比较特殊的文件，JDK1.1开始,开发专门对付文本的字符流.

IO流的四个抽象基类

A. 字节输出流，写入任意文件   
      OutputStream 方法就是用来写数据
      write 字节数组  字节数组一部分  单个字节
      close 关闭资源   IO写文件利用操作系统中的功能
      flush 刷新，数据强制的从内存，刷新到一个设备，字节流一般不用
     
   B. 字节输入流，读取任意文件
      InputStream 方法用来读取数据
      read 字节数组  字节数组一部分 单个字节
      close 关闭资源
     
   C. 字符输出流，写文本文件
      Writer 方法就是用来写数据
      write 字符输出  字符数组一部分  单个字符   写字符串
      flush 字符流输出流，写完数据后，必须要刷新，否则数据留在内存中
      close 关闭资源
     
   D. 字符输入流 ，读取文本文件
     Reader 方法用来读取数据
      read 字符数组  字符数组一部分  单个字符
      close 关闭资源

注意:在使用IO流操作文件时,会出现异常,需要处理.使用try..catch处理异常.try外声明变量,try内建立对象.IO对象在操作文件的时候,会占用操作系统的资源,无论读写文件是否成功,必须释放资源.close应该写在finally后.为了避免关闭资源时空指针异常,close方法必须单独写try..catch.

FileOutputStream 它是OutputStream的子类.构造方法有:

FileOutputStream(File file)
FileOutputStream(String name)

写数据的方法有:

public void write(int b)  //写入单个字节
public void write(byte[] b)  //写如字节数组
public void write(byte[] b,int off,int len)  //写字节数组的一部分

FileInputStream 它是InputStream的子类.构造方法有: FileInputStream(File file)
FileInputStream(String name)

成员方法有:

public int read()
public int read(byte[] b)

下面通过案例来说明:

/*
 * 字节流复制任意文件
 * 数据源 c:\\qq.exe    数据目的是 d:\\qq.exe
 * FileInputStream      FileOuputStream
 * 读取字节数组         写字节数组
 *  read(bytes)          write(bytes,0,1)
 *  效率较快           
 */
import java.io.*;
public class CopyFile1 {
	public static void main(String[] args) {
		//创建2个流对象
		FileInputStream fis = null;
		FileOutputStream fos = null;
		try{
			fis = new FileInputStream("c:\\m.exe");
			fos = new FileOutputStream("d:\\m.exe");
			//定义字节数组缓冲，读取数组，写数组
			byte[] bytes = new byte[1024*10];
			int len = 0 ;
			while((len = fis.read(bytes))!=-1){
				fos.write(bytes,0,len);
			}
		}catch(IOException e){
			throw new RuntimeException("复制失败");
		}finally{
			try{
				if(fos!=null)
					fos.close();
			}catch(IOException e){
				throw new RuntimeException("关闭资源失败");
			}finally{
				try{
					if(fis!=null)
						fis.close();
				}catch(IOException e){
					throw new RuntimeException("关闭资源失败");
				}
			}
		}
	}
}

为了提高流操作效率,字节流开发除了缓冲区对象.输出流:BufferedOutputStream,继承OutputStream,写的方法与FileOutputStream方法一样.构造方法为:BufferedOutputStream(OutputStream out)首先创建缓冲区对象,传递字节输出流的对象,传递OutputStream子类对象FileOutputStream,主要看传递的是哪个流对象,缓冲区就对哪个流对象提高效率,所有的字节输出流都可以提高效率.

import java.io.*;
public class BufferedOutputStreamDemo {
	public static void main(String[] args)throws Exception {
		//创建字节输出流对象
		FileOutputStream fos = new FileOutputStream("c:\\stream.txt");
		//创建字节输出流缓冲区对象，传递字节输出流
		BufferedOutputStream bos = new BufferedOutputStream(fos);
		
		//写数据
		bos.write("缓冲区".getBytes());
		
		//写单个字节
		bos.write(99);
		
		//关闭资源，直接关闭缓冲区即可
		bos.close();
	}

)

字节输入流缓冲区对象 BufferedInputStream 继承于InputStream.

读取方法有:

public void read(int b)  //读取单个字节
public void <span style="font-family:SimSun;">read</span>(byte[] b)  //读取字节数组
public void read(byte[] b,int off,int len)  //读取节数组的一部分

构造方法:BufferedInputStream(InputStream in) 传递字节输入流对象,传递FileInputStream子类的对象.

import java.io.*;
public class BufferedInputStreamDemo {
	public static void main(String[] args)throws Exception {
	   //创建字节输入流对象
		FileInputStream fis = new FileInputStream("c:\\stream.txt");
		//创建字节输入流缓冲区对象，传递字节输入流
		BufferedInputStream bis = new BufferedInputStream(fis);
		//可以读取单个字节
		/*int len = 0 ;
		while((len = bis.read())!=-1){
			System.out.print((char)len);
		}*/
		//读取字节数组
		byte[] bytes = new byte[1024];
		int len = 0 ;
		while((len = bis.read(bytes))!=-1){
			System.out.print(new String(bytes,0,len));
		}
		bis.close();
	}
}

我们可以实验得出结论,字节流复制4种方式中,缓冲区读写字节数组的效率最高

1. FileInputStream FileOutputStream  读写单个字节
  2. FileInputStream FileOutputStream  读写字节数组
  3. BufferedInputStream  BufferedOutputStream  缓冲区读写单个字节
  4. BufferedInputStream  BufferedOutputStream  缓冲区读写字节数组

字节流操作中文不是特别方便,java提供了转换流.字符流=字节流+编码表

转换流: 输出流 OutputStreamWrite(字符流),继承Write,方法是写字符数组,字符数组一部分和单个字符.转换流构造方法:传递字节输出流 OutputStreamWriter(OutputStream out)
OutputStreamWriter(FileOutputStream out)

构造方法中,可以写字符串编码表的名字,如果不指定,默认是GBK.

写的方法是:write(char[]) write(String) 刷新:flush() 关闭资源:close()

输入流 InputStreamReader 继承Reader 具有读取的方法 读取单个字符，读取字符数组，读取字符数组一部分.InputStreamReader 转换流是字节流向字符的桥梁,可以使字节转成字符.

构造器有: InputStreamReader(InputStream in) 传递字节输入流
InputStreamReader(FileInputStream in) 传递字节输入流
转换流InputStreamReader，从字节流FileInputStream读取字节，根据编码，转成字符.InputStreamReader类构造方法中，可以传递字节输入流，指定编码表.

转换流的名字比较长，而我们常见的操作都是按照本地默认编码实现的，所以，为了简化我们的书写，转换流提供了对应的子类。

FileWriter

/*
 * FileWriter 写入文本文件的便捷类，方便，快速
 * FileWriter继承OutputStreamWriter继承Writer
 * FileWriter方法
 *   write 单个字符，字符数组，字符数组一部分 刷新，关闭
 * 这个流对象，只查询默认编码表GBK，不能更改编码表
 * 
 * 构造方法 传递字符串文件名

 *<span style="font-family: SimSun;">其他方法父类中都实现完成，继承后直接使用</span>
 */
import java.io.*;
public class FileWriterDemo {
	public static void main(String[] args) throws Exception{
		//创建FileWriter类的对象，指定文件名
		//创建文件，如果文件存在，就覆盖
		FileWriter fw = new FileWriter("c:\\demo.txt");
		//调用Writer方法写
		//写单个字符
		fw.write('a');
		fw.flush();
		//写字符串
		fw.write("你好我好大家好");
		fw.flush();
		fw.write("\r\n");
		fw.flush();
		//写字符数组
		char[] ch = "尝试编写字符数组".toCharArray();
		fw.write(ch,1,5);
		fw.flush();
		fw.close();
	}
}

FileREader

/*
 * FileReader 字符输入流，读取文本文件
 * FileReader继承InputStreamReader继承Reader
 * 读取单个字符，字符数组，字符数组一部分
 * FileReader读取文本文件便捷类，默认查询编码表GBK，不允许指定编码表
 * 
 * FileReader 所有读取方法使用父类方法
 * 构造方法
 *   传递字符串的文件名
 */
import java.io.*;
public class FileReaderDemo {
	public static void main(String[] args) throws Exception{
		//创建FileReader对象，传递字符串的文件名
		FileReader fr = new FileReader("C:\\demo.txt");
		//读取单个字符
		/*int x = fr.read();
		System.out.println(x);*/
		/*int x = 0 ;
		while((x=fr.read())!=-1){
			System.out.print((char)x);
		}
		*/
		char[] ch = new char[1024];
		int len = 0 ;
		while((len = fr.read(ch))!=-1){
			System.out.print(new String(ch,0,len));
		}
		fr.close();
	}
}

BufferedWriter 字符输出流的缓冲区对象，出现目的，提高字符输出流的效率和写的效率.BufferedWriter 继承 Writer.

构造方法:BufferedWriter(Writer out)
传递字符输出流，传递Writer子类，OutputStreamWriter ， FileWriter
缓冲区就对哪个流提高效率
BufferedWriter(new FileWriter(""))
BufferedWriter自己的特有方法  void newLine()//写一个换行

注意:\r\n 可以用来换行,这是在Windows在特有的.而使用java语言编写的方法 newLine(),这种换行方法具有 平台无关性,具有跨平台型.

BufferedReader 字符输入流，读取文件的缓冲区对象,BufferedReader实现读取文本的一行的方法为: String readLine() //读取到文件的结尾   null

构造方法: BufferedReader(Reader in) 传递字符输入流
传递Reader的子类对象，InputStreamReader，FileReader

总结:

  |-- 字节流
    |-- 输出流  写任意的文件
      OuputStream  FileOutputStream  BufferedOutputStream
                  写字节数组   write (byte[],开始下标,个数)
    |-- 输入流  读取任意文件
      InputStream FileInputStream   BufferedInputStream
                读取字节数组 read (byte[]) 返回数组中的有效个数
                
  |-- 字符流
    |-- 输出流 写文本文件
      Writer  OutputStreamWrite  FileWriter  BufferedWriter
                  写字符数组  write(char[],开始下标,个数)  字符串(String s)
      OutputStreamWrite构造方法，传递字节输出流，指定编码表
      BufferedWriter newLine 写行
      
    |-- 输入流 读取文本文件
      Reader InputStreamReader  FileReader  BufferedReader
                 读取字符数组 read(char[])  读取行
      InputStreamReader构造方法中，传递字节输入流，指定编码表
      BufferedReader readLine 读取一行
 
 使用中：IO作用是读写文件
    明确数据源：
         文本数据：FileReader BufferedReader 读取
         读取字符数组，读取文本行
         
        不是文本文件：FileInputStream  BufferedInputStream读取
        读取字节数组
        
        如果数据源不明确到时什么类型文件,一律使用字节流  
       
 明确数据目的：
      文本数据： FileWriter BufferedWriter 写入
      写字符数组，写换行
      
    不是文本文件：FileOutputStream BufferedOutputStream 写入
    写字节数组
    
    如果数据目的不明确到时什么类型文件,使用字节流