zoukankan      html  css  js  c++  java

  • IO流与NIO流

    JAVA IO流最详解

     
     
    （转自CSDN）

    IO流上：概述、字符流、缓冲区(java基础)

     

    一、IO流概述

    概述：

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

    分类：

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

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

    IO流常用的基类：

             * InputStream    ，    OutputStream

    字符流的抽象基类：

             * Reader       ，         Writer

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

                如：FileReader和FileInputStream

    二、字符流

    1. 字符流简介：

    * 字符流中的对象融合了编码表，也就是系统默认的编码表。我们的系统一般都是GBK编码。

    * 字符流只用来处理文本数据，字节流用来处理媒体数据。

    * 数据最常见的表现方式是文件，字符流用于操作文件的子类一般是FileReader和FileWriter。

    2.字符流读写：

    注意事项：

    * 写入文件后必须要用flush()刷新。

    * 用完流后记得要关闭流

    * 使用流对象要抛出IO异常

    * 定义文件路径时，可以用“/”或者“\”。

    * 在创建一个文件时，如果目录下有同名文件将被覆盖。

    * 在读取文件时，必须保证该文件已存在，否则出异常

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

    [java] view plain copy
     
    1. class FireWriterDemo {  
    2.     public static void main(String[] args) throws IOException {             //需要对IO异常进行处理   
    3.   
    4.         //创建一个FileWriter对象，该对象一被初始化就必须要明确被操作的文件。  
    5.         //而且该文件会被创建到指定目录下。如果该目录有同名文件，那么该文件将被覆盖。  
    6.   
    7.         FileWriter fw = new FileWriter("F:\1.txt");//目的是明确数据要存放的目的地。  
    8.   
    9.         //调用write的方法将字符串写到流中  
    10.         fw.write("hello world!");  
    11.       
    12.         //刷新流对象缓冲中的数据，将数据刷到目的地中  
    13.         fw.flush();  
    14.   
    15.         //关闭流资源，但是关闭之前会刷新一次内部缓冲中的数据。当我们结束输入时候，必须close();  
    16.         fw.write("first_test");  
    17.         fw.close();  
    18.         //flush和close的区别：flush刷新后可以继续输入，close刷新后不能继续输入。  
    19.   
    20.     }  
    21. }  

    示例2：FileReader的reade()方法.

    要求：用单个字符和字符数组进行分别读取

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

    示例3：对已有文件的数据进行续写

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



    练习：

    将F盘的一个文件复制到E盘。 

    思考：

    其实就是将F盘下的文件数据存储到D盘的一个文件中。

    步骤：

    1.在D盘创建一个文件，存储F盘中文件的数据。
    2.定义读取流和F：盘文件关联。
    3.通过不断读写完成数据存储。
    4.关闭资源。

    源码：

    [java] view plain copy
     
    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.   
    37.   
    38.   
    39. /**********************Println************************/  
    40.     private static void sop(Object obj) {  
    41.         System.out.println(obj);  
    42.     }  
    43. }  

    三、缓冲区

    1. 字符流的缓冲区：BufferedReader和BufferedWreiter

    * 缓冲区的出现时为了提高流的操作效率而出现的.

    * 需要被提高效率的流作为参数传递给缓冲区的构造函数

    * 在缓冲区中封装了一个数组，存入数据后一次取出

    BufferedReader示例：

    读取流缓冲区提供了一个一次读一行的方法readline，方便对文本数据的获取。
    readline()只返回回车符前面的字符，不返回回车符。如果是复制的话，必须加入newLine()，写入回车符

    newLine()是java提供的多平台换行符写入方法。

    [java] view plain copy
     
    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示例：

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

    2.装饰设计模式

    装饰设计模式：：：：

    要求：自定义一些Reader类，读取不同的数据(装饰和继承的区别)
    MyReader //专门用于读取数据的类
        |--MyTextReader
            |--MyBufferTextReader
        |--MyMediaReader
            |--MyBufferMediaReader
        |--MyDataReader
            |--MyBufferDataReader

    如果将他们抽取出来，设计一个MyBufferReader，可以根据传入的类型进行增强
    class MyBufferReader {

        MyBufferReader (MyTextReader text) {}
        MyBufferReader (MyMediaReader media) {}
        MyBufferReader (MyDataReader data) {}
    }

    但是上面的类拓展性很差。找到其参数的共同类型，通过多态的形式，可以提高拓展性

    class MyBufferReader  extends MyReader{
        private MyReader r;                        //从继承变为了组成模式  装饰设计模式
        MyBufferReader(MyReader r) {}
    }

    优化后的体系：
        |--MyTextReader
        |--MyMediaReader
        |--MyDataReader
        |--MyBufferReader        //增强上面三个。装饰模式比继承灵活，
                                  避免继承体系的臃肿。降低类与类之间的耦合性

    装饰类只能增强已有的对象，具备的功能是相同的。所以装饰类和被装饰类属于同一个体系

    MyBuffereReader类：  自己写一个MyBuffereReader类，功能与BuffereReader相同

    [java] view plain copy
     
    1. class MyBufferedReader1  extends Reader{               
    2.     private Reader r;  
    3.     MyBufferedReader1(Reader r){  
    4.         this.r  = r;  
    5.     }  
    6.   
    7.     //一次读一行数据的方法  
    8.     public String myReaderline()  throws IOException {  
    9.         //定义一个临时容器，原BufferReader封装的是字符数组。  
    10.         //为了演示方便。定义一个StringBuilder容器。最终要将数据变成字符串  
    11.         StringBuilder sb = new StringBuilder();  
    12.         int ch = 0;  
    13.         while((ch = r.read()) != -1)  
    14.         {  
    15.             if(ch == ' ')   
    16.                 continue;  
    17.             if(ch == ' ')                    //遇到换行符 ,返回字符串  
    18.                 return sb.toString();  
    19.             else  
    20.             sb.append((char)ch);  
    21.         }  
    22.         if(sb.length()!=0)                    //当最后一行不是以 结束时候，这里需要判断  
    23.             return sb.toString();  
    24.         return null;  
    25.     }  
    26.     /* 
    27.     需要覆盖Reader中的抽象方法close()，read(); 
    28.     */  
    29.     public void close()throws IOException {  
    30.         r.close();  
    31.     }  
    32.   
    33.     public int read(char[] cbuf,int off, int len)throws IOException {   //覆盖read方法  
    34.         return r.read(cbuf,off,len);  
    35.     }  
    36.   
    37.     public void myClose() throws IOException{  
    38.         r.close();  
    39.     }  
    40.   
    41.   
    42. }  
     

     

    一、字节流

    1.概述：

    1、字节流和字符流的基本操作是相同的，但是要想操作媒体流就需要用到字节流。

    2、字节流因为操作的是字节，所以可以用来操作媒体文件。（媒体文件也是以字节存储的）

    3、读写字节流：InputStream   输入流（读）和OutputStream  输出流（写）

    4、字节流操作可以不用刷新流操作。

    5、InputStream特有方法：

            int available();//返回文件中的字节个数

    注：可以利用此方法来指定读取方式中传入数组的长度，从而省去循环判断。但是如果文件较大，而虚拟机启动分配的默认内存一般为64M。当文件过大时，此数组长度所占内存空间就会溢出。所以，此方法慎用，当文件不大时，可以使用。

    练习：

    需求：复制一张图片F:java_Demoday9_281.BMP到F:java_Demoday9_282.bmp

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

    2. 字节流缓冲区

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

    注意事项：

    1. read()：会将字节byte()提升为int型值

    2. write()：会将int类型转换为byte()类型，保留最后的8位。

    练习：

    1.复制MP3文件   1.MP3 -->  2.MP3

    2.自己写一个MyBufferedInputStream缓冲类，提升复制速度

    代码：

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

    二、流操作规律

    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.               
    8.             /*InputStream ips = System.in;        //从键盘读入输入字节流 
    9.             InputStreamReader fr = new InputStreamReader(ips);             //将字节流转成字符流 
    10.             bufr = new BufferedReader(fr);  */                 //将字符流加强，提升效率  
    11.   
    12.               
    13.             bufr = new BufferedReader(new InputStreamReader(System.in));            //匿名类。InputSteamReader:读取字节并将其解码为字符  
    14.             bufw = new BufferedWriter(new OutputStreamWriter(System.out));      //OutputStreamWriter:要写入流中的字符编码成字节  
    15.             String line = null;  
    16.             while((line = bufr.readLine())!=null){  
    17.                 if("over".equals(line)) break;  
    18.                 bufw.write(line.toUpperCase());                     //打印  
    19.                 bufw.newLine();                                     //为了兼容，使用newLine()写入换行符  
    20.                 bufw.flush();                                       //必须要刷新。不然不会显示  
    21.             }  
    22.             if(bufw!=null) {  
    23.                 bufr.close();  
    24.                 bufw.close();  
    25.             }  
    26.         }  
    27.         catch (IOException e) {  
    28.             e.printStackTrace();  
    29.         }  
    30.               
    31.           
    32.     }  
    33. }  



    2. 整行录入

    1.从键盘录入数据，并存储到文件中。

    2. 我们在键盘录入的是时候，read()方法是一个一个录入的，能不能整行的录入呢？这时候我们想到了BufferedReader中ReadLine()方法。

    3. 转换流

    为了让字节流可以使用字符流中的方法，我们需要转换流。

     1. 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.               
    8.             /*InputStream ips = System.in;        //从键盘读入输入字节流 
    9.             InputStreamReader fr = new InputStreamReader(ips);             //将字节流转成字符流 
    10.             bufr = new BufferedReader(fr);  */                 //将字符流加强，提升效率  
    11.   
    12.               
    13.             bufr = new BufferedReader(new InputStreamReader(System.in));            //匿名类。InputSteamReader:读取字节并将其解码为字符  
    14.             bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("out.txt")));     //OutputStreamWriter:要写入流中的字符编码成字节  
    15.             String line = null;  
    16.             while((line = bufr.readLine())!=null){  
    17.                 if("over".equals(line)) break;  
    18.                 bufw.write(line.toUpperCase());                     //打印  
    19.                 bufw.newLine();                                     //为了兼容，使用newLine()写入换行符  
    20.                 bufw.flush();                                       //必须要刷新。不然不会显示  
    21.             }  
    22.             if(bufw!=null) {  
    23.                 bufr.close();  
    24.                 bufw.close();  
    25.             }  
    26.         }  
    27.         catch (IOException e) {  
    28.             e.printStackTrace();  
    29.         }  
    30.               
    31.   
    32.     }  


    4. 流操作基本规律

    为了控制格式我将其写入了Java代码段中，如下：

    示例1：文本 ~ 文本

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

    5.指定编码表(转换流可以指定编码表)

    要求：用UTF-8编码存储一个文本文件

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

    Java NIO流

         对于JavaNIO还是不是很了解，之前认为NIO的N是non-block IO的意思，非阻塞；但是原来是New IO的意思。这个新表示的是和原来的BIO而言是一种新的IO吧。NIO的主要特性就是缓冲区，通道，和选择器（这个可能不是）。

          Java在JDK1.4版本呢，引入了NIO这个新的api。Sun公司官方说明NIO的特性如下：

    1. 为所有的原始类型提供了（Buffer）缓存支持；

    2. 字符集编码解码解决方案

    3. Channel（通道）：一个新的原始I/O抽象；

    4. 支持锁和内存映射文件的文件访问接口；

    5. 提供多路（non-blocking）非阻塞式的高伸缩网络I/O。

          对于上面的特性，我是不大了解的。不过，不影响，我们继续介绍。

          NIO创建的目的是，实现高速的I/O，而无需编写自定义的本机代码。

          那NIO大概是怎么做到的呢？它将最耗时的I/O操作转回操作系统，因而可以极大的提高速度。而最耗时的I/O操作是填充和提取缓冲区。

          原来的io和现在NIO最重要的区别就是，数据打包和传输的方式。以前是以流，现在是以块的方式处理数据。

          之前用流的方式呢，只能一次一个字节的处理数据。一个输入流产生一个字节的数据，而一个输出流则消耗一个字节的数据。这样的好处是，创建过滤器特别容易，可以创建多个过滤器，每个过滤器处理只处理一部分的数据。坏处就是，比较慢。

          而NIO用块的方式呢，可以一次一个块的处理数据。每一步的操作都在产生或者消耗一个块，好处是相对于流快得多，坏处是，不够优雅和简单。

    缓冲区

          然后开始介绍缓冲区，缓冲区就是上面介绍到的NIO的特性第一条，为所有的原始数据都提供了Buffer缓存的支持。它主要是将所有的原始数据放在数组中，以块的形式处理。

          而每种缓冲区的类都有四个属性：容量（Capacity），上界（Limit），位置（Position），以及标记（Mark），用于提供关于其所包含的数据元素的信息。

          容量：缓冲区能够容纳的数据元素的最大数量，缓冲区创建时确定，永远不能被改变；

          上界：缓冲区第一个不能被读或写的元素，或者说，缓冲区现存元素的计数。

          位置：下一个要被读或写的元素的索引。该值会自动由相应的get(),put()函数更新；

          标记：一个备忘的位置。调用mark()来设定mark=position。调用reset()来设定position = mark；标记在设定前是未定义的undefined。

          缓冲区的分类有，ByteBuffer（字节缓冲区），CharBuffer（字符缓冲区），ShortBuffer（短整型缓冲区），IntBuffer（整型缓冲区），LongBuffer（长整型缓冲区），FloatBuffer（单精度浮点缓冲区），DoubleBuffer（双精度浮点缓冲区），就是没有布尔缓冲区。

          他们都是抽象类，所以不能实例化，然后他们都继承了Buffer类，所以都有存get(），取set()方法，也都可以通过各自的静态方法allocation，创建缓冲区。该方法是通过warpping将现有的数组包装到缓冲区中来为缓冲区的内容分配空间，或者通过创建现有字节缓冲区的视图来创建。

          下面这是一个简单的实例，从上到下，创建一个整型的缓冲区，然后将现有的数组放到该缓冲区中。可以通过put改变数组中的数据，并且由于缓冲区中的数据对数组是可见的，所以改变缓冲区也会改变数据，可以认为是传引用。flip()，由于get()每调用一次，position位置都会改变，本来pos会等于3的，而用flip可以让pos变为0;clear()效果也一样。而duplicate()可以复制一个缓冲区，一模一样，也是传引用，修改哪个都会影响到另一个。

    1.  
      import java.nio.IntBuffer;
    2.  
      import java.util.Arrays;
    3.  
       
    4.  
      /**
    5.  
      * Created by liuyanling on 2017/6/30.
    6.  
      */
    7.  
      public class BufferTest {
    8.  
      public static void main(String[] args) {
    9.  
      //创建缓冲区，并指定大小
    10.  
      IntBuffer intBuffer = IntBuffer.allocate(10);
    11.  
       
    12.  
      //给缓冲区赋值,建立数组
    13.  
      int[] intArray = new int[]{3,5,7};
    14.  
      intBuffer = intBuffer.wrap(intArray);
    15.  
       
    16.  
       
    17.  
      //修改元素
    18.  
      intBuffer.put(0,9);
    19.  
       
    20.  
      //打印缓冲区数据
    21.  
      for(int i=0;i<intBuffer.limit();i++) {
    22.  
      System.out.print(intBuffer.get()+" ");
    23.  
      //System.out.print(intBuffer+" "); //
    24.  
      }
    25.  
       
    26.  
      System.out.println(" 缓冲区的数据对数组是可见的,修改视图,数组中的数据也会变;传引用");
    27.  
      //打印原始数组
    28.  
      Arrays.stream(intArray).forEach(temp-> System.out.print(temp+" "));
    29.  
       
    30.  
       
    31.  
      //intBuffer.flip();//get()会使pos改变,对缓冲区进行反转,将limit=pos;pos=0; (将当前位置给limit,然后变为0)
    32.  
      intBuffer.clear();
    33.  
      System.out.println(intBuffer);
    34.  
       
    35.  
      IntBuffer intBuffer2 = intBuffer.duplicate();
    36.  
      System.out.println(intBuffer2);
    37.  
       
    38.  
      intBuffer2.put(0,11);
    39.  
       
    40.  
      //0 <= mark <= position <= limit <= capacity
    41.  
       
    42.  
      //打印缓冲区数据
    43.  
      for(int i=0;i<intBuffer.limit();i++) {
    44.  
      System.out.print(intBuffer.get()+" ");
    45.  
      }
    46.  
       
    47.  
      System.out.println(" 复制的缓冲区对原来的缓冲区也是可见的;传引用");
    48.  
      //打印原始数组
    49.  
      for(int i=0;i<intBuffer2.limit();i++) {
    50.  
      System.out.print(intBuffer2.get()+" ");
    51.  
      }
    52.  
      }
    53.  
      }

          结果是这样

    9	5	7	
缓冲区的数据对数组是可见的,修改视图,数组中的数据也会变;传引用
9	5	7	java.nio.HeapIntBuffer[pos=0 lim=3 cap=3]
java.nio.HeapIntBuffer[pos=0 lim=3 cap=3]
11	5	7	
复制的缓冲区对原来的缓冲区也是可见的;传引用
11	5	7

          未完待续！
  • 相关阅读:
    Title提示样式修改
    列表查询数据交互简写形式
    cookie 一次性弹窗
    postman 使用 设置
    idea window mac安装
    在线校验格式化工具
    bootstrap下拉列表多选组件
    kaiguan
    5个数组Array方法: indexOf、filter、forEach、map、reduce使用实例
    对js里bind函数的理解
  • 原文地址：https://www.cnblogs.com/wsnb8/p/9255339.html
Copyright © 2011-2022 走看看