码迷，mamicode.com
首页 > 其他好文 > 详细

IO流与NIO流

时间：2018-07-02 20:25:09      阅读：193      评论：0      收藏：0      [点我收藏+]

标签：system   pypi   继承   iostream   res   数组   整型   类型   就会   

 
 
（转自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(‘\n‘);  
  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(‘\n‘);  
  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\r\nde");  
  15.         //bfw.newLine();               这行代码等价于bfw.write("\r\n"),相当于一个跨平台的换行符  
  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 == ‘\r‘)   
  16.                 continue;  
  17.             if(ch == ‘\n‘)                    //遇到换行符\n,返回字符串  
  18.                 return sb.toString();  
  19.             else  
  20.             sb.append((char)ch);  
  21.         }  
  22.         if(sb.length()!=0)                    //当最后一行不是以\n结束时候，这里需要判断  
  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_Demo\day9_28\1.BMP到F:\java_Demo\day9_28\2.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()+"\t");
  23.  
    //System.out.print(intBuffer+"\t"); //
  24.  
    }
  25.  
     
  26.  
    System.out.println("\n缓冲区的数据对数组是可见的,修改视图,数组中的数据也会变;传引用");
  27.  
    //打印原始数组
  28.  
    Arrays.stream(intArray).forEach(temp-> System.out.print(temp+"\t"));
  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()+"\t");
  45.  
    }
  46.  
     
  47.  
    System.out.println("\n复制的缓冲区对原来的缓冲区也是可见的;传引用");
  48.  
    //打印原始数组
  49.  
    for(int i=0;i<intBuffer2.limit();i++) {
  50.  
    System.out.print(intBuffer2.get()+"\t");
  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

      未完待续！



IO流与NIO流

标签：system   pypi   继承   iostream   res   数组   整型   类型   就会   

原文地址：https://www.cnblogs.com/wsnb8/p/9255339.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！