IO流

一、IO流概述
概述：

     IO流简单来说就是Input和Output流，IO流主要是用来处理设备之间的数据传输，java中对于数据的处理都是通过流实现的，而java用于操作流的对象都在IO包中。

分类：

     按操作数据分为：字节流和字符流。如：Reader和InputStream

按流向分：输入流和输出流。如：InputStream和OutStream

IO常用的基类：

InputStream，OutStream

字符流的抽象基类：

Reader，Writer

由上面四个类派生的子类名称都是以其父类名作为子类的后缀：

如：FileReader和FileInputStream

二、字符流

1、字符流简介：
字符流中的对象融合了编码表，也就是系统默认的编码表，我们的系统一般都是GBK编码。
字符流只处理文本数据，字节流用来处理媒体数据
数据最常见的表现方式是文件，字符流用于操作文件的子类一般是FileReader和FileWriter

2、字符流读写：

注意事项：
写入文件后必须要用flush（）刷新。
用完流记得关闭流。
使用流对象要抛出IO异常

定义文件路径时，可以用“/”或者“\”
在创建一个文件时，如果目录下有同名文件将被覆盖
在读取文件时，必须保证该文件已经存在，否则抛出异常

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

class FileWriteDemo{
public static void main（String[] args）throws IOException{//需要对IO异常进行处理
//创建一个FileWriter对象，该对象一被初始化就必须要明确被操作的文件
FileWriter fw=new new FileWriter（“F：\1.txt”）；//目的明确数据存放位置。
//调用write的方法将字符串写到流中
fw.write（“hello world”）；
//刷新流对象缓冲中的数据，将数据刷到目的地中
fw.flush（）；
//关闭流资源，但是关闭之前刷新一次内部缓冲中的数据。当我们结束输入时候，必须close（）
fw.write（“first–test”）；
fw.close（）；
//flush和close的区别：flush刷新后可以继续输入，close刷新后不能继续输入。
}

}

实例2、FileReader的reader方法
要求：用单个字符和字符数组进行分别读取

1. class FileReaderDemo {
2. public static void main(String[] args) {
3. characters();
4. }
5. 
   
6. /*******字符数组进行读取***********/
7. private static void characters() {
8. 
   
   1. try {
9. 
   
   1. FileReader fr = new FileReader(“Demo.txt”);
10. char [] buf = new char[6];
11. //将Denmo中的文件读取到buf数组中。
12. int num = 0;
13. while((num = fr.read(buf))!=-1) {
14. 
    
    1. //String(char[] value , int offest,int count) 分配一个新的String,包含从offest开始的count个字符
15. sop(new String(buf,0,num));
16. }
17. sop(‘\n’);
18. fr.close();
19. }
20. catch (IOException e) {
21. sop(e.toString());
22. }
23. }
24. 
    
25. 
    
26. 
    
27. /*******单个字母读取***************/
28. private static void singleReader() {
29. 
    
    1. try {
30. 
    
    1. //创建一个文件读取流对象，和指定名称的文件关联。
31. //要保证文件已经存在，否则会发生异常：FileNotFoundException
32. FileReader fr = new FileReader(“Demo.txt”);
33. 
    
34. //如何调用读取流对象的read方法？
35. //read()方法，一次读取一个字符，并且自动往下读。如果到达末尾则返回-1
36. int ch = 0;
37. while ((ch=fr.read())!=-1) {
38. sop((char)ch);
39. }
40. sop(‘\n’);
41. fr.close();
42. 
    
43. /*int ch = fr.read();
44. sop(“ch=” + (char)ch);
45. 
    
    1. int ch2 = fr.read();
46. sop(“ch2=” + (char)ch2);
47. 
    
    1. //使用结束注意关闭流
48. fr.close(); */
49. 
    
50. 
    
    1. }
51. catch (IOException e) {
52. sop(e.toString());
53. }
54. 
    
    1. }
55. 
    
56. /*****************Println*******************/
57. private static void sop(Object obj) {
58. System.out.print(obj);
59. }

78. }

示例3、对已经有的文件进行读写

1. import java.io.*;
2. 
   
   1. class FileWriterDemo3 {
3. public static void main(String[] args) {
4. 
   
   1. try {
5. //传递一个参数,代表不覆盖已有的数据。并在已有数据的末尾进行数据续写
6. FileWriter fw = new FileWriter(“F:\java_Demo\day9_24\demo.txt”,true);
7. fw.write(” is charactor table?”);
8. fw.close();
9. }
10. catch (IOException e) {
11. sop(e.toString());
12. }
13. 
    
    1. }
14. 
    
    1. /*****************Println*******************/
15. private static void sop(Object obj)
16. {
17. System.out.println(obj);
18. }

23. }

将F盘的一个文件复制到E盘
（其实就是将F盘下的文件数据存储D盘的一个文件中）
1.在D盘创建一个文件，存储F盘中文件的数据。
2.定义读取流和F：盘文件关联。
3.通过不断读写完成数据存储。
4.关闭资源。
1. import java.io.*;
2. import java.util.Scanner;
3.
4. class CopyText {
5. public static void main(String[] args) throws IOException {
6. sop(“请输入要拷贝的文件的路径:”);
7. Scanner in = new Scanner(System.in);
8. String source = in.next();
9. sop(“请输入需要拷贝到那个位置的路径以及生成的文件名:”);
10. String destination = in.next();
11. in.close();
12. CopyTextDemo(source,destination);
13.
14. }
15.
16. /*******文件Copy*********************/
17. private static void CopyTextDemo(String source,String destination) {
18.
19. try {
20. FileWriter fw = new FileWriter(destination);
21. FileReader fr = new FileReader(source);
22. char [] buf = new char[1024];
23. //将Denmo中的文件读取到buf数组中。
24. int num = 0;
25. while((num = fr.read(buf))!=-1) {
26. //String(char[] value , int offest,int count) 分配一个新的String,包含从offest开始的count个字符
27. fw.write(new String(buf,0,num));
28. }
29. fr.close();
30. fw.close();
31. }
32. catch (IOException e) {
33. sop(e.toString());
34. }
35. }

36.

三、缓冲区
1. 字符流的缓冲区：BufferedReader和BufferedWreiter
* 缓冲区的出现时为了提高流的操作效率而出现的.
* 需要被提高效率的流作为参数传递给缓冲区的构造函数
* 在缓冲区中封装了一个数组，存入数据后一次取出

BufferedReader示例：
读取流缓冲区提供了一个一次读一行的方法readline，方便对文本数据的获取。
readline（）只返回回车符前面的字符，不返回回车符。如果是复制的话，必须加入newLine（），写入回车符
newLine（）是java提供的多平台换行符写入方法
1. import java.io.*;
2.
3.
4. class BufferedReaderDemo {
5. public static void main(String[] args) throws IOException {
6.
7. //创建一个字符读取流流对象，和文件关联
8. FileReader rw = new FileReader(“buf.txt”);
9.
10. //只要将需要被提高效率的流作为参数传递给缓冲区的构造函数即可
11. BufferedReader brw = new BufferedReader(rw);
12.
13.
14. for(;;) {
15. String s = brw.readLine();
16. if(s==null) break;
17. System.out.println(s);
18. }
19.
20. brw.close();//关闭输入流对象
21.
22. }

23. }

BufferedWriter示例

1. import java.io.*;
2. 
   
3. class BufferedWriterDemo {
4. public static void main(String[] args) throws IOException {
5. 
   
   1. //创建一个字符写入流对象
6. FileWriter fw = new FileWriter(“buf.txt”);
7. 
   
   1. //为了提高字符写入效率，加入了缓冲技术。
8. //只要将需要被提高效率的流作为参数传递给缓冲区的构造函数即可
9. BufferedWriter bfw = new BufferedWriter(fw);
10. 
    
    1. //bfw.write(“abc\r\nde”);
11. //bfw.newLine(); 这行代码等价于bfw.write(“\r\n”),相当于一个跨平台的换行符
12. //用到缓冲区就必须要刷新
13. for(int x = 1; x < 5; x++) {
14. bfw.write(“abc”);
15. bfw.newLine(); //java提供了一个跨平台的换行符newLine();
16. bfw.flush();
17. }
18. 
    
19. 
    
    1. bfw.flush(); //刷新缓冲区
20. bfw.close(); //关闭缓冲区，但是必须要先刷新
21. 
    
    1. //注意，关闭缓冲区就是在关闭缓冲中的流对象
22. fw.close(); //关闭输入流对象
23. 
    
    1. }

32. }

http://www.cnblogs.com/xll1025/p/6418766.html
一、字节流
1、概述：
1、字节流和字符流的基本操作是一样的，但是想操作媒体流就需要用到字节流。
2、字节流因为操作的是字节，所以可以用来操作媒体文件。（媒体文件也是以字节存储的）
3、读写字节流InputStream 输入流（读）和OutPutStream输出流（写）
4、字节流操作可以不用刷新流操作
5、InputStream特有的方法：
int available（）；//返回文件中的字节个数

练习：
需求：复制一张图片F:\java_Demo\day9_28\1.BMP到F:\java_Demo\day9_28\2.bmp

1. class CopyPic {
2. public static void main(String[] args){
3. copyBmp();
4. System.out.println(“复制完成”);
5. }
6. 
   
   1. public static void copyBmp() {
7. 
   
   1. FileInputStream fis = null;
8. FileOutputStream fos = null;
9. try {
10. fis = new FileInputStream(“F:\java_Demo\day9_28\1.bmp”); //写入流关联文件
11. fos = new FileOutputStream(“F:\java_Demo\day9_28\2.bmp”);//读取流关联件
12. byte[] copy = new byte[1024];
13. int len = 0;
14. while((len=fis.read(copy))!=-1) {
15. fos.write(copy,0,len);
16. }
17. }
18. catch (IOException e) {
19. e.printStackTrace();
20. throw new RuntimeException(“复制文件异常”);
21. }
22. finally {
23. try {
24. if(fis!=null) fis.close();
25. }
26. catch (IOException e) {
27. e.printStackTrace();
28. throw new RuntimeException(“读取流”);
29. }
30. }
31. 
    
    1. }
32. 
    
    1. }

2、字节流缓冲区
字节流缓冲区跟字符流缓冲区一样，也是为了提高效率。

注意事项：
1、read();会将字节byte（）提升为int型值
2、write（）；会将int类型转换为byte（）类型，保留最后的8位；

练习：
1、复制MP3文件 1.MP3—>2.MP3
2、自己写一个MyBufferInputStream缓冲类，提升复制速度

代码：

1. import java.io.*;
2. 
   
3. //自己的BufferedInputStream
4. class MyBufferedInputStream {
5. private InputStream in; //定义一个流对象
6. private byte [] buf = new byte[1024*4];
7. private int count = 0,pos = 0;
8. public MyBufferedInputStream(InputStream in){
9. this.in = in;
10. }
11. 
    
    1. public int MyRead() throws IOException{
12. if(count==0) { //当数组里的数据为空时候，读入数据
13. count = in.read(buf);
14. pos = 0;
15. byte b = buf[pos];
16. count–;
17. pos++;
18. return b&255; //提升为int类型，在前面三个字节补充0。避免1111 1111 1111 1111
19. }
20. else if(count > 0) {
21. byte b = buf[pos];
22. pos++;
23. count–;
24. return b&0xff; //提升为int类型，在前面三个字节补充0。避免1111 1111 1111 1111
25. }
26. return -1;
27. }
28. 
    
    1. public void myClose() throws IOException{
29. in.close();
30. }
31. 
    
    1. }
32. 
    
33. 
    
34. class BufferedCopyDemo {
35. public static void main(String[] args) {
36. long start = System.currentTimeMillis();
37. copy();
38. long end = System.currentTimeMillis();
39. System.out.println(“时间:”+(end-start)+”ms”);
40. 
    
41. start = System.currentTimeMillis();
42. copy1();
43. end = System.currentTimeMillis();
44. System.out.println(“时间:”+(end-start)+”ms”);
45. }
46. 
    
    1. public static void copy1() { // 应用自己的缓冲区缓冲数据
47. 
    
    1. MyBufferedInputStream bis = null;
48. BufferedOutputStream bos = null;
49. try {
50. bis = new MyBufferedInputStream(new FileInputStream(“马旭东-入戏太深.mp3”));//匿名类，传入一个InputStream流对象
51. bos = new BufferedOutputStream(new FileOutputStream(“3.mp3”));
52. int buf = 0;
53. while((buf=bis.MyRead())!=-1) {
54. bos.write(buf);
55. }
56. }
57. catch (IOException e) {
58. e.printStackTrace();
59. throw new RuntimeException(“复制失败”);
60. }
61. finally {
62. try {
63. if(bis!=null) {
64. bis.myClose();
65. bos.close();
66. }
67. }
68. catch (IOException e) {
69. e.printStackTrace();
70. }
71. 
    
    1. }
72. 
    
    1. }
73. }

二、流操作规律
1. 键盘读取，控制台打印。
System.out: 对应的标准输出设备：控制台 //它是PrintStream对象，（PrintStream：打印流。OutputStream的子类）
System.in: 对应的标准输入设备：键盘 //它是InputStream对象
示例：

[java] view plain copy

1. /================从键盘录入流，打印到控制台上================/
2. public static void InOutDemo(){
3. //键盘的最常见的写法
4. BufferedReader bufr = null;
5. BufferedWriter bufw = null;
6. try {
7. 
   
   1. /*InputStream ips = System.in; //从键盘读入输入字节流
8. InputStreamReader fr = new InputStreamReader(ips); //将字节流转成字符流
9. bufr = new BufferedReader(fr); */ //将字符流加强，提升效率
10. 
    
11. bufr = new BufferedReader(new InputStreamReader(System.in)); //匿名类。InputSteamReader:读取字节并将其解码为字符
12. bufw = new BufferedWriter(new OutputStreamWriter(System.out)); //OutputStreamWriter:要写入流中的字符编码成字节
13. String line = null;
14. while((line = bufr.readLine())!=null){
15. if(“over”.equals(line)) break;
16. bufw.write(line.toUpperCase()); //打印
17. bufw.newLine(); //为了兼容，使用newLine()写入换行符
18. bufw.flush(); //必须要刷新。不然不会显示
19. }
20. if(bufw!=null) {
21. bufr.close();
22. bufw.close();
23. }
24. }
25. catch (IOException e) {
26. e.printStackTrace();
27. }
28. 
    
29. }

30. }

    1. 整行录入
       1.从键盘录入数据，并存储到文件中。
    2. 我们在键盘录入的是时候，read()方法是一个一个录入的，能不能整行的录入呢？这时候我们想到了BufferedReader中ReadLine()方法。
    3. 转换流
       为了让字节流可以使用字符流中的方法，我们需要转换流。
    4. InputStreamReader:字节流转向字符流；
       a、获取键盘录入对象。
       InputStream in=System.in;
       b、将字节流对象转成字符流对象，使用转换流。
       InputStreamReaderisr=new InputStreamReader(in);
       c、为了提高效率，将字符串进行缓冲区技术高效操作。使用BufferedReader
       BufferedReaderbr=new BufferedReader(isr);
       //键盘录入最常见写法
       BufferedReaderin=new BufferedReader(new InputStreamReader(System.in));
       2.OutputStreamWriter:字符流通向字节流
       示例：

[java] view plain copy

1. /================把键盘录入的数据存到一个文件中==============/
2. public static void inToFile() {
3. //键盘的最常见的写法
4. BufferedReader bufr = null;
5. BufferedWriter bufw = null;
6. try {
7. 
   
   1. /*InputStream ips = System.in; //从键盘读入输入字节流
8. InputStreamReader fr = new InputStreamReader(ips); //将字节流转成字符流
9. bufr = new BufferedReader(fr); */ //将字符流加强，提升效率
10. 
    
11. bufr = new BufferedReader(new InputStreamReader(System.in)); //匿名类。InputSteamReader:读取字节并将其解码为字符
12. bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(“out.txt”))); //OutputStreamWriter:要写入流中的字符编码成字节
13. String line = null;
14. while((line = bufr.readLine())!=null){
15. if(“over”.equals(line)) break;
16. bufw.write(line.toUpperCase()); //打印
17. bufw.newLine(); //为了兼容，使用newLine()写入换行符
18. bufw.flush(); //必须要刷新。不然不会显示
19. }
20. if(bufw!=null) {
21. bufr.close();
22. bufw.close();
23. }
24. }
25. catch (IOException e) {
26. e.printStackTrace();
27. }
28. 
    

29. }

    1. 流操作基本规律
       为了控制格式我将其写入了Java代码段中，如下：
       示例1：文本 ~ 文本

[java] view plain copy

1. /*
2. 流操作的基本规律。
3. 一、两个明确：(明确体系)
4. 1. 明确源和目的
5. 源：输入流 InputStream Reader
6. 目的：输出流 OutputStream Writer
7. 
   
   1. 1. 操作的数据是否是纯文本
8. 是： 字符流
9. 否： 字节流
10. 二、明确体系后要明确具体使用的对象
11. 通过设备区分：内存，硬盘，键盘
12. 目的设备：内存，硬盘，控制台
13. 
    
14. 示例1：将一个文本文件中的数据存储到另一个文件中: 复制文件
15. 一、明确体系
16. 源：文件–>读取流–>(InputStream和Reader)
17. 是否是文本：是–>Reader
18. 
    
19. 目的：文件–>写入流–>(OutputStream Writer)
20. 是否纯文本：是–>Writer
21. 
    
    1. 二、 明确设备
22. 源：Reader
23. 设备：硬盘上一个文本文件 –> 子类对象为：FileReader
24. FileReader fr = new FileReader(“Goods.txt”);
25. 
    
    1. 是否提高效率：是–>加入Reader中的缓冲区：BufferedReader
26. BufferedReader bufr = new BufferedReader(fr);
27. 
    
    1. 目的：Writer
28. 设备：键盘上一个文本文件 –> 子类对象：FileWriter
29. FileWriter fw = new FileWriter(“goods1.txt”);
30. 是否提高效率：是–>加入Writer的缓冲区：BufferedWriter
31. BufferedWriter bufw = new BufferedWriter(fw);
32. 
    
33. 
    
    1. 示例2：将一个图片文件数据复制到另一个文件中：复制文件
34. 一、明确体系
35. 源：文件–>读取流–>(InputStream和Reader)
36. 是否是文本：否–>InputStream
37. 
    
38. 目的：文件–>写入流–>(OutputStream Writer)
39. 是否纯文本：否–>OutputStream
40. 
    
    1. 二、 明确设备
41. 源：InputStream
42. 设备：硬盘上一个媒体文件 –> 子类对象为：FileInputStream
43. FileInputStream fis = new FileInputStream(“Goods.txt”);
44. 
    
    1. 是否提高效率：是–>加入InputStream中的缓冲区：BufferedInputStream
45. BufferedInputStream bufi = new BufferedInputStream(fis);
46. 
    
    1. 目的：OutputStream
47. 设备：键盘上一个媒体文件 –> 子类对象：FileOutputStream
48. FileOutputStream fos = new FileOutputStream(“goods1.txt”);
49. 是否提高效率：是–>加入OutputStream的缓冲区：BufferedOutputStream
50. BufferedOutputStream bufo = new BufferedOutputStream(fw);
51. 
    
    1. 示例3：将键盘录入的数据保存到一个文本文件中
52. 一、明确体系
53. 源：键盘–>读取流–>(InputStream和Reader)
54. 是否是文本：是–>Reader
55. 
    
56. 目的：文件–>写入流–>(OutputStream Writer)
57. 是否纯文本：是–>Writer
58. 
    
    1. 二、 明确设备
59. 源：InputStream
60. 设备：键盘 –> 对用对象为：System.in –> InputStream
61. 为了操作方便，转成字符流Reader –> 使用Reader中的转换流：InputStreamReader
62. InputStreamReader isr = new InputStreamReader(System.in);
63. 
    
    1. 是否提高效率：是–>加入Reader中的缓冲区：BufferedReader
64. BufferedReader bufr = new BufferedReader(isr);
65. 
    
    1. 目的：Writer
66. 设备：键盘上一个文本文件 –> 子类对象：FileWriter
67. FileWriter fw = new FileWriter(“goods1.txt”);
68. 是否提高效率：是–>加入Writer的缓冲区：BufferedWriter
69. BufferedWriter bufw = new BufferedWriter(fw);
    5.指定编码表(转换流可以指定编码表)
    要求：用UTF-8编码存储一个文本文件

[java] view plain copy

1. import java.io.*;
2. public class IOStreamLaw {
3. 
   
   1. /**
4. • @param args
5. */
6. public static void main(String[] args) throws IOException {
7. //键盘的最常见写法
8. BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
9. BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(“goods1.txt”),”UTF-8”));
10. String line = null;
11. while((line=bufr.readLine())!=null){
12. if(“over”.equals(line)) break;
13. bufw.write(line.toUpperCase());
14. bufw.newLine();
15. bufw.flush();
16. }
17. bufr.close();
18. }
19. 
    
20. }