14：IO之字符字节流

字节流：
InputStream   
 OutputStream 
字节流： 
FileInputStream
FileOutputStream
BufferedInputStream
BufferedOutputStream
字符流：
Writer Reader
FileReader
FileWriter
BufferedReader
BufferedWriter

第一  IO流概述

一、概述：

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

1、特点：

1）流操作按照数据可分为字节流(处理所有的数据)和字符流(处理文字，其中包含编码表，可以指定编码表防止了编码表不同而产生乱码的现象)

2）按照流向分可以分为输出流和输入流。

字节流的抽象基类：InputStream（读）、OutputStream（写）

字符流的抽象基类：Reader（读）、Writer（写）

注：此四个类派生出来的子类名称都是以父类名作为子类名的后缀，以前缀为其功能；


第二  字符流

一、简述：

1、字符流中的对象融合了编码表。使用的是默认的编码，即当前系统的编码。

2、字符流只用于处理文字数据，而字节流可以任何数据。

3、既然IO流是用于操作数据的，那么数据的最常见体现形式是文件。专门用于操作文件的子类对象：FileWriter、FileReader

二、写入字符流

  • 数据的续写是通过构造函数 FileWriter(String s,boolean append)，根据给定文件名及指示是否附加写入数据的boolean值来构造FileWriter对象。为true时就是续写，为false就是不续写。 
  • 调用write()方法，将字符串写入到流中。这里他本身没有特定的写方法都是继承自父类的方法有写单个字符：write(int c)，写入字符数组：write(char[] cbuf)这里的数组一般定义成1024的整数倍，不宜过大，过大容易造成内存溢出。写入字符数组的某一部分：write(char[] cbuf, int off, int len)，写入字符串：write(String str)，写入字符串的某一部分：write(String str, int off, int len)

  1.  *   
  2.  * 需求:在硬盘上，创建一个文件并写入一些文字数据。  
  3.  * 找到一个专门用于操作文件的Writer子类对象。FileWriter。  后缀名是父类名。 前缀名是该流对象的功能。  
  4.  */  
  5. public class FileWriterDemo {  
  6.     public static void main(String[] args) {  
  7.         method();//写内容  
  8.         method2();//续写内容  
  9.     }  
  10.       
  11.     /*  
  12.      * 写数据  
  13.      */  
  14.     public static void method(){  
  15.         FileWriter fw = null;  
  16.         try {  
  17.             //创建一个FileWriter对象。该对象一被初始化就必须要明确被操作的文件。  
  18.             //该文件会被存放在指定的目录下，如果该文件已经存在，会被覆盖  
  19.             //其实该步就是在明确数据要存放的目的地。  
  20.             fw = new FileWriter("testwrite.txt");// C:\\testwrite.txt  
  21.               
  22.             //调用write方法，将字符串写入到流中  
  23.             fw.write("asdsadafsd");  
  24.               
  25.             //刷新流对象中的缓冲中的数据。  
  26.             //将数据刷到目的地中。  
  27. //          fw.flush();  
  28.               
  29.             //关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据。  
  30.             //将数据刷到目的地中。  
  31.             //和flush区别：flush刷新后，流可以继续使用，close刷新后，会将流关闭。  
  32. //          fw.close();  
  33.         } catch (IOException e) {  
  34.             e.printStackTrace();  
  35.         }finally{  
  36.             try {  
  37.                 if(fw != null)  
  38.                     fw.close();  
  39.             } catch (IOException e) {  
  40.                 e.printStackTrace();  
  41.             }  
  42.         }  
  43.     }  
  44.       
  45.     /*  
  46.      * 在文件原有内容的基础上续写内容  
  47.      */  
  48.     public static void method2(){  
  49.         FileWriter fw = null;  
  50.         try {  
  51.             fw = new FileWriter("testwrite.txt", true);  
  52.             fw.write("\r\nnihao\r\nxiexie");//\r\n是换行符\n是linux下的换行  
  53.         } catch (IOException e) {  
  54.             e.printStackTrace();  
  55.         }finally{  
  56.             if(fw != null){  
  57.                 try {  
  58.                     fw.close();  
  59.                 } catch (IOException e) {  
  60.                     e.printStackTrace();  
  61.                 }  
  62.             }  
  63.         }  
  64.     }  
  65. }  
     

三、读取字符流

  • 创建一个文件读取流对象，和指定名称的文件相关联。要保证该文件已经存在，若不存在，将会发生异常FileNotFoundException。
  • 调用读取流对象的read()方法。read()：一次读一个字符，且会继续往下读。（方法1）

    read()读取单个字符。read(char[] cbuf)将字符读入数组。（方法2）其实都是按照每次只读取一个字符的方式读取的，只是读到数组中会把读取到的数据存放在数组中，起到一个临时缓存的作用，提高了读取效率。

    1. 演示1：
    2.  public static void main(String[] args) throws IOException {
    4.       FileReader fr = new FileReader("demo.txt");
    6.       int ch = 0;
    7.  
    8.       while((ch=fr.read())!=-1){// abcde读5次
    9.       System.out.println((char)ch);
    10.      fr.close();
    11.   }
    12.  
    14. 演示2：
    15. public class FileReaderDemo2 {
    16.    public static void main(String[] args) throws IOException {
    17.         FileReader fr = new FileReader("demo.txt");
    18.  
    19.   /*
    20.    * 使用read(char[])读取文本文件数据。
    21.    *  
    22.    * 先创建字符数组。
    23.    */
    24.   char[] buf = new char[1024];
    25.  
    26.   int len = 0;
    27.  
    28.   while((len=fr.read(buf))!=-1){ // abcde读1次，提高效率，是一个数组一个数组的读
    29.    System.out.println(new String(buf,0,len));
    30.   }
    31.  
    32.   /*  
    33.   int num = fr.read(buf);//将读取到的字符存储到数组中。读到几个几个变成数组
    34.   System.out.println(num+":"+new String(buf,0,num));
    35.   int num1 = fr.read(buf);//将读取到的字符存储到数组中。
    36.   System.out.println(num1+":"+new String(buf,0,num1));
    37.   int num2 = fr.read(buf);//将读取到的字符存储到数组中。
    38.   System.out.println(num2+":"+new String(buf));
    39.   */
    40.      fr.close(); 
    41. }



四、文件的拷贝：

原理：其实就是将磁盘下的文件数据读取出来，然后写入磁盘的一个文件中

步骤：
1、在硬盘上创建一个文件，用于存储读取出来的文件数据
2、定义读取流和文件关联
3、通过不断读写完成数据存储
方式一：读取一个字符，存入一个字符
方式二：先将读取的数据存入到内存中，再将存入的字符取出写入硬盘
4、关闭流资源：输入流资源和输出流资源。


  1. 方法1：
  2. /*
  3.  * 思路：
  4.  * 1，需要读取源，
  5.  * 2，将读到的源数据写入到目的地。
  6.  * 3，既然是操作文本数据，使用字符流。
  7.  *
  8.  */
  9. public class CopyTextTest {
  10.     public static void main(String[] args) throws IOException {
  11.       //1,读取一个已有的文本文件，使用字符读取流和文件相关联。
  12.       FileReader fr = new FileReader("IO流_2.txt");
  13.       //2,创建一个目的，用于存储读到数据。
  14.       FileWriter fw = new FileWriter("copytext_1.txt");
  15.       //3,频繁的读写操作。
  16.       int ch = 0;
  17.       while((ch=fr.read())!=-1){
  18.       fw.write(ch);
  19.   }
  20.      //4,关闭流资源。先关写再关读
  21.      fw.close();
  22.      fr.close();
  23.   }
  24. } 
  1. 方法2：
  2. public class CopyTextTest_2 {
  3.     private static final int BUFFER_SIZE = 1024;
  4.     public static void main(String[] args) {
  5.         FileReader fr = null;
  6.         FileWriter fw = null;
  7.         try {
  8.             fr = new FileReader("IO流_2.txt");
  9.             fw = new FileWriter("copytest_2.txt");
  10.    
  11.             //创建一个临时容器，用于缓存读取到的字符。
  12.             char[] buf = new char[BUFFER_SIZE];//这就是缓冲区。
  13.    
  14.            //定义一个变量记录读取到的字符数，(其实就是往数组里装的字符个数 )
  15.             int len = 0;
  16.    
  17.            while((len=fr.read(buf))!=-1){
  18.           fw.write(buf, 0, len);
  19.          }
  20.    
  21.      } catch (Exception e) {
  22.      // System.out.println("读写失败");
  23.       throw new RuntimeException("读写失败");
  24.      }finally{
  25.          if(fw!=null)
  26.     try {
  27.         fw.close();
  28.     } catch (IOException e) {
  29.      
  30.      e.printStackTrace();
  31.     }
  32.    if(fr!=null)
  33.         try {
  34.         fr.close();
  35.     } catch (IOException e) {
  36.      
  37.      e.printStackTrace();
  38.     }
  39.   }
  40.  }
  41. }

第三  字符缓冲区

一、写入缓冲区BufferedWriter 
  1. /
  2.  * 缓冲区的出现就是为了提高操作流的效率  
  3.  * 所以在创建缓冲区之前必须要先有流对象  
  4.  *   
  5.  * 缓冲区提供了一个跨平台的换行符 new Line();  
  6.  */  
  7. public class BufferedWriterDemo {  
  8.     public static void main(String[] args) {  
  9.         method();  
  10.     }  
  11.   
  12.     public static void method() {  
  13.         // 创建一个字符写入流对象  
  14.         FileWriter fw = null;  
  15.         BufferedWriter bfw = null;  
  16.         try {  
  17.             fw = new FileWriter("buf.txt");  
  18.             // 为了提高字符写入流效率。加入了缓冲技术。其实缓冲区就是封装了数组，不用自己定义数组，用起来更方便  
  19.             // 只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可。  
  20.             bfw = new BufferedWriter(fw);  
  21.   
  22.             for (int x = 0; x < 10; x++) {  
  23.                 bfw.write("abcds" + x);  
  24.                 bfw.newLine();// 换行在windows中相当于\r\n,在linux中相当于\n  
  25.             }  
  26.             // 记住，只要用到缓冲区，就要记得刷新。  
  27.             // bufw.flush();  
  28.         } catch (IOException e) {  
  29.             e.printStackTrace();  
  30.         } finally {  
  31.             try {  
  32.                 bfw.close();// 关闭缓冲区就是在关闭缓冲区中的流对象，关闭前刷新  
  33.             } catch (IOException e) {  
  34.                 e.printStackTrace();  
  35.             }  
  36.         }  
  37.     }  
  38. }
  1.  private static final String LINE_SEPARATOR = System.getProperty("line.separator");  
  2.     //使用缓冲区的写入方法将数据先写入到缓冲区中。
  3.     // bufw.write("abcdefq"+LINE_SEPARATOR+"hahahha");
  4.     // bufw.write("xixiixii");
  5.    // bufw.newLine(); 行分隔，就不需要LINE_SEPARATOR，不过只在这里有效
  6.    // bufw.write("heheheheh");

二、读取流缓冲区BufferedReader

该缓冲区提供了一个一次读一行的方法readLine()，方便与对文本数据的获取，当返回null时，表示读到文件末尾。

      readLine()方法返回的时只返回回车符之前的数据内容，并不返回回车符，即读取的内容中不包含任何行终止符（回车符和换行符）。

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

  2. public class BufferedReaderDemo {  
  3.     public static void main(String[] args) {  
  4.         method();  
  5.     }  
  6.       
  7.     public static void method(){  
  8.         //创建一个读取流对象  
  9.         FileReader fr = null;  
  10.         BufferedReader bfr = null;  
  11.         try {  
  12.             fr = new FileReader("buf.txt");  
  13.             //为了提高效率。加入缓冲技术。将字符读取流对象作为参数传递给缓冲对象的构造函数。  
  14.             bfr = new BufferedReader(fr);  
  15.               
  16. //          char[] buf = new char[1024];  
  17. //          bfr.read(buf);  
  18. //          int len = 0;  
  19. //          while((len = bfr.read(buf)) != -1){  
  20. //              System.out.println(new String(buf,0,len));  
  21. //          }  
  22.               
  23.             String line = null;  
  24.             while((line = bfr.readLine()) != null){  
  25.                 System.out.println(line);  
  26.             }  
  27.         } catch (IOException e) {  
  28.             e.printStackTrace();  
  29.         }finally{  
  30.             try {  
  31.                 bfr.close();  
  32.             } catch (IOException e) {  
  33.                 e.printStackTrace();  
  34.             }  
  35.         }  
  36.     }  
  37. }

三、通过缓冲技术提高效率复制文件：
  1. public class CopyTextByBufTest {
  2. 	//不处理异常，抛出去
  3. 	public static void main(String[] args) throws IOException {
  4. 		FileReader fr = new FileReader("buf.txt");
  5. 		BufferedReader bufr = new BufferedReader(fr);
  7. 		FileWriter fw = new FileWriter("buf_copy.txt");
  8. 		BufferedWriter bufw = new BufferedWriter(fw);
  10. 		String line = null;
  11. 		while ((line = bufr.readLine()) != null) {
  12. 			bufw.write(line);
  13. 			bufw.newLine();
  14. 			bufw.flush();
  15. 		}
  16. 		/*
  17. 		 * int ch = 0;
  18. 		 * 
  19. 		 * while((ch=bufr.read())!=-1){
  20. 		 * 
  21. 		 * bufw.write(ch); }
  22. 		 */
  23. 		bufw.close();
  24. 		bufr.close();
  25. 	}
  26. }
处理异常try...catch
  1. public class CopyByBuffer {  
  2.     public static void main(String[] args) {  
  3.         copyByBuf();  
  4.     }  
  5.   
  6.     public static void copyByBuf() {  
  7.         FileWriter fw = null;  
  8.         FileReader fr = null;  
  9.         BufferedWriter bfw = null;  
  10.         BufferedReader bfr = null;  
  11.   
  12.         try {  
  13.             fw = new FileWriter("C:\\buffertest.txt");//创建写文件对象  
  14.             fr = new FileReader("buffertest.txt");//创建读文件对象  
  15.             bfw = new BufferedWriter(fw);//使用缓冲区关联读写对象  
  16.             bfr = new BufferedReader(fr);  
  17.   
  18.             String line = null;  
  19.             while ((line = bfr.readLine()) != null) {//通过读一行的方式提高效率  
  20.                 bfw.write(line);  
  21.                 bfw.newLine();//换行，夸平台  
  22.             }  
  23.         } catch (IOException e) {  
  24.             e.printStackTrace();  
  25.         } finally {  
  26.             if (bfw != null) {  
  27.                 try {  
  28.                     bfw.close();  
  29.                 } catch (IOException e) {  
  30.                     e.printStackTrace();  
  31.                 }  
  32.             }  
  33.   
  34.             if (bfr != null) {  
  35.                 try {  
  36.                     bfr.close();  
  37.                 } catch (IOException e) {  
  38.                     e.printStackTrace();  
  39.                 }  
  40.             }  
  41.         }  
  42.     }  
  43. }


四、自定义缓冲区
其实就是模拟一个BufferedReader.
 * 分析：
 * 缓冲区中无非就是封装了一个数组，并对外提供了更多的方法对数组进行访问。 其实这些方法最终操作的都是数组的角标。
 *
 * 缓冲的原理：
 * 其实就是从源中获取一批数据装进缓冲区中。在从缓冲区中不断的取出一个一个数据。
 * 在此次取完后，在从源中继续取一批数据进缓冲区。 当源中的数据取光时，用-1作为结束标记。
  1. public class MyBufferedReader extends Reader {
  2. 	 private Reader r;
  3. 	 
  4. 	 //定义一个数组作为缓冲区。
  5. 	 private char[] buf = new char[1024];
  6. 	 
  7. 	 //定义一个指针用于操作这个数组中的元素。当操作到最后一个元素后，指针应该归零。
  8. 	 private int pos = 0;
  9. 	 
  10. 	 
  11. 	 //定义一个计数器用于记录缓冲区中的数据个数。 当该数据减到0，就从源中继续获取数据到缓冲区中。
  12. 	 private int count = 0;
  14. 	 MyBufferedReader(Reader r){
  15. 	  this.r = r;
  16. 	 }
  17. 	/**
  18. 	  * 该方法从缓冲区中一次取一个字符。
  19. 	  * @return
  20. 	  * @throws IOException
  21. 	  */
  22. 	/*
  23. 	public int myRead() throws IOException{ 
  24. 	  //从源中获取一批数据到缓冲区中。需要先做判断，只有计数器为0时，才需要从源中获取数据。
  25. 	  if(count==0){
  26. 	   count = r.read(buf); //这是在底层
  27. 	   
  28. 	   if(count<0)//没有了
  29. 	    return -1;
  30. 	   
  31. 	   //每次获取数据到缓冲区后，角标归零（第一个read，底层）创建了一个数组。
  32. 	   pos = 0;
  33. 	   char ch = buf[pos];
  34. 	  // 然后调用一次（第二个）read，返回一个a,再调用返回b,角标取一个，count减一个
  35. 	   pos++;
  36. 	   count--;
  37. 	   
  38. 	   return ch;
  39. 	   
  40. 	  }
  41. 	else if(count>0){//第二次调用的时候count就不为0了， 不需要count = r.read(buf)这一步了
  42. 	   
  43. 	   char ch = buf[pos];
  44. 	   
  45. 	   pos++;
  46. 	   count--;
  47. 	   
  48. 	   return ch;
  49. 	   
  50. 	  }*/


  1. 优化后
  2.  public int myRead() throws IOException{
  3.  
  4.   if(count==0){
  5.    count = r.read(buf);
  6.    pos = 0;
  7.   }
  8.   if(count<0)
  9.    return -1;
  10.  
  11.   char ch = buf[pos++];
  12.  
  13.   count--;
  14.  
  15.   return ch;
  16.    } 
  17.
五、模拟ReadLine
  1. public String myReadLine() throws IOException{
  2. 	 
  3. 	  // 定义一个临时容器，原BufferedReader封装的是字符数组，这里定义StringBuilder演示原理  
  4. 	  StringBuilder sb = new StringBuilder();
  5. 	 
  6. 	  int ch = 0;
  7. 	  while((ch = myRead())!=-1){
  8. 	   
  9. 	   if(ch=='\r') //如是'\r'继续往下读  
  10. 	    continue;
  11. 	   if(ch=='\n') //读到'\n'就停止读，然后将这些数据返回  
  12. 	    return sb.toString();
  13. 	   //将从缓冲区中读到的字符，存储到缓存行数据的缓冲区中。
  14. 	   sb.append((char)ch);
  15. 	     }   
  16. 	 
  17. 	  if(sb.length()!=0) //最后没有空格，说明有东西，返回，
  18. 	//这里是防止最后一行没有回车符的情况  
  19. 	   return sb.toString();
  20. 	  return null;
  21. 	 }
  22. 	 public void myClose() throws IOException {
  23. 	 
  24. 	  r.close();
  25. 	 }
  26. 	 @Override
  27. 	 public int read(char[] cbuf, int off, int len) throws IOException {
  28. 	 
  29. 	  return 0;
  30. 	 }
  31. 	 @Override
  32. 	 public void close() throws IOException {
  33. 	 }
  34. 	}
  36. 	运行 ReadLine
  37. 	public class MyBufferedReaderDemo {
  38. 	 public static void main(String[] args) throws IOException {
  39. 	  FileReader fr = new FileReader("buf.txt");
  40. 	 
  41. 	  MyBufferedReader bufr = new MyBufferedReader(fr);
  42. 	 
  43. 	  String line = null;
  44. 	 
  45. 	  while((line=bufr.myReadLine())!=null){
  46. 	   System.out.println(line);
  47. 	  }
  48. 	 
  49. 	  bufr.myClose();
  50. 	     
  51. 	 
  52. 	  Collections.reverseOrder();
  53. 	  HashMap map = null;
  54. 	  map.values();
  55. 	   } 
  56. 	}
六、LineNumberReader（功能增强的读）

在BufferedReader中有个直接的子类LineNumberReader，其中有特有的方法获取和设置行号：

setLineNumber()和getLineNumber()

  1. public class LineNumberReaderDemo {
  3. 	public static void main(String[] args) throws IOException {
  4. 		FileReader fr = new FileReader("IO流_2.txt");
  5. 		LineNumberReader lnr = new LineNumberReader(fr);
  7. 		String line = null;
  8. 		lnr.setLineNumber(100);// 默认是0
  9. 		while ((line = lnr.readLine()) != null) {
  10. 			System.out.println(lnr.getLineNumber() + ":" + line);
  11. 		}
  13. 		lnr.close();
  14. 	}
  15. }

第四  装饰设计模式

装饰设计模式： (buffer就是装饰设计模式)
 对一组对象的功能进行增强时，就可以使用该模式进行问题的解决。
  装饰和继承都能实现一样的特点：进行功能的扩展增强。 
有什么区别呢？ 
首先有一个继承体系。
Writer （抽取了一个写的）
 |--TextWriter （随便写的）:用于操作文本
 |--MediaWriter：用于操作媒体。
 
想要对操作的动作进行效率的提高。
按照面向对象，可以通过继承对具体的进行功能的扩展。
效率提高需要加入缓冲技术。
 
Writer
 |--TextWriter:用于操作文本
  |--BufferTextWriter:加入了缓冲技术的操作文本的对象。
 |--MediaWriter：用于操作媒体。
  |--BufferMediaWriter:
到这里就哦了。但是这样做好像并不理想。
如果这个体系进行功能扩展，有多了流对象。
那么这个流要提高效率，是不是也要产生子类呢？是。这时就会发现只为提高功能，进行的继承，
导致继承体系越来越臃肿。不够灵活。
重新思考这个问题？
既然加入的都是同一种技术--缓冲。
前一种是让缓冲和具体的对象相结合。
可不可以将缓冲进行单独的封装，哪个对象需要缓冲就将哪个对象和缓冲关联。
  1. class Buffer {
  2. 	Buffer(TextWriter w) // 要缓冲谁就加入进来
  3. 	{
  4. 	}
  6. 	Buffer(MediaWirter w) // 要缓冲谁就加入进来
  7. 	{
  8. 	}
  9. } // 但是这样做，来新对象还得加入，比较麻烦
  11. // 都能写入，为了名字有意义，写成BufferWriter
  12. class BufferWriter extends Writer {
  13. 	BufferWriter(Writer w) {
  14. 	}
  15. }

Writer
 |--TextWriter:用于操作文本
 |--MediaWriter：用于操作媒体。
 |--BufferWriter:用于提高效率。

  装饰比继承灵活。 
特点：装饰类和被装饰类都必须所属同一个接口或者父类。 
有个类想要增强，可以用装饰设计模式，把被装饰的类往里传进来就可以

第五  字节流

一、概述：

1、字节流和字符流的原理是相似的，而字符流是基于字节流的，字节流可以操作如媒体等其他数据，如媒体（MP3，图片，视频）等

2、由于媒体数据中都是以字节存储的，所以，字节流对象可直接对媒体进行操作，而不用再进行刷流动作。

3、InputStream     --->  输入流（读）  OutputStream  --->  输出流（写）

4、为何不用进行刷流动作：因为字节流操作的是字节，即数据的最小单位，不需要像字符流一样要进行转换为字节。可直接将字节写入到指定文件中，但是需要在写代码的时候，如果有字符串，要将字符串转为字节数组再进行操作。

5、FileInputStream特有方法：int available() --->  返回数据字节的长度，包含终止符

在定义字节数组长度的时候，可以用到这个方法：byte[] = new byte[fos.available()]   （fos为字节流对象）但是，对于这个方法要慎用，如果字节过大，超过jvm所承受的大小（一般内存为64M），就会内存溢出。

实例：
  1.  /
  2.  * 字节流操作  
  3.  * InputStream OutputStream  
  4.  *   
  5.  */  
  6. public class FileStreamDemo {  
  7.     public static void main(String[] args) {  
  8.         // writeFile();  
  9.         // readFile_1();  
  10.         // readFile_2();  
  11.         readFile_3();  
  12.     }  
  13.   
  14.     /*  
  15.      * 对字节流读操作的第一种方式 通过read()方法读取一个字节  
  16.      */  
  17.     public static void readFile_1() {  
  18.         FileInputStream fis = null;// 定义字节输入流  
  19.         try {  
  20.             fis = new FileInputStream("fos.txt");// 指定输入流和文件关联  
  21.             int ch = 0;  
  22.             while ((ch = fis.read()) != -1) {// 读取操作  
  23.                 System.out.println((char) ch);  
  24.             }  
  25.         } catch (FileNotFoundException e) {  
  26.             e.printStackTrace();  
  27.         } catch (IOException e) {  
  28.             e.printStackTrace();  
  29.         } finally {  
  30.             try {  
  31.                 if (fis != null)// 判空，提高程序的健壮性  
  32.                     fis.close();  
  33.             } catch (IOException e) {  
  34.                 e.printStackTrace();  
  35.             }  
  36.         }  
  37.     }  
  38.   
  39.     /*  
  40.      * 对字节流读操作的第二种方式 通过read(byte[])方法读取字节数组  
  41.      */  
  42.     public static void readFile_2() {  
  43.         FileInputStream fis = null;  
  44.         try {  
  45.             fis = new FileInputStream("fos.txt");  
  46.             byte[] byf = new byte[1024];  
  47.             int len = 0;  
  48.             while ((len = fis.read(byf)) != -1) {  
  49.                 System.out.println(new String(byf, 0, len));  
  50.             }  
  51.         } catch (FileNotFoundException e) {  
  52.             e.printStackTrace();  
  53.         } catch (IOException e) {  
  54.             e.printStackTrace();  
  55.         } finally {  
  56.             try {  
  57.                 if (fis != null)  
  58.                     fis.close();  
  59.             } catch (IOException e) {  
  60.                 e.printStackTrace();  
  61.             }  
  62.         }  
  63.     }  
  64.   
  65.     /*  
  66.      * 对字节流读操作的第三种方式 通过字节流的available()方法获取到文件大小，定义一个大小刚刚好的数组，无需循环  但是，这种方式操作较大数据时容易内存溢出，所以要慎用 首选的还是定义1024的整数倍数组  
  67.      */  
  68.     public static void readFile_3() {  
  69.         FileInputStream fis = null;  
  70.         try {  
  71.             fis = new FileInputStream("fos.txt");  
  72.             // 通过这样的方式定义一个刚刚好的数组  
  73.             // 这种方法慎用，如果文件不大，可以用这个方法  
  74.             byte[] byf = new byte[fis.available()];// fis.available()获取文件大小  
  75.             fis.read(byf);  
  76.             System.out.println(new String(byf));  
  77.         } catch (FileNotFoundException e) {  
  78.             e.printStackTrace();  
  79.         } catch (IOException e) {  
  80.             e.printStackTrace();  
  81.         } finally {  
  82.             try {  
  83.                 fis.close();  
  84.             } catch (IOException e) {  
  85.                 e.printStackTrace();  
  86.             }  
  87.         }  
  88.     }  
  89.   
  92.     /*  
  93.      * 对字节流进行写操作  
  94.      */  
  95.     public static void writeFile() {  
  96.         FileOutputStream fos = null;  
  97.         try {  
  98.             fos = new FileOutputStream("fos.txt");//定义字节写出流和文件关联  
  99.             fos.write("abcds".getBytes());// str.getBytes()将String转化成字节数组  
  100.         } catch (FileNotFoundException e) {  
  101.             e.printStackTrace();  
  102.         } catch (IOException e) {  
  103.             e.printStackTrace();  
  104.         } finally {  
  105.             if (fos != null)  
  106.                 try {  
  107.                     fos.close();// 因为字节流没有用到缓冲区，所以不需要刷新，但必须关闭资源  
  108.                 } catch (IOException e) {  
  109.                     e.printStackTrace();  
  110.                 }  
  111.         }  
  112.     }  
  113. }
二、通过字节流复制媒体文件

思路：

1、用字节流读取流对象和媒体文件相关联

2、用字节写入流对象，创建一个媒体文件，用于存储获取到的媒体文件数据

3、通过循环读写，完成数据的存储

4、关闭资源

  2.  * 通过字节流拷贝图片  
  3.  */  
  4. public class CopyPicture {  
  5.     public static void main(String[] args) {  
  6.         copyPic();  
  7.     }  
  8.   
  9.     public static void copyPic() {  
  10.         FileInputStream fis = null;  
  11.         FileOutputStream fos = null;  
  12.         try {  
  13.             fis = new FileInputStream("1.jpg");  
  14.             fos = new FileOutputStream("C:\\1.jpg");  
  15.   
  16.             byte[] byf = new byte[1024];  
  17.             int len = 0;  
  18.             while ((len = fis.read(byf)) != -1) {// 将数据读取到数组中  
  19.                 fos.write(byf, 0, len);// 写入数组中的有效数据  
  20.             }  
  21.         } catch (FileNotFoundException e) {  
  22.             e.printStackTrace();  
  23.         } catch (IOException e) {  
  24.             e.printStackTrace();  
  25.         } finally {  
  26.             // 有多个流不能一起关闭，要分别关闭  
  27.             if (fis != null) {  
  28.                 try {  
  29.                     fis.close();  
  30.                 } catch (IOException e) {  
  31.                     e.printStackTrace();  
  32.                 }  
  33.             }  
  34.             if (fos != null) {  
  35.                 try {  
  36.                     fos.close();  
  37.                 } catch (IOException e) {  
  38.                     e.printStackTrace();  
  39.                 }  
  40.             }  
  41.         }  
  42.     }  
  43. }  
  44. //	千万不要用，效率没有！
  45.  public static void copy_4() throws IOException {
  46.   FileInputStream fis = new FileInputStream("c:\\0.mp3");
  47.   FileOutputStream fos = new FileOutputStream("c:\\4.mp3");
  48.  
  49.   int ch = 0; 
  50.  
  51.   while((ch =fis.read())!=-1){
  52.    fos.write(ch);
  53.   }
  54.  
  55.   fos.close();
  56.   fis.close();
  57.  }
  58.  //不建议。
  59.  public static void copy_3() throws IOException {
  60.   FileInputStream fis = new FileInputStream("c:\\0.mp3");
  61.   FileOutputStream fos = new FileOutputStream("c:\\3.mp3");
  62.  
  63.   byte[] buf = new byte[fis.available()];
  64.   fis.read(buf);
  65.   fos.write(buf);
  66.   fos.close();
  67.   fis.close();
  68.  }
  69. //提高效率
  70. public static void copy_2() throws IOException {
  71.  
  72.   FileInputStream fis = new FileInputStream("c:\\0.mp3");
  73.   BufferedInputStream bufis = new BufferedInputStream(fis);
  74.  
  75.   FileOutputStream fos = new FileOutputStream("c:\\2.mp3");
  76.   BufferedOutputStream bufos = new BufferedOutputStream(fos);
  77.  
  78.    int ch = 0; 
  79.  
  80.   while((ch=bufis.read())!=-1){
  81.    bufos.write(ch);
  82.   }
  83.  
  84.   bufos.close();
  85.   bufis.close();
  86.  }
三、字节流缓冲区

1、缓冲区的出现无非就是提高了流的读写效率，当然也就是因为这样，所以缓冲区的使用频率也是相当高的，所以要做必要性的掌握。

2、字节流缓冲区读写的特点：

这里没有什么特殊的读写方法，就是read()读一个字节，read(byte[])读数组的方法。写write(int b)写一个自己，write(byte[])写数组的方法。

注：需要注意个地方，write方法只写出二进制的最后八位。

原理：将数据拷贝一部分，读取一部分，循环，直到数据全部读取完毕。

1）先从数据中抓取固定数组长度的字节，存入定义的数组中，再通过然后再通过read()方法读取数组中的元素，存入缓冲区

2）循环这个动作，知道最后取出一组数据存入数组，可能数组并未填满，同样也取出包含的元素

3）每次取出的时候，都有一个指针在移动，取到数组结尾就自动回到数组头部，这样指针在自增

4）取出的时候，数组中的元素再减少，取出一个，就减少一个，直到减到0即数组取完

5）到了文件的结尾处，存入最后一组数据，当取完数组中的元素，就会减少到0，这是全部数据就取完了

3、自定义字节缓冲区：
  2.  * 自定义字节流缓冲区  
  3.  */  
  4. public class MyBufferedInputStream {  
  5.     private InputStream in;  
  6.     private byte[] buf = new byte[1024];  
  7.     private int pos;// 定义数组的指针  
  8.     private int count;// 定义计数器  
  9.   
  10.     MyBufferedInputStream(InputStream in) {  
  11.         this.in = in;  
  12.     }  
  13.   
  14.     // 一次读一个字节，从缓冲区（数组）中取得  
  15.     public int myRead() throws IOException {  
  16.         // 通过in对象读取数据并存放在buf数组中  
  17.         if (count == 0) {  
  18.             count = in.read(buf);  
  19.             if (count < 0) {  
  20.                 return -1;  
  21.             }  
  22.             pos = 0;  
  23.             byte b = buf[pos];  
  24.   
  25.             count--;  
  26.             pos++;  
  27.   
  28.             return b & 255;// &255是因为存放的是二进制，也就是可能前八位是11111111，提升为int还是-1，就直接return了，  
  29.             // &255就是让前面补0  
  30.             /*  
  31.              *  11111111 11111111 11111111 11111111   
  32.              * &00000000 00000000 00000000 11111111   
  33.              * ------------------------------------   
  34.              *  00000000 00000000  00000000 11111111  
  35.              */  
  36.         }else if(count>0){  
  37.             byte b = buf[pos];  
  38.               
  39.             count--;  
  40.             pos++;  
  41.             return b&255;//&0xff  
  42.         }  
  43.         return -1;  
  44.     }  
  45.       
  46.     public void myClose() throws IOException{  
  47.         in.close();  
  48.     }  
  49. }
注：取出的是byte型，返回的是int型，这里存在提升的动作，
当byte中的八位全为1的时候是byte的-1，提升为int类型，就变为int型的-1，为-1时程序就停止循环了，read循环条件就结束了，变为-1的原因是由于在提升时，将byte的八位前都补的是1，即32位的数都是1，即为int型的-1了。如何保证提升后的最后八位仍为1呢？就需要将前24位补0，就可以保留原字节数据不变，又可以避免转为int型出现-1的情况；
那么要如何做呢？
这就需要将提升为int的数据和前24位为0，后八位仍为原字节数据的这个值做与运算。即和255做与运算即可。说到了这里应该也明白了为什么Read方法返回值为int类型了。

第六  转换流

转换流：转换流可以实现字节数据和字符数据的相互转换方便与操作，而且在转换的时候可以指定编码，这也是该流最具特色的地方。：

InputStreamReader 是字节流通向字符流的桥梁

OutputStreamWriter 是字符流通向字节流的桥梁


转换流的子类和转换流的区别？
InputStreamReader   字节-->字符 
 |--FileReader : 字节流+本地默认码表。
OutputStreamWriter  字符-->字节
 |--FileWriter 

什么时候使用转换流呢？
 1，源或者目的对应的设备是字节流，但是操作的却是文本数据，可以使用转换作为桥梁。
  提高对文本操作的便捷。
 2，一旦操作文本涉及到具体的指定编码表时，必须使用转换流 。
 BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("a.txt"),charsetName));

  1.       //获取键盘录入对象  
  2.          InputStream in = System.in;  
  3.           
  4.          //将字节流对象转换成字符流对象  
  5.          InputStreamReader isr = new InputStreamReader(in);  
  6.           
  7.          //将字符流对象用缓冲技术高效处理  
  8.          BufferedReader bufr = new BufferedReader(isr);
  10.          // 键盘录入最常见的写法  
  11.          BufferedReader bufr = new BufferedReader(new  InputStreamReader(System.in));  


字符流转字节流：

    1.         // 操作输出  
    2.         // 获取输出流  
    3.          OutputStream out = System.out;  
    4.          //将字符流转换成字节流，OutputStreamWriter字符流通向字节流的桥梁  
    5.          OutputStreamWriter osw = new OutputStreamWriter(out);  
    6.          BufferedWriter bfw = new BufferedWriter(osw);//高效缓冲区

获取键盘输入：键盘输入都是字节，所以用到字节流与标准输入流相关联就可以把输入的数据获取到流中，以达到数据的操作效果。
  2.  * 获取键盘录入  
  4. public class ReadIn {  
  5.     public static void main(String[] args) {  
  6.         // method_1();  
  7.         // method_2();  
  8.         InputStreamReaderDemo();  
  9.     }  
  10.   
  11.     /*  
  12.      * 获取键盘录入  
  13.      */  
  14.     public static void method_1() {  
  15.         InputStream in = System.in;// 定义输入流与键盘输入流相关联  
  16.         int ch = 0;  
  17.         try {  
  18.             while ((ch = in.read()) != -1) {  
  19.                 System.out.println(ch);  
  20.             }  
  21.         } catch (IOException e) {  
  22.             e.printStackTrace();  
  23.         }  
  24.     }  
  25.   
  26.     /*  
  27.      * 需求：通过键盘录入数据。 当录入一行数据后，就将该行数据进行打印。 如果录入的数据是over，那么停止录入。  
  28.      * 1，因为键盘录入只读取一个字节，要判断是否是over，需要将读取到的字节拼成字符串。
  29.      * 2，那就需要一个容器。StringBuilder.
  30.      * 3，在用户回车之前将录入的数据变成字符串判断即可。 
  31.      */  
  32.     public static void method_2() {  
  33.         InputStream in = System.in;  
  34.         StringBuilder sb = new StringBuilder();// 定义一个临时容器  
  35.   
  36.         while (true) {  
  37.             int ch = 0;  
  38.             try {  
  39.                 ch = in.read();  
  40.                 if (ch == '\r')// windows中换行符为\r\n  
  41.                     continue;  
  42.                 if (ch == '\n') {  
  43.                     String s = sb.toString();// 当读到一行的结束标记时，把改行数据变成字符串  
  44.                     if ("over".equals(s))  
  45.                         break;  
  46.                     System.out.println(s.toUpperCase());  //变成大写
  47.                     sb.delete(0, sb.length());// 清空容器  ，不清空会将上次输入的和这次输入的都输出
  48.                 } else {  
  49.                     sb.append((char) ch);    //将读取到的字节存储到StringBuilder中。
  50.                 }  
  51.             } catch (IOException e) {  
  52.                 e.printStackTrace();  
  53.             }  
  54.         }  
  55.     }  
  56.   
  57.     // **************************************************************************  
  58.   
  59.     /*  
  60.      * 通过上面录入一行数据，发现其方法类似于readLine方法 但是readLine方法是字符流缓冲区的方法，所以需要把字节流转换成字符流进行操作  
  61.      * 需要用到InputStreamReader方法进行转换,InputStreamReader字节通向字符的桥梁  
  62.      *   
  63.      * 转换流  
  64.      */  
  65.     public static void InputStreamReaderDemo() {   
  66.   
  67.         BufferedReader bufr = null;  
  68.         try {  
  69.             // 源为文件  
  70.             bufr = new BufferedReader(new InputStreamReader(  
  71.                     new FileInputStream("buf.txt")));  
  72.         } catch (FileNotFoundException e2) {  
  73.             e2.printStackTrace();  
  74.         }  
  75.   
  76.         // 操作输出  
  77.         // 目的地是控制台  
  78.         BufferedWriter bfw = new BufferedWriter(new OutputStreamWriter(  
  79.                 System.out));  
  80.   
  81.         // 目的地是文件  
  82.         // BufferedWriter bfw = null;  
  83.         // try {  
  84.         // bfw = new BufferedWriter(new OutputStreamWriter(new  
  85.         // FileOutputStream("out.txt")));  
  86.         // } catch (FileNotFoundException e1) {  
  87.         // e1.printStackTrace();  
  88.         // }  
  89.   
  90.         String line = null;  
  91.   
  92.         try {  
  93.             while ((line = bufr.readLine()) != null) {  
  94.                 if ("over".equals(line)) {  
  95.                     break;  
  96.                 }  
  97.                 bfw.write(line.toUpperCase());  
  98.                 bfw.newLine();// 换行  
  99.                 bfw.flush();// 数据存放在缓冲区，所以需要刷新  
  100.             }  
  101.         } catch (IOException e) {  
  102.             e.printStackTrace();  
  103.         } finally {  
  104.             try {  
  105.                 bufr.close();  
  106.             } catch (IOException e) {  
  107.                 e.printStackTrace();  
  108.             }  
  109.         }  
  110.     }  
  111. }
  112. 不处理异常
  113. public class TransStreamDemo2 {
  115.    public static void main(String[] args) throws IOException {
  116.  
  117.   /*
  118.    * 1,需求：将键盘录入的数据写入到一个文件中。
  119.    *
  120.    * 2,需求：将一个文本文件内容显示在控制台上。
  121.    *
  122.    * 3,需求：将一个文件文件中的内容复制到的另一个文件中。
  123.    */
  124.  
  125.     BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
  126.  
  127.     BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new       FileOutputStream("b.txt")));
  128.  
  129.      String line = null; 
  130.  
  131.      while((line=bufr.readLine())!=null){
  132.      if("over".equals(line))
  133.      break;
  134.      
  135.      bufw.write(line.toUpperCase()); //变成大写
  136.      bufw.newLine();
  137.      bufw.flush();
  138.     }
  139.   } 
  140. }

第七  流的操作规律

之所以要弄清楚这个规律，是因为流对象太多，开发时不知道用哪个对象合适。
想要知道开发时用到哪些对象。只要通过四个明确即可。
1，明确源和目的(汇)
 源：InputStream  Reader
 目的：OutputStream  Writer
2，明确数据是否是纯文本数据。
 源：是纯文本：Reader
  否：InputStream
 目的：是纯文本 Writer
  否：OutputStream
 
 到这里，就可以明确需求中具体要使用哪个体系。
 
3，明确具体的设备。
 源设备：
  硬盘：File
  键盘：System.in
  内存：数组
  网络：Socket流
 
 目的设备：
  硬盘：File
  控制台：System.out
  内存：数组
  网络：Socket流
4，是否需要其他额外功能。
 1，是否需要高效(缓冲区);
  是，就加上buffer.
 2，转换。
 
需求1：复制一个文本文件。
 1,明确源和目的。
  源：InputStream Reader
  目的：OutputStream  Writer
 2,是否是纯文本？
  是！
  源：Reader
  目的：Writer
 
 3,明确具体设备。
  源：
   硬盘：File
  目的：
   硬盘：File
 
  FileReader fr = new FileReader("a.txt");
  FileWriter fw = new FileWriter("b.txt");
 
 4,需要额外功能吗？
  需要，需要高效。
  BufferedReader bufr = new BufferedReader(new FileReader("a.txt"));
  BufferedWriter bufw = new BufferedWriter(new FileWriter("b.txt"));
 
================================================
需求2：读取键盘录入信息，并写入到一个文件中。
 
 1,明确源和目的。
  源：InputStream Reader
  目的：OutputStream  Writer
 2，是否是纯文本呢？
  是，
  源：Reader
  目的：Writer
 3，明确设备
  源：
   键盘。System.in
  目的：
   硬盘。File
   
  InputStream in = System.in;
  FileWriter fw = new FileWriter("b.txt");
  这样做可以完成，但是麻烦。将读取的字节数据转成字符串。再由字符流操作。
 4，需要额外功能吗？
  需要。转换。 将字节流转成字符流。因为名确的源是Reader，这样操作文本数据做便捷。
   所以要将已有的字节流转成字符流。使用字节-->字符 。InputStreamReader
  InputStreamReader isr = new InputStreamReader(System.in);
  FileWriter fw = new FileWriter("b.txt");
 
  还需要功能吗？
  需要：想高效。
  BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
  BufferedWriter bufw = new BufferedWriter(new FileWriter("b.txt"));
 
   
 
===================================================
 
需求3：将一个文本文件数据显示在控制台上。
 1,明确源和目的。
  源：InputStream Reader
  目的：OutputStream  Writer
 2，是否是纯文本呢？
  是，
  源：Reader
  目的：Writer
 3，明确具体设备
  源：
   硬盘：File
  目的：
   控制台：System.out
   
  FileReader fr = new FileReader("a.txt");
  OutputStream out = System.out;//PrintStream
 4，需要额外功能吗？
  需要，转换。
  FileReader fr= new FileReader("a.txt");
  OutputStreamWriter osw = new OutputStreamWriter(System.out);
  需要，高效。
  BufferedReader bufr = new BufferedReader(new FileReader("a.txt"));
  BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));
 
================================================================
需求4：读取键盘录入数据，显示在控制台上。
 1,明确源和目的。
  源：InputStream Reader
  目的：OutputStream  Writer
 2，是否是纯文本呢？
  是，
  源：Reader
  目的：Writer
 3，明确设备。
  源：
   键盘：System.in
  目的：
   控制台：System.out
 
  InputStream in = System.in;
  OutputStream out = System.out;
 
 4，明确额外功能？
  需要转换，因为都是字节流，但是操作的却是文本数据。
  所以使用字符流操作起来更为便捷。
  InputStreamReader isr = new InputStreamReader(System.in);
  OutputStreamWriter osw = new OutputStreamWriter(System.out);
 
  为了将其高效。
  BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
  BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));
 
 
============================================================
5，将一个中文字符串数据按照指定的编码表写入到一个文本文件中.
 
 1，目的。OutputStream，Writer
 2，是纯文本，Writer。
 3，设备：硬盘File
 FileWriter fw = new FileWriter("a.txt");
 fw.write("你好");
 
 注意：既然需求中已经明确了指定编码表的动作。
 那就不可以使用FileWriter，因为FileWriter内部是使用默认的本地码表。
 只能使用其父类。OutputStreamWriter.
 OutputStreamWriter接收一个字节输出流对象，既然是操作文件，那么该对象应该是FileOutputStream
 
 OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("a.txt"),charsetName（编码）);
 
 需要高效吗？
 BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("a.txt"),charsetName));

  演示：将一个中文字符串数据按照指定的编码表写入到一个文本文件中. 
写：
  1. 	public static void writeText_2() throws IOException {
  3. 		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
  4. 				"gbk_3.txt"), "GBK");
  6. 		// OutputStreamWriter osw = new OutputStreamWriter(new
  7. 		// FileOutputStream("gbk_3.txt"),"GBK");
  8. 		// FileWriter fw = new FileWriter("gbk_1.txt");
  10. 		/*
  11. 		 * 这两句代码的功能是等同的。 FileWriter：其实就是转换流指定了本机默认码表的体现。而且这个转换流的子类对象，可以方便操作文本文件。
  12. 		 * 简单说：操作文件的字节流+本机默认的编码表。 这是按照默认码表来操作文件的便捷类。
  13. 		 * 
  14. 		 * 如果操作文本文件需要明确具体的编码。FileWriter就不行了。必须用转换流
  15. 		 */
  16. 		osw.write("你好");
  18. 		osw.close();
  19. 	}
  21. 	public static void writeText_3() throws IOException {
  22. 		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
  23. 				"u8_1.txt"), "UTF-8");
  24. 		osw.write("你好");
  25. 		osw.close();
  26. 	}

读：
  1. public static void readText_1() throws IOException {
  2. 	 
  3. 	  FileReader fr = new FileReader("gbk_1.txt");
  4. 	 
  5. 	  char[] buf = new char[10];
  6. 	  int len = fr.read(buf);
  7. 	  String str = new String(buf,0,len);
  8. 	  System.out.println(str);
  9. 	   fr.close();
  10. 	   } 
  11. 	//用utf-8读默认的编码文件
  12. 	 public static void readText_2() throws IOException, FileNotFoundException {
  13. 	 
  14. 	  InputStreamReader isr = new InputStreamReader(new FileInputStream("gbk_1.txt"),"utf-8"); 
  15. 	  char[] buf = new char[10];
  16. 	  int len = isr.read(buf);
  17. 	  String str = new String(buf,0,len);
  18. 	  System.out.println(str);
  19. 	  isr.close();
  20. 	 }
  21. 	  }
  22. 	}


 




posted @ 2015-10-26 20:44  梦和远方  阅读(614)  评论(0)    收藏  举报