Java基础之IO流知识点总结一

Io流的整体把握：

          

其他常用与流相关的对象:

     

             IO流  总结一

IO流：用于处理设备上的数据。
   设备：硬盘、内存、键盘输入。

IO有具体的分类：
   1． 根据流向的不同：输入流和输出流
   2． 根据操作数据的不同：字节流和字符流

问：有了字节流的存在，为什么字符流还要出现？
   字符流的由来：因为文件编码的不同，才出现了字符流，它可以对字符进行高效的操作。
   原理：其实字符流就是基于字节流读取字节时，去查询了指定的码表。

那么字节流和字符流有哪些区别呢？
    区别：
      1. 字节流读取数据的时候，读到一个字节就返回一个字节。而字符流就不同了，字符流使用了字节流读到一个或者多个字节（为啥？会读 到多个字节：因为中文对应的字节数是两个，在UTF-8码表中是三个字节）时。先去查指定的编码表，将查到的字符返回。

      2. 字节流可以处理所有类型的数据，比如：图片、MP3音乐，avi格式的视频等。但是字符流只能处理字符数据。

      再次，总结字符流和字节流，可以得出结论： 只要是处理纯文本数据时，就要优先考虑使用字符流，除此之外都用字节流。

IO的体系。我们要知道IO流的两个基本的功能：读和写。
     1. 字节流的抽象基类：
          InputStream（读）,OutputStream（写）
     2. 字符流的抽象基类：
          Reader（读），Writer（写）

IO基本的读写操作方式：
      因为数据通常都是以文件形式存在的，所以就要找到IO体系中可以用于操作文件的流对象。通过名称可以很容易的获 取该对象，因为IO体系中的子类名后缀绝大部分是父类名称，而前缀都是体现子类功能名字。

下面举个例子说明一下：
Reader
    |--InputStreamReader:专门用于处理文件的字节读取流对象
           |--FileReader:专门用于处理文件的字符读取流对象
Writer
    |--OutputStreamWriter专门用于处理文件的字节写入流对象
           |--FileWriter:专门用于处理文件的字符写入流对象

Writer中常见的方法：
  1. writer(ch):将一个字符写入到流中。
  2. writer(char[]):将一个字符数组写入到流中。
  3. writer(String):将一个字符串写入到流中。
  4. flush():刷新流，将流中的数据刷新到目的地中，流还存在。
  5. close():关闭资源，在关闭前会先调用flush(),刷新流中的数据去目的地，然后流才关闭。

Reader中常见到的方法：
  1. int read():读取一个字符。返回的是读到的那个字符。如果读到流的末尾，返回-1。
  2. int read(char[]):将读到的字符存入到数组中，返回的是读到的字符个数，也就是往数组里装的元素的个数。如果读到了流的末尾，返回-1。
  3. close():关闭字符流其实用的是window系统的功能，就希望使用完毕后，要对资源进行释放。

    FileWriter:
      该类没有特有的方法。只有自己的构造函数。
      该类的特点在于：
        1. 用于处理文本文件。
        2. 该类中有默认的编码表。
        3. 该类中有临时缓冲。
      构造函数：在写入流对象初始化时，必须要有一个存储数据的目的地。
    FileWriter(String filename):
      该构造函数做了什么事情呢？
        1. 调用系统资源。
        2. 在指定位置，创建了一个文件。注意：如果该文件已存在，将会被覆盖。
    FileWriter(String filename,Boolean append):该构造函数：当传入的boolean类型值为true时，会在指定的文件末尾处进行数据的续写。

    FileReader:
      1. 用于读取文本文件的流对象。
      2. 用于关联文本文件
      构造函数：在读取流对象初始化的时候，必须要指定一个被读取的文件。如果该文件不存在，会报FileNotFoundException的异常。
    FileReader(String filename);

例子1：在硬盘上，创建一个文件并写入一些文字数据。

package cn.itheima.day02;
import java.io.FileWriter;
import java.io.IOException;
/**
 * 需求：在硬盘上，创建一个文件并写入一些文字数据。
 * 解析：这里就找到了专门操作文件的Writer子类对象FileWriter，
 * 它的后缀名是父类名，前缀名是自己所具有的功能
 * @author wl-pc
*/
public class FileWriterDemo {

	public static void main(String[] args) throws IOException {

	  //创建一个FileWriter对象，该对象一被初始化就必须要明确被操作的文件。
	  //而且，该文件会被创建到指定的目录下，指定的文件名。如果该目录下已有
	  //同名文件，那么原文件将会被覆盖。其实该步就是要明确数据存放的目的地。
	  //出现IO异常  方法1：抛出异常 方法2：try...catch...异常 
          FileWriter fw = new FileWriter("F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day02\\demo.txt");   
		
	  //调用write()方法，将字符串写入到流中
	  fw.write("hello world!");   
	  //刷新流对象中的缓冲的数据，将数据刷新到目的地中
	  fw.flush();
	  fw.write("wangling!");
	  //close()关闭流资源，但是在关闭之前会刷新一次内部缓冲区中的数据，将数据
	  //刷到目的地中和flush()区别：flush()刷新后，流可以继续使用，但是close()刷新后，会将流关闭
	  fw.close();
	}
}

上面的示例代码没有用到try...catch代码块处理异常下面给出完整的代码处理方式。

例子2：完整的异常处理方式的代码实例演示。

package cn.itheima.day02;
import java.io.FileWriter;
import java.io.IOException;
public class FileWriterDemo2 {
	public static void main(String[] args) {
		FileWriter fw=null;
		try {
                 fw = new FileWriter("F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day02\\demo2.txt");
			fw.write("hello world!");
			fw.flush();
		} catch (IOException e) {
			System.out.println(e.toString());
		} finally{
			if(fw!=null){
				try {
					fw.close();
				} catch (IOException e) {
					System.out.println("close:"+e.toString());
				}
			}
		}	
	}
}

发现的小细节：
     当指定绝对路径时，定义目录分隔符有两种方式：
        1.  反斜线 但是一定要写两个。例：new FileWriter(c:\\emo.txt);
        2.  斜线  / 写一个即可。例：newFileWriter(c:/demo.txt);
 例子3：对已经存在文件的内容进行续写。

package cn.itheima.day02;
import java.io.FileWriter;
import java.io.IOException;
/**
 * 演示：对已有数据的续写
 * @author wl-pc
*/
public class FileWriterDemo3 {
	public static void main(String[] args) {
		FileWriter fw = null;
		try {
		   //传递一个true参数，代表不覆盖已有的文件，并在已有的文件的末尾处进行数据的添加
	           fw=new FileWriter("F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day02\\demo2.txt",true);
		   fw.write("nihao!\r\nxiaoming");    // \r\n表示换行标记
		   fw.flush();
		} catch (IOException e) {
		   System.out.println(e.toString());
		}finally{
		   if(fw!=null){
			try {
			    fw.close();
			} catch (IOException e) {
			    System.out.println("close:"+e.toString());
		        }
		   }
	      }
	}
}

例子4：读取一个已有的文本文件，将文本数据打印出来。（注意：一次读一个字符就打印出来，效率不高。）

package cn.itheima.day02;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class FileReaderDemo1 {
	public static void main(String[] args) {
		FileReader fr = null;
		try {
			//创建一个文件读取流对象，和指定名称的文件相关联
			//要保障此文件已存在，如果不存在，会发生异常(FileNotException异常)
			fr=new FileReader("F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day02\\demo2.txt");
			//调用读取流对象的read()方法
			int ch = 0;
			try {
				while((ch=fr.read())!=-1){   //数据读到结尾，返回结果为-1
					System.out.println("ch="+(char)ch);
				}
			} catch (IOException e) {
				System.out.println(e.toString());
			}
		} catch (FileNotFoundException e) {
			System.out.println(e.toString());
		} finally{
			if(fr != null){
				try {
					fr.close();
				} catch (IOException e) {
					System.out.println("close:"+e.toString());
				}
			}
		}
	}
}

例子5：读取一个已有的文本文件，将文本数据打印出来。（注意：使用while循环把所有的字符都打印出来。）

package cn.itheima.day02;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class FileReaderDemo1 {
	public static void main(String[] args) {
		FileReader fr = null;
		try {
			//创建一个文件读取流对象，和指定名称的文件相关联
			//要保障此文件已存在，如果不存在，会发生异常(FileNotException异常)
			fr=new FileReader("F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day02\\demo2.txt");
			//调用读取流对象的read()方法
			int ch = 0;
			try {
				while((ch=fr.read())!=-1){   //数据读到结尾，返回结果为-1
					System.out.println("ch="+(char)ch);
				}
			} catch (IOException e) {
				System.out.println(e.toString());
			}
		} catch (FileNotFoundException e) {
			System.out.println(e.toString());
		} finally{
			if(fr != null){
				try {
					fr.close();
				} catch (IOException e) {
					System.out.println("close:"+e.toString());
				}
			}
		}
	}
}

例子6：读一个字符就存入字符数组里，读完1Kb再打印。

package cn.itheima.day02;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class FileReaderDemo2 {
	public static void main(String[] args) {
		FileReader fr = null;
		try {
			//创建一个文件读取流对象，和指定名称的文件相关联
			//要保障此文件已存在，如果不存在，会发生异常(FileNotException异常)
			fr=new FileReader("F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day02\\demo2.txt");
			char[] buf = new char[1024];  //该长度通常是1024的整数倍
			int len = 0;
			try {
				while((len=fr.read(buf))!=-1){
                                //使用String(char[] value,int offset,int count)分配
				//一个新的String,它包含取自字符数组参数一个子数组的字符
				System.out.println(new String(buf,0,len));
				}
			} catch (IOException e) {
				System.out.println(e.toString());
			}	
		} catch (FileNotFoundException e) {
			System.out.println(e.toString());
		} finally{
			if(fr != null){
				try {
					fr.close();
				} catch (IOException e) {
					System.out.println("close:"+e.toString());
				}
			}
		}
	}
}

例子7：读取一个*.java的文件，并且打印在控制台上

package cn.itheima.day02;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
/**
 * 演示：读取一个*.java的文件，并且打印在控制台上
 * @author wl-pc
*/
public class FileReaderTest {
	public static void main(String[] args) {
		FileReader fr=null;
		try {
		    fr = new FileReader("F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day02\\FileWriterDemo2.java");
		    char[] buf = new char[1024];
		    int len = 0;
		    try {
				while((len = fr.read(buf))!=-1){
					System.out.println(new String(buf,0,len));
				}
			} catch (IOException e) {
				System.out.println(e.toString());
			}
		} catch (FileNotFoundException e) {
			System.out.println(e.toString());
		} finally{
			if(fr!=null) {
				try {
					fr.close();
				} catch (IOException e) {
					System.out.println(e.toString());
				}
			}
		}
	}
}

例子8：将f盘中的一个文件复制到f盘一个另文本文件中。

package cn.itheima.day02;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/**
 * 将f盘中的一个文件复制到f盘一个另文本文件中
 * 复制原理：其实就是将c盘下的文件数据存储到d盘的一个文件中
 * @author wl-pc 
 * 步骤：1.在d盘创建一个文件，用于存储c盘文件中的数据 
 *       2.定义一个读取流，和c盘文件关联
 *       3.通过不断的读写完成数据的copy
 *       4.关闭资源
 */
public class CopyText {
	public static void main(String[] args) {
		// copy_1();
		   copy_2();
	}

	// 第一种copy的方法
	public static void copy_1() {
		FileWriter fw = null;
		FileReader fr = null;
		try {
			// 创建目的地
			fw = new FileWriter(
					"F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day02\\RuntimeDemo_copy.txt");
			// 与已有文件关联
			fr = new FileReader(
					"F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day02\\FileWriterDemo2.java");
			// 一次读取一个字符直接写了一次到txt文本中，速度慢
			int ch = 0;
			while ((ch = fr.read()) != -1) {
				fw.write(ch);
			}
			fr.close();
			fw.close();
		} catch (IOException e) {
			System.out.println(e.toString());
		} finally {
			if (fw != null) {
				try {
					fw.close();
				} catch (IOException e) {
					System.out.println("close:" + e.toString());
				}
			}
		}
	}

	// 第二种copy的方法
	public static void copy_2() {
		FileWriter fw = null;
		FileReader fr = null;
		try {
			// 创建目的地
			fw = new FileWriter(
					"F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day02\\RuntimeDemo_copy1.txt");
			// 与已有文件关联
			fr = new FileReader(
					"F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day02\\FileWriterDemo2.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 (fw != null) {
				try {
					fw.close();
				} catch (IOException e) {
					System.out.println("close:" + e.toString());
				}
			}
			if (fr != null) {
				try {
					fr.close();
				} catch (IOException e) {
					System.out.println("close:" + e.toString());
				}
			}
		}
	}
}