IO流与NIO流

扫码查看

JAVA IO流最详解

 

 

一、IO流概述

二、字符流

2.字符流读写:

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

  1. class FireWriterDemo {
  2. public static void main(String[] args) throws IOException {             //需要对IO异常进行处理
  3. //创建一个FileWriter对象,该对象一被初始化就必须要明确被操作的文件。
  4. //而且该文件会被创建到指定目录下。如果该目录有同名文件,那么该文件将被覆盖。
  5. FileWriter fw = new FileWriter("F:\\1.txt");//目的是明确数据要存放的目的地。
  6. //调用write的方法将字符串写到流中
  7. fw.write("hello world!");
  8. //刷新流对象缓冲中的数据,将数据刷到目的地中
  9. fw.flush();
  10. //关闭流资源,但是关闭之前会刷新一次内部缓冲中的数据。当我们结束输入时候,必须close();
  11. fw.write("first_test");
  12. fw.close();
  13. //flush和close的区别:flush刷新后可以继续输入,close刷新后不能继续输入。
  14. }
  15. }
  1. class FileReaderDemo {
  2. public static void main(String[] args) {
  3. characters();
  4. }
  5. /*****************字符数组进行读取*********************/
  6. private static void characters() {
  7. try {
  8. FileReader fr = new FileReader("Demo.txt");
  9. char []  buf = new char[6];
  10. //将Denmo中的文件读取到buf数组中。
  11. int num = 0;
  12. while((num = fr.read(buf))!=-1) {
  13. //String(char[] value , int offest,int count) 分配一个新的String,包含从offest开始的count个字符
  14. sop(new String(buf,0,num));
  15. }
  16. sop('\n');
  17. fr.close();
  18. }
  19. catch (IOException e) {
  20. sop(e.toString());
  21. }
  22. }
  23. /*****************单个字母读取*************************/
  24. private static void singleReader() {
  25. try {
  26. //创建一个文件读取流对象,和指定名称的文件关联。
  27. //要保证文件已经存在,否则会发生异常:FileNotFoundException
  28. FileReader fr = new FileReader("Demo.txt");
  29. //如何调用读取流对象的read方法?
  30. //read()方法,一次读取一个字符,并且自动往下读。如果到达末尾则返回-1
  31. int ch = 0;
  32. while ((ch=fr.read())!=-1) {
  33. sop((char)ch);
  34. }
  35. sop('\n');
  36. fr.close();
  37. /*int ch = fr.read();
  38. sop("ch=" + (char)ch);
  39. int ch2 = fr.read();
  40. sop("ch2=" + (char)ch2);
  41. //使用结束注意关闭流
  42. fr.close(); */
  43. }
  44. catch (IOException e) {
  45. sop(e.toString());
  46. }
  47. }
  48. /**********************Println************************/
  49. private static void sop(Object obj) {
  50. System.out.print(obj);
  51. }
  52. }
  1. import java.io.*;
  2. class  FileWriterDemo3 {
  3. public static void main(String[] args) {
  4. try {
  5. //传递一个参数,代表不覆盖已有的数据。并在已有数据的末尾进行数据续写
  6. FileWriter fw = new FileWriter("F:\\java_Demo\\day9_24\\demo.txt",true);
  7. fw.write(" is charactor table?");
  8. fw.close();
  9. }
  10. catch (IOException e) {
  11. sop(e.toString());
  12. }
  13. }
  14. /**********************Println************************/
  15. private static void sop(Object obj)
  16. {
  17. System.out.println(obj);
  18. }
  19. }

步骤:

源码:

  1. import java.io.*;
  2. import java.util.Scanner;
  3. class CopyText {
  4. public static void main(String[] args) throws IOException {
  5. sop("请输入要拷贝的文件的路径:");
  6. Scanner in = new Scanner(System.in);
  7. String source = in.next();
  8. sop("请输入需要拷贝到那个位置的路径以及生成的文件名:");
  9. String destination = in.next();
  10. in.close();
  11. CopyTextDemo(source,destination);
  12. }
  13. /*****************文件Copy*********************/
  14. private static void CopyTextDemo(String source,String destination) {
  15. try {
  16. FileWriter fw = new FileWriter(destination);
  17. FileReader fr = new FileReader(source);
  18. char []  buf = new char[1024];
  19. //将Denmo中的文件读取到buf数组中。
  20. int num = 0;
  21. while((num = fr.read(buf))!=-1) {
  22. //String(char[] value , int offest,int count) 分配一个新的String,包含从offest开始的count个字符
  23. fw.write(new String(buf,0,num));
  24. }
  25. fr.close();
  26. fw.close();
  27. }
  28. catch (IOException e) {
  29. sop(e.toString());
  30. }
  31. }
  32. /**********************Println************************/
  33. private static void sop(Object obj) {
  34. System.out.println(obj);
  35. }
  36. }

三、缓冲区

BufferedReader示例:

  1. import java.io.*;
  2. class BufferedReaderDemo {
  3. public static void main(String[] args)  throws IOException {
  4. //创建一个字符读取流流对象,和文件关联
  5. FileReader rw = new FileReader("buf.txt");
  6. //只要将需要被提高效率的流作为参数传递给缓冲区的构造函数即可
  7. BufferedReader brw = new BufferedReader(rw);
  8. for(;;) {
  9. String s = brw.readLine();
  10. if(s==null) break;
  11. System.out.println(s);
  12. }
  13. brw.close();//关闭输入流对象
  14. }
  15. }
  1. import java.io.*;
  2. class BufferedWriterDemo {
  3. public static void main(String[] args)  throws IOException {
  4. //创建一个字符写入流对象
  5. FileWriter fw = new FileWriter("buf.txt");
  6. //为了提高字符写入效率,加入了缓冲技术。
  7. //只要将需要被提高效率的流作为参数传递给缓冲区的构造函数即可
  8. BufferedWriter bfw = new BufferedWriter(fw);
  9. //bfw.write("abc\r\nde");
  10. //bfw.newLine();               这行代码等价于bfw.write("\r\n"),相当于一个跨平台的换行符
  11. //用到缓冲区就必须要刷新
  12. for(int x = 1; x < 5; x++) {
  13. bfw.write("abc");
  14. bfw.newLine();                  //java提供了一个跨平台的换行符newLine();
  15. bfw.flush();
  16. }
  17. bfw.flush();                                                //刷新缓冲区
  18. bfw.close();                                                //关闭缓冲区,但是必须要先刷新
  19. //注意,关闭缓冲区就是在关闭缓冲中的流对象
  20. fw.close();                                                 //关闭输入流对象
  21. }
  22. }
  1. class MyBufferedReader1  extends Reader{
  2. private Reader r;
  3. MyBufferedReader1(Reader r){
  4. this.r  = r;
  5. }
  6. //一次读一行数据的方法
  7. public String myReaderline()  throws IOException {
  8. //定义一个临时容器,原BufferReader封装的是字符数组。
  9. //为了演示方便。定义一个StringBuilder容器。最终要将数据变成字符串
  10. StringBuilder sb = new StringBuilder();
  11. int ch = 0;
  12. while((ch = r.read()) != -1)
  13. {
  14. if(ch == '\r')
  15. continue;
  16. if(ch == '\n')                    //遇到换行符\n,返回字符串
  17. return sb.toString();
  18. else
  19. sb.append((char)ch);
  20. }
  21. if(sb.length()!=0)                    //当最后一行不是以\n结束时候,这里需要判断
  22. return sb.toString();
  23. return null;
  24. }
  25. /*
  26. 需要覆盖Reader中的抽象方法close(),read();
  27. */
  28. public void close()throws IOException {
  29. r.close();
  30. }
  31. public int read(char[] cbuf,int off, int len)throws IOException {   //覆盖read方法
  32. return r.read(cbuf,off,len);
  33. }
  34. public void myClose() throws IOException{
  35. r.close();
  36. }
  37. }
 

一、字节流

练习:

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

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

注意事项:

练习:

代码:

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

二、流操作规律

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

3. 转换流

2.OutputStreamWriter:字符流通向字节流

示例:

  1. /*================把键盘录入的数据存到一个文件中==============*/
  2. public static void inToFile() {
  3. //键盘的最常见的写法
  4. BufferedReader bufr = null;
  5. BufferedWriter bufw = null;
  6. try {
  7. /*InputStream ips = System.in;        //从键盘读入输入字节流
  8. InputStreamReader fr = new InputStreamReader(ips);             //将字节流转成字符流
  9. bufr = new BufferedReader(fr);  */                 //将字符流加强,提升效率
  10. bufr = new BufferedReader(new InputStreamReader(System.in));            //匿名类。InputSteamReader:读取字节并将其解码为字符
  11. bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("out.txt")));     //OutputStreamWriter:要写入流中的字符编码成字节
  12. String line = null;
  13. while((line = bufr.readLine())!=null){
  14. if("over".equals(line)) break;
  15. bufw.write(line.toUpperCase());                     //打印
  16. bufw.newLine();                                     //为了兼容,使用newLine()写入换行符
  17. bufw.flush();                                       //必须要刷新。不然不会显示
  18. }
  19. if(bufw!=null) {
  20. bufr.close();
  21. bufw.close();
  22. }
  23. }
  24. catch (IOException e) {
  25. e.printStackTrace();
  26. }
  27. }
  1. /*
  2. 流操作的基本规律。
  3. 一、两个明确:(明确体系)
  4. 1. 明确源和目的
  5. 源:输入流  InputStream  Reader
  6. 目的:输出流  OutputStream Writer
  7. 2. 操作的数据是否是纯文本
  8. 是: 字符流
  9. 否: 字节流
  10. 二、明确体系后要明确具体使用的对象
  11. 通过设备区分:内存,硬盘,键盘
  12. 目的设备:内存,硬盘,控制台
  13. 示例1:将一个文本文件中的数据存储到另一个文件中: 复制文件
  14. 一、明确体系
  15. 源:文件-->读取流-->(InputStream和Reader)
  16. 是否是文本:是-->Reader
  17. 目的:文件-->写入流-->(OutputStream Writer)
  18. 是否纯文本:是-->Writer
  19. 二、 明确设备
  20. 源:Reader
  21. 设备:硬盘上一个文本文件 --> 子类对象为:FileReader
  22. FileReader fr = new FileReader("Goods.txt");
  23. 是否提高效率:是-->加入Reader中的缓冲区:BufferedReader
  24. BufferedReader bufr = new BufferedReader(fr);
  25. 目的:Writer
  26. 设备:键盘上一个文本文件 --> 子类对象:FileWriter
  27. FileWriter fw = new FileWriter("goods1.txt");
  28. 是否提高效率:是-->加入Writer的缓冲区:BufferedWriter
  29. BufferedWriter bufw = new BufferedWriter(fw);
  30. 示例2:将一个图片文件数据复制到另一个文件中:复制文件
  31. 一、明确体系
  32. 源:文件-->读取流-->(InputStream和Reader)
  33. 是否是文本:否-->InputStream
  34. 目的:文件-->写入流-->(OutputStream Writer)
  35. 是否纯文本:否-->OutputStream
  36. 二、 明确设备
  37. 源:InputStream
  38. 设备:硬盘上一个媒体文件 --> 子类对象为:FileInputStream
  39. FileInputStream fis = new FileInputStream("Goods.txt");
  40. 是否提高效率:是-->加入InputStream中的缓冲区:BufferedInputStream
  41. BufferedInputStream bufi = new BufferedInputStream(fis);
  42. 目的:OutputStream
  43. 设备:键盘上一个媒体文件 --> 子类对象:FileOutputStream
  44. FileOutputStream fos = new FileOutputStream("goods1.txt");
  45. 是否提高效率:是-->加入OutputStream的缓冲区:BufferedOutputStream
  46. BufferedOutputStream bufo = new BufferedOutputStream(fw);
  47. 示例3:将键盘录入的数据保存到一个文本文件中
  48. 一、明确体系
  49. 源:键盘-->读取流-->(InputStream和Reader)
  50. 是否是文本:是-->Reader
  51. 目的:文件-->写入流-->(OutputStream Writer)
  52. 是否纯文本:是-->Writer
  53. 二、 明确设备
  54. 源:InputStream
  55. 设备:键盘 --> 对用对象为:System.in --> InputStream
  56. 为了操作方便,转成字符流Reader --> 使用Reader中的转换流:InputStreamReader
  57. InputStreamReader isr = new InputStreamReader(System.in);
  58. 是否提高效率:是-->加入Reader中的缓冲区:BufferedReader
  59. BufferedReader bufr = new BufferedReader(isr);
  60. 目的:Writer
  61. 设备:键盘上一个文本文件 --> 子类对象:FileWriter
  62. FileWriter fw = new FileWriter("goods1.txt");
  63. 是否提高效率:是-->加入Writer的缓冲区:BufferedWriter
  64. BufferedWriter bufw = new BufferedWriter(fw);
  1. import java.io.*;
  2. public class IOStreamLaw {
  3. /**
  4. * @param args
  5. */
  6. public static void main(String[] args) throws IOException {
  7. //键盘的最常见写法
  8. BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
  9. BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("goods1.txt"),"UTF-8"));
  10. String line = null;
  11. while((line=bufr.readLine())!=null){
  12. if("over".equals(line)) break;
  13. bufw.write(line.toUpperCase());
  14. bufw.newLine();
  15. bufw.flush();
  16. }
  17. bufr.close();
  18. }
  19. }
 

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

未完待续!

05-18 06:59
查看更多