IO流

IO流 - 图1

IO流引入

IO流之前我们的数据都是存在内存中的。内存中的数据程序结束就没有了。但是在实际开发中很多时候我们的数据是需要持久化保存的。持久化保存的数据需要保存在硬盘的文件上。那么如何才能将数据保存到文件上？如何才能如何文件上的数据呢？这就需要用到IO流了。

IO流

IO：Input/Output 输入输出

流(Stream)：数据流。连续不断的数据。

操作系统本身就有IO功能。

但是今天我们学习的是使用java提供的IO流API操作文件数据。

JavaIO和系统IO的关系

IO流 - 图2

IO流的分类

根据数据的流向分类

  • 输入流：读数据
  • 输出流：写数据
    IO流 - 图3

根据操作数据的不同分类

  • 字节流：IO读写数据的单位是字节
  • 字符流：IO读写数据的单位是字符

综合以上两种分类就得到了JavaIO中的四大基本抽象流：

JavaIO中的四大基本抽象流：

  • 字节输入流（InputStream）: 按照字节读数据
  • 字节输出流 （OutputStream）：按照字节写数据
  • 字符输入流（Reader）：按照字符读数据
  • 字符输出流（Writer）： 按照字符写数据

OutputStream-字节输出流

  1. public abstract class OutputStream extends Object implements Closeable, Flushable

此抽象类是表示输出字节流的所有类的超类。

常用方法

方法摘要
void close()
关闭此输出流并释放与此流有关的所有系统资源。
void flush()
刷新此输出流并强制写出所有缓冲的输出字节。
void write(byte[] b)
将 b.length
个字节从指定的 byte 数组写入此输出流。
void write(byte[] b, int off, int len)
将指定 byte 数组中从偏移量 off
开始的 len
个字节写入此输出流。
abstract void write(int b)
将指定的字节写入此输出流。

OutputStream是一个抽象类，所以我们需要使用其子类来完成数据的写操作。

FileOutputStream - 文件字节输出流 ⭐⭐⭐

文件输出流是用于将数据写入 File 的输出流。

单字节写数据

  1. package com.powernode.p1;
  3. import java.io.File;
  4. import java.io.FileNotFoundException;
  5. import java.io.FileOutputStream;
  6. import java.io.IOException;
  8. /**
  9.  * FileOutputStream类：
  10.  *
  11.  * 构造方法摘要
  12.  * FileOutputStream(File file)
  13.  *           创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
  14.  * FileOutputStream(File file, boolean append)
  15.  *           创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
  16.  * FileOutputStream(String name)
  17.  *           创建一个向具有指定名称的文件中写入数据的输出文件流。
  18.  * FileOutputStream(String name, boolean append)
  19.  *           创建一个向具有指定 name 的文件中写入数据的输出文件流
  20.  *
  21.  *
  22.  * 方法摘要
  23.  *  void close()
  24.  *           关闭此文件输出流并释放与此流有关的所有系统资源。
  25.  *  void write(byte[] b)
  26.  *           将 b.length 个字节从指定 byte 数组写入此文件输出流中。
  27.  *  void write(byte[] b, int off, int len)
  28.  *           将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
  29.  *  void write(int b)
  30.  *           将指定字节写入此文件输出流。
  31.  *
  32.  *
  33.  */
  34. public class Demo01 {
  35.     public static void main(String[] args) {
  36.         FileOutputStream fos = null;
  37.         try {
  38.             // 1. 创建对象
  39.             // 创建文件流对象的时候，如果文件不存在会创建文件
  40.             // 创建文件流对象的时候，如果文件存在，就要根据参数append来决定：
  41.             // 如果append是true就在原有文件内容末尾追加；false就是覆盖原有文件
  42.             // 如果文件路径中的文件夹不存在就会抛出FileNotFoundException
  43.             fos = new FileOutputStream(new File("D://a.txt"),true);
  45.             // 2. 让对象干活 -- 调用对象的相关方法
  46.             // 单字节写数据
  47.             fos.write(97); // a
  48.             fos.write(57); // 9
  49.             fos.write(55); // 7
  50.         } catch (FileNotFoundException exception) {
  51.             exception.printStackTrace();
  52.         } catch (IOException exception) {
  53.             exception.printStackTrace();
  54.         }finally {
  55.             if(fos != null){
  56.                 try {
  57.                     fos.close();
  58.                 } catch (IOException exception) {
  59.                     exception.printStackTrace();
  60.                 }
  61.                 // 以下的代码非必需,这样做的目的是让对象变成垃圾，方便垃圾回收
  62.                 fos = null;
  63.             }
  65.         }
  66.     }
  67. }

按照字节数组写数据

  1. package com.powernode.p1;
  3. import java.io.FileNotFoundException;
  4. import java.io.FileOutputStream;
  5. import java.io.IOException;
  6. import java.util.Arrays;
  8. /**
  9.  *  演示： 按照字节数组写数据
  10.  *
  11.  *  void write(byte[] b)
  12.  *          将 b.length 个字节从指定 byte 数组写入此文件输出流中。
  13.  *   void write(byte[] b, int off, int len)
  14.  *          将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
  15.  */
  16. public class Demo03 {
  17.     public static void main(String[] args) {
  18.         FileOutputStream fos = null;
  19.         try {
  20.             // 1. 创建对象
  21.             fos = new FileOutputStream("D://b.txt");
  22.             // 2. 干活
  23.             byte[] bs = "ai,ya高考，我好紧张".getBytes();
  24.             System.out.println(Arrays.toString(bs));
  25.             // 将字节数组的数据全部写入文件
  26. //            fos.write(bs);
  27.             // 将字节数组的一部分数据写入文件
  28.             fos.write(bs,5,21); // 高考，我好紧张
  29.         } catch (IOException exception) {
  30.             exception.printStackTrace();
  31.         }finally {
  32.             if(fos != null){
  33.                 try {
  34.                     fos.close();
  35.                 } catch (IOException exception) {
  36.                     exception.printStackTrace();
  37.                 }
  38.                 fos = null;
  39.             }
  40.         }
  41.     }
  42. }

InputStream-字节输入流

  1. public abstract class InputStream extends Object implements Closeable

此抽象类是表示字节输入流的所有类的超类。

常用方法

abstract int read()
从输入流中读取数据的下一个字节。
int read(byte[] b)
从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b
中。
int read(byte[] b, int off, int len)
将输入流中最多 len
个数据字节读入 byte 数组。返回读取到的字节总数的长度
void close()
关闭此输入流并释放与该流关联的所有系统资源。

InputStream是一个抽象类，需要使用其子类完成数据的读取。

FileInputStream-文件字节输入流⭐⭐⭐

  1. public class FileInputStream extends InputStream

FileInputStream 从文件系统中的某个文件中获得输入字节.

单字节读取数据

  1. package com.powernode.p1;
  3. import java.io.File;
  4. import java.io.FileInputStream;
  5. import java.io.FileNotFoundException;
  6. import java.io.IOException;
  8. /**
  9.  * FileInputStream类：
  10.  *
  11.  * 构造方法摘要
  12.  * FileInputStream(File file)
  13.  *           通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。
  14.  * FileInputStream(String name)
  15.  *           通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。
  16.  *
  17.  * 方法摘要
  18.  *  int available()
  19.  *           返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取（或跳过）的估计剩余字节数。
  20.  *  void close()
  21.  *           关闭此文件输入流并释放与此流有关的所有系统资源。
  22.  *  int read()
  23.  *           从此输入流中读取一个数据字节。
  24.  *  int read(byte[] b)
  25.  *           从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。
  26.  *  int read(byte[] b, int off, int len)
  27.  *           从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。
  28.  *  long skip(long n)
  29.  *           从输入流中跳过并丢弃 n 个字节的数据。
  30.  */
  31. public class Demo04 {
  32.     public static void main(String[] args) {
  33.         FileInputStream fis = null;
  34.         try {
  35.             // 1. 创建对象
  36.             fis = new FileInputStream(new File("D://a.txt"));
  37.             // 2. 干活 -- 读取数据
  38.             // read() 按照单字节读取数据；返回读取到的字节数据，如果读取到文件末尾返回-1
  39.             int b;
  40.             while((b = fis.read()) != -1){
  41.                 System.out.println(b);
  42.             }
  43.         } catch (FileNotFoundException exception) {
  44.             exception.printStackTrace();
  45.         } catch (IOException exception) {
  46.             exception.printStackTrace();
  47.         }finally {
  48.             // 3. 释放资源
  49.             if(fis != null){
  50.                 try {
  51.                     fis.close();
  52.                 } catch (IOException exception) {
  53.                     exception.printStackTrace();
  54.                 }
  55.                 fis = null;
  56.             }
  57.         }
  58.     }
  59. }

按照字节数据读取数据

  1. package com.powernode.p1;
  3. import java.io.FileInputStream;
  4. import java.io.FileNotFoundException;
  5. import java.io.IOException;
  6. import java.util.Arrays;
  8. /**
  9.  * FileInputStream类：
  10.  *
  11.  *  int read(byte[] b)
  12.  *           从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。
  13.  *  int read(byte[] b, int off, int len)
  14.  *           从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。
  15.  */
  16. public class Demo05 {
  18.     public static void main(String[] args) {
  19.         FileInputStream fis = null;
  20.         try {
  21.             fis = new FileInputStream("D://b.txt");
  22.             byte[] bs = new byte[1024];
  23.             // 按照字节数组读取数据,将数据读取到字节数组（缓冲区）中
  24.             // 返回读取到的字节总数，也就是读取到的字节长度；如果到了文件末尾返回-1
  25.             int len;
  26.             while((len = fis.read(bs)) != -1){
  27.                 System.out.print(new String(bs,0,len));
  28.             }
  29.         } catch (FileNotFoundException exception) {
  30.             exception.printStackTrace();
  31.         } catch (IOException exception) {
  32.             exception.printStackTrace();
  33.         }finally {
  34.             if(fis != null){
  35.                 try {
  36.                     fis.close();
  37.                 } catch (IOException exception) {
  38.                     exception.printStackTrace();
  39.                 }
  41.                 fis = null;
  42.             }
  43.         }
  44.     }
  45. }

其他方法

  1. package com.powernode.p1;
  3. import java.io.FileInputStream;
  4. import java.io.FileNotFoundException;
  5. import java.io.IOException;
  7. /**
  8.  * FileInputStream类：
  9.  *
  10.  *  int available()
  11.  *          可用的剩余字节数
  12.  *  long skip(long n)
  13.  *           从输入流中跳过 n 个字节的数据。
  14.  */
  15. public class Demo06 {
  17.     public static void main(String[] args) {
  18.         FileInputStream fis = null;
  19.         try {
  20.             fis = new FileInputStream("D://b.txt");
  21.             // 可用的剩余字节数
  22.             int count = fis.available();
  23.             System.out.println(count);
  25.             // 表示跳过2个字节
  26.             fis.skip(2);
  27.             int b = fis.read();
  28.             System.out.println(b);
  31.         } catch (FileNotFoundException exception) {
  32.             exception.printStackTrace();
  33.         } catch (IOException exception) {
  34.             exception.printStackTrace();
  35.         }finally {
  36.             if(fis != null){
  37.                 try {
  38.                     fis.close();
  39.                 } catch (IOException exception) {
  40.                     exception.printStackTrace();
  41.                 }
  43.                 fis = null;
  44.             }
  45.         }
  46.     }
  47. }

拷贝文件

  1. package com.powernode.p1;
  3. import java.io.FileInputStream;
  4. import java.io.FileNotFoundException;
  5. import java.io.FileOutputStream;
  6. import java.io.IOException;
  8. /**
  9.  * 演示：使用字节流拷贝文件
  10.  * 分析：
  11.  *  1. 字节输入流读取源文件数据
  12.  *  2. 字节输出流写数据到目标文件
  13.  *  3. 边读边写
  14.  *  4. 关闭资源
  15.  *
  16.  *  字节流是万能流，什么类型的文件都可以读写（复制），因为任何数据在计算机中都是字节。
  17.  *
  18.  */
  19. public class CopyFileDemo {
  20.     public static void main(String[] args) {
  21.         String src = "D://video/228.泛型和集合_LinkedHashMap集合的概述.avi";
  22.         String dest ="E://b.avi";
  23. //        copyFileBySingleByte(src,dest); // 耗时：121738
  25.         copyFileByByteArray(src,dest);// 耗时：162  105 77  45
  26.     }
  27.     /**
  28.      * 使用字节数组的方式拷贝文件
  29.      * @param srcPath 源文件路径
  30.      * @param destPath 目标文件路径
  31.      */
  32.     public static void copyFileByByteArray(String srcPath,String destPath){
  33.         // 创建输入流和输出流对象
  34.         FileInputStream fis = null;
  35.         FileOutputStream fos = null;
  36.         try {
  37.             fis = new FileInputStream(srcPath);
  38.             fos = new FileOutputStream(destPath);
  39.             // 边读边写
  40.             int len; // 存储读取到的字节总数
  41.             byte[] bs = new byte[1024];
  42.             long start = System.currentTimeMillis();
  43.             while((len = fis.read(bs)) != -1){
  44.                 fos.write(bs,0,len);
  45.             }
  46.             long end = System.currentTimeMillis();
  47.             System.out.println("耗时：" + (end - start));
  48.         } catch (IOException exception) {
  49.             exception.printStackTrace();
  50.         }finally {
  51.             // 释放资源
  52.             if(fos != null){
  53.                 try {
  54.                     fos.close();
  55.                 } catch (IOException exception) {
  56.                     exception.printStackTrace();
  57.                 }
  59.                 fos = null;
  60.             }
  62.             if(fis != null){
  63.                 try {
  64.                     fis.close();
  65.                 } catch (IOException exception) {
  66.                     exception.printStackTrace();
  67.                 }
  69.                 fis = null;
  70.             }
  71.         }
  72.     }
  73.     /**
  74.      * 使用单字节的方式拷贝文件
  75.      * @param srcPath 源文件路径
  76.      * @param destPath 目标文件路径
  77.      */
  78.     public static void copyFileBySingleByte(String srcPath,String destPath){
  79.         // 创建输入流和输出流对象
  80.         FileInputStream fis = null;
  81.         FileOutputStream fos = null;
  82.         try {
  83.             fis = new FileInputStream(srcPath);
  84.             fos = new FileOutputStream(destPath);
  85.             // 边读边写
  86.             int b; // 存储读取到的字节数据
  87.             long start = System.currentTimeMillis();
  88.             while((b = fis.read()) != -1){
  89.                 fos.write(b);
  90.             }
  91.             long end = System.currentTimeMillis();
  92.             System.out.println("耗时：" + (end - start));
  93.         } catch (IOException exception) {
  94.             exception.printStackTrace();
  95.         }finally {
  96.             // 释放资源
  97.             if(fos != null){
  98.                 try {
  99.                     fos.close();
  100.                 } catch (IOException exception) {
  101.                     exception.printStackTrace();
  102.                 }
  104.                 fos = null;
  105.             }
  107.             if(fis != null){
  108.                 try {
  109.                     fis.close();
  110.                 } catch (IOException exception) {
  111.                     exception.printStackTrace();
  112.                 }
  114.                 fis = null;
  115.             }
  116.         }
  117.     }
  118. }

通过以上文件拷贝的案例测试，我们发现使用数组拷贝的方式比单字节拷贝效率高很多。使用字节数组拷贝的时候，自己数组的大小不是越大越好，一般在1024-8192字节区间设置，效率逐渐提高。增加更大的字节数组大小反而造成效率下降了。

jdk中其实已经帮我们设计好了一个IO流，这个IO流就可以帮助我们提高读写数据的效率。这个IO流就是缓冲流。

字节缓冲流

BufferedInputStream-字节缓冲输入流⭐⭐⭐

  1. public class BufferedInputStream extends FilterInputStream

BufferedInputStream为另一个输入流添加一些功能，即缓冲输入以及支持 mark 和 reset 方法的能力。

单字节读取数据

  1. package com.powernode.p2;
  3. import java.io.BufferedInputStream;
  4. import java.io.FileInputStream;
  5. import java.io.FileNotFoundException;
  6. import java.io.IOException;
  8. /**
  9.  * BufferedInputStream 缓冲字节输入流
  10.  *
  11.  * 构造方法摘要
  12.  * BufferedInputStream(InputStream in)
  13.  *           创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
  14.  * BufferedInputStream(InputStream in, int size)
  15.  *           创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
  16.  *
  17.  * 节点流（普通流）：可以直接从数据源或目的地读写数据。
  18.  * 处理流（包装流、包裹流）：不直接连接到数据源或目的地，是“处理流的流”。通过对其它流进行封装，目的主要是简化操作和提高程序的性能。
  19.  *
  20.  * 缓冲就是一种处理流（包装流、包裹流），在节点流的基础上添加了缓冲的功能。
  21.  */
  22. public class Demo01 {
  24.     public static void main(String[] args) {
  25.         BufferedInputStream bis = null;
  26.         try {
  27.             bis = new BufferedInputStream(new FileInputStream("D://a.txt"));
  28.             int b;
  29.             while((b = bis.read()) != -1){
  30.                 System.out.println(b);
  31.             }
  32.         } catch (IOException exception) {
  33.             exception.printStackTrace();
  34.         }finally {
  35.             if(bis != null){
  36.                 try {
  37.                     bis.close();
  38.                 } catch (IOException exception) {
  39.                     exception.printStackTrace();
  40.                 }
  41.             }
  42.         }
  44.     }
  45. }

缓冲流单字节读取数据的原理

IO流 - 图4

按照字节数组读取数据

  1. package com.powernode.p2;
  4. import java.io.BufferedInputStream;
  5. import java.io.FileInputStream;
  6. import java.io.FileNotFoundException;
  7. import java.io.IOException;
  9. public class Demo02 {
  10.     public static void main(String[] args) {
  11.         BufferedInputStream bis = null;
  12.         try {
  13.             bis = new BufferedInputStream(new FileInputStream("D://a.txt"));
  14.             // 按照字节数组读取
  15.             int len;
  16.             byte[] bs = new byte[1024];
  17.             while((len = bis.read(bs))!= -1){
  18.                 System.out.println( new String(bs,0,len));
  19.             }
  20.         } catch (FileNotFoundException exception) {
  21.             exception.printStackTrace();
  22.         } catch (IOException exception) {
  23.             exception.printStackTrace();
  24.         }finally {
  25.             // close
  26.         }
  27.     }
  28. }

缓冲流字节数组读取数据的原理

IO流 - 图5

BufferedOutputStream-字节缓冲输出流⭐⭐⭐

  1. public class BufferedOutputStream extends FilterOutputStream

该类实现缓冲的输出流。通过设置这种输出流，应用程序就可以将各个字节写入底层输出流中，而不必针对每次字节写入调用底层系统。

单字节写数据

  1. package com.powernode.p1;
  3. import java.io.BufferedOutputStream;
  4. import java.io.FileNotFoundException;
  5. import java.io.FileOutputStream;
  6. import java.io.IOException;
  8. /**
  9.  * BufferedOutputStream-字节缓冲输出流
  10.  *   该类实现缓冲的输出流。通过设置这种输出流，应用程序就可以将各个字节写入底层输出流中，而不必针对每次字节写入调用底层系统。
  11.  *
  12.  * 构造方法摘要
  13.  * BufferedOutputStream(OutputStream out)
  14.  *           创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
  15.  * BufferedOutputStream(OutputStream out, int size)
  16.  *           创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流
  17.  *
  18.  * 方法摘要
  19.  *  void flush()
  20.  *           刷新此缓冲的输出流。
  21.  *  void write(byte[] b, int off, int len)
  22.  *           将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此缓冲的输出流。
  23.  *  void write(int b)
  24.  *           将指定的字节写入此缓冲的输出流。
  25.  *
  26.  */
  27. public class Demo01 {
  28.     public static void main(String[] args) {
  29.         BufferedOutputStream bos = null;
  30.         try {
  31.             // 创建对象
  32.             bos = new BufferedOutputStream(new FileOutputStream("D://out.txt"));
  33.             // 干活
  34.             bos.write(97);
  35.             // 手动将缓冲区中的数据刷写到文件
  36.             bos.flush();
  37.         } catch (IOException exception) {
  38.             exception.printStackTrace();
  39.         }finally {
  40.             if(bos != null){
  41.                 try {
  42.                     bos.close(); // 缓冲流释放资源的时候会调用flush
  43.                 } catch (IOException exception) {
  44.                     exception.printStackTrace();
  45.                 }
  46.                 bos = null;
  47.             }
  48.         }
  49.     }
  50. }

IO流 - 图6

按照字节数组写数据

  1. package com.powernode.p1;
  3. import java.io.BufferedOutputStream;
  4. import java.io.FileNotFoundException;
  5. import java.io.FileOutputStream;
  6. import java.io.IOException;
  8. public class Demo02 {
  10.     public static void main(String[] args) {
  11.         BufferedOutputStream bos = null;
  12.         try {
  13.             bos = new BufferedOutputStream(new FileOutputStream("D://c.txt"),12);
  14.             // 按照字节数组写数据
  15.             byte[] bs = "好好学习".getBytes();
  16.             bos.write(bs);
  17.             bos.flush();
  18.         } catch (IOException exception) {
  19.             exception.printStackTrace();
  20.         }finally {
  21.             if(bos != null){
  22.                 try {
  23.                     bos.close();
  24.                 } catch (IOException exception) {
  25.                     exception.printStackTrace();
  26.                 }
  27.                 bos= null;
  28.             }
  29.         }
  30.     }
  31. }

IO流 - 图7

缓冲流的好处

  • 减少了对磁盘读写的频率，提高了效率
  • 站在代码设计的角度考虑，使用了装饰者设计模式，增强了流的功能。（简化代码）
  • 支持了mark和reset方法

字符流

字符流 = 字节流 + 字符编码

因为计算机中的数据是字节，所以读写数据还是需要使用字节流。但是读取中文的时候，由于中文的编码格式不一样，所以字节转中文的时候就比较麻烦，jdk帮我们设计了字符流，我们只需要在字节流的基础上添加对应的字符编码就可以将字节转成中文。方便我们操作中文。

Writer

  1. public abstract class Writer extends Object implements Appendable, Closeable, Flushable

写入字符流的抽象类。

OutputStreamWriter-转换流（字符输出流）⭐⭐⭐

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

IO流 - 图8

单字符写数据

  1. package com.powernode.p2;
  3. import java.io.FileNotFoundException;
  4. import java.io.FileOutputStream;
  5. import java.io.IOException;
  6. import java.io.OutputStreamWriter;
  7. import java.util.Arrays;
  9. /**
  10.  * OutputStreamWriter: 字符输出流
  11.  * 构造方法摘要
  12.  * OutputStreamWriter(OutputStream out)
  13.  *           创建使用默认字符编码的 OutputStreamWriter。
  14.  * OutputStreamWriter(OutputStream out, Charset cs)
  15.  *           创建使用给定字符集的 OutputStreamWriter。
  16.  * OutputStreamWriter(OutputStream out, CharsetEncoder enc)
  17.  *           创建使用给定字符集编码器的 OutputStreamWriter。
  18.  * OutputStreamWriter(OutputStream out, String charsetName)
  19.  *           创建使用指定字符集的 OutputStreamWriter。
  20.  *
  21.  * 常用方法：
  22.  * void write(char[] cbuf)
  23.  *           写入字符数组。
  24.  *  void write(char[] cbuf, int off, int len)
  25.  *           写入字符数组的某一部分。
  26.  *  void write(int c)
  27.  *           写入单个字符。
  28.  *  void write(String str)
  29.  *           写入字符串。
  30.  *  void write(String str, int off, int len)
  31.  *           写入字符串的某一部分。
  32.  */
  33. public class Demo01 {
  34.     public static void main(String[] args) {
  35.         OutputStreamWriter writer = null;
  36.         try {
  37.             // 创建使用默认字符编码的 OutputStreamWriter。
  38.             writer = new OutputStreamWriter(new FileOutputStream("D://a.txt"));
  39.             writer.write('我');
  40.             // 注意：使用字符流需要flush()
  41.             writer.flush();
  42.         } catch (IOException exception) {
  43.             exception.printStackTrace();
  44.         }finally {
  45.             if(writer != null){
  46.                 try {
  47.                     writer.close(); // close也会flush
  48.                 } catch (IOException exception) {
  49.                     exception.printStackTrace();
  50.                 }
  51.                 writer = null;
  52.             }
  53.         }
  55.     }
  56. }

按照字符数组写数据

  1. package com.powernode.p2;
  3. import java.io.*;
  5. public class Demo02 {
  7.     public static void main(String[] args) {
  8.         OutputStreamWriter writer = null;
  9.         try {
  10.             // 创建字符流对象，指定字符编码格式
  11.             writer = new OutputStreamWriter(new FileOutputStream("D://b.txt",true), "GBK");
  12.             // 按照字符数组写数据
  13.             writer.write("好好学习".toCharArray());
  14.             // 按照字符串写数据
  15.             writer.write("天天向上");
  16.             // 写入一个换行符,windows环境的换行符是 \r\n
  17.             writer.write("\r\n");
  18.             writer.flush();
  19.         } catch (UnsupportedEncodingException e) {
  20.             e.printStackTrace();
  21.         } catch (IOException exception) {
  22.             exception.printStackTrace();
  23.         }finally {
  24.             // close
  25.         }
  26.     }
  27. }

Reader

  1. public abstract class Reader extends Object implements Readable, Closeable

用于读取字符流的抽象类。

InputStreamReader-转换流（字符输入流）⭐⭐⭐

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

单字符读取数据

  1. package com.powernode.p2;
  3. import java.io.FileInputStream;
  4. import java.io.FileNotFoundException;
  5. import java.io.IOException;
  6. import java.io.InputStreamReader;
  8. /**
  9.  * InputStreamReader：
  10.  *
  11.  * 构造方法摘要：
  12.  * InputStreamReader(InputStream in)
  13.  *           创建一个使用默认字符集的 InputStreamReader。
  14.  * InputStreamReader(InputStream in, Charset cs)
  15.  *           创建使用给定字符集的 InputStreamReader。
  16.  * InputStreamReader(InputStream in, CharsetDecoder dec)
  17.  *           创建使用给定字符集解码器的 InputStreamReader。
  18.  * InputStreamReader(InputStream in, String charsetName)
  19.  *           创建使用指定字符集的 InputStreamReader。
  20.  *
  21.  * 常用方法：
  22.  * int read()
  23.  *           读取单个字符。读取的字符，如果已到达流的末尾，则返回 -1
  24.  *  int read(char[] cbuf)
  25.  *           按照字符数组读取。读取的字符，如果已到达流的末尾，则返回 -1
  26.  *  int read(char[] cbuf, int offset, int length)
  27.  *           将字符读入数组中的某一部分。读取的字符，如果已到达流的末尾，则返回 -1
  28.  */
  29. public class Demo03 {
  31.     public static void main(String[] args) {
  32.         InputStreamReader reader = null;
  33.         try {
  34.             /*
  35.             * InputStreamReader对象的字符编码指定成什么，应该根据读取的文件
  36.             * 内容的字符编码决定。
  37.             */
  38.             reader = new InputStreamReader(new FileInputStream("D://a.txt"),"GBK");
  39.             int c;
  40.             while((c = reader.read()) != -1){
  41.                 System.out.println((char)c);
  42.             }
  43.         } catch (FileNotFoundException exception) {
  44.             exception.printStackTrace();
  45.         } catch (IOException exception) {
  46.             exception.printStackTrace();
  47.         }finally {
  48.             // close
  49.         }
  50.     }
  51. }

按照字符数组读取数据

  1. package com.powernode.p2;
  3. import java.io.FileInputStream;
  4. import java.io.FileNotFoundException;
  5. import java.io.IOException;
  6. import java.io.InputStreamReader;
  8. // 按照字符数组读取数据
  9. public class Demo04 {
  11.     public static void main(String[] args) {
  12.         InputStreamReader reader = null;
  13.         try {
  14.             /*
  15.             * InputStreamReader对象的字符编码指定成什么，应该根据读取的文件
  16.             * 内容的字符编码决定。
  17.             */
  18.             reader = new InputStreamReader(new FileInputStream("D://a.txt"),"GBK");
  19.             // 按照字符数组读取数据
  20.             int len;
  21.             char[] cs= new char[1024];
  22.             while((len = reader.read(cs)) != -1){
  23.                 System.out.println(new String(cs,0,len));
  24.             }
  25.         } catch (FileNotFoundException exception) {
  26.             exception.printStackTrace();
  27.         } catch (IOException exception) {
  28.             exception.printStackTrace();
  29.         }finally {
  30.             // close
  31.         }
  32.     }
  33. }

注意

字符流不是万能的。

字符流可以读写哪些格式的文件？

文件使用操作系统的记事本打开后没有出现乱码，字符流就可以。

便捷类

FileWriter ⭐⭐⭐

  1. public class FileWriter extends OutputStreamWriter

用来写入字符文件的便捷类。

  1. package com.powernode.p2;
  3. import java.io.FileOutputStream;
  4. import java.io.FileWriter;
  5. import java.io.IOException;
  6. import java.io.OutputStreamWriter;
  8. /**
  9.  * FileWriter类：
  10.  *构造方法摘要
  11.  *
  12.  * FileWriter(File file)
  13.  *           根据给定的 File 对象构造一个 FileWriter 对象。
  14.  * FileWriter(File file, boolean append)
  15.  *           根据给定的 File 对象构造一个 FileWriter 对象。
  16.  * FileWriter(String fileName)
  17.  *           根据给定的文件名构造一个 FileWriter 对象。
  18.  * FileWriter(String fileName, boolean append)
  19.  *           根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象。
  20.  *
  21.  *
  22.  */
  23. public class Demo06 {
  25.     public static void main(String[] args) {
  26.         FileWriter writer = null;
  27.         try {
  28.            /*
  29.            * 便捷类：便捷体现在：
  30.            * 1. 构造中不再需要手动创建OutputStream对象，
  31.            * FileWriter底层源码中自动帮我们创建了FileOutputStream对象
  32.            *
  33.            * 2. 不需要手动指定字符编码格式了，会自动使用默认的字符编码
  34.            *
  35.            * 缺点：
  36.            *    字符编码格式固定了，也就是便捷类只能操作一种编码格式。
  37.            *
  38.            */
  39.             writer = new FileWriter("D://c.txt");
  40.             writer.write("真的是好便捷哦");
  41.             writer.flush();
  42.         } catch (IOException exception) {
  43.             exception.printStackTrace();
  44.         }finally {
  45.             // close
  46.         }
  47.     }
  48. }

FileReader ⭐⭐⭐

  1. public class FileReader extends InputStreamReader

用来读取字符文件的便捷类。

  1. package com.powernode.p2;
  3. import java.io.FileNotFoundException;
  4. import java.io.FileReader;
  5. import java.io.IOException;
  7. /**
  8.  * FileReader类：
  9.  *
  10.  * 构造方法摘要
  11.  * FileReader(File file)
  12.  *           在给定从中读取数据的 File 的情况下创建一个新 FileReader。
  13.  * FileReader(String fileName)
  14.  *           在给定从中读取数据的文件名的情况下创建一个新 FileReader。
  15.  */
  16. public class Demo07 {
  18.     public static void main(String[] args) {
  19.         FileReader reader = null;
  20.         try {
  21.             /*
  22.              * 使用FileReader的前提是：
  23.              *   文件的字符编码和平台的默认编码格式一致才能使用；否则中文乱码
  24.              */
  25.             reader = new FileReader("D://a.txt");
  26.             int len;
  27.             char[] cs = new char[1024];
  28.             while((len = reader.read(cs)) != -1){
  29.                 System.out.println(new String(cs,0,len));
  30.             }
  31.          } catch (IOException exception) {
  32.             exception.printStackTrace();
  33.         }finally {
  34.             // close
  35.         }
  36.     }
  37. }

BufferedWriter-缓冲字符输出流 ⭐⭐⭐

将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。

该类提供了 newLine() 方法，它使用平台自己的行分隔符概念。（跨平台分隔符）

  1. package com.powernode.p3;
  3. import java.io.*;
  5. /**
  6.  * BufferedWriter-缓冲字符输出流
  7.  *
  8.  * 构造方法摘要
  9.  * BufferedWriter(Writer out)
  10.  *           创建一个使用默认大小输出缓冲区的缓冲字符输出流。
  11.  * BufferedWriter(Writer out, int sz)
  12.  *           创建一个使用给定大小输出缓冲区的新缓冲字符输出流。
  13.  *
  14.  * 方法摘要
  15.  *  void close()
  16.  *           关闭此流，但要先刷新它。
  17.  *  void flush()
  18.  *           刷新该流的缓冲。
  19.  *  void newLine()
  20.  *           写入一个行分隔符。
  21.  *  void write(char[] cbuf, int off, int len)
  22.  *           写入字符数组的某一部分。
  23.  *  void write(int c)
  24.  *           写入单个字符。
  25.  *  void write(String s, int off, int len)
  26.  *           写入字符串的某一部分。
  27.  */
  28. public class Demo01 {
  30.     public static void main(String[] args) {
  31.         BufferedWriter writer = null;
  32.         try {
  33.             writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("D://x.txt",true)));
  34.             writer.write("java是世界上最好的语言");
  35.             // newLine() 根据系统的分隔符来决定
  36.             writer.newLine();
  37.             writer.flush();
  38.         } catch (IOException exception) {
  39.             exception.printStackTrace();
  40.         }finally {
  41.             // close
  42.         }
  43.     }
  44. }

BufferedReader-缓冲字符输入流 ⭐⭐⭐

从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。

  1. package com.powernode.p3;
  3. import java.io.*;
  5. /**
  6.  * BufferedReader-缓冲字符输入流
  7.  *
  8.  * 构造方法摘要
  9.  * BufferedReader(Reader in)
  10.  *           创建一个使用默认大小输入缓冲区的缓冲字符输入流。
  11.  * BufferedReader(Reader in, int sz)
  12.  *           创建一个使用指定大小输入缓冲区的缓冲字符输入流。
  13.  *
  14.  * 方法摘要
  15.  *  void close()
  16.  *           关闭该流并释放与之关联的所有资源。
  17.  *  int read()
  18.  *           读取单个字符。
  19.  *  int read(char[] cbuf, int off, int len)
  20.  *           将字符读入数组的某一部分。
  21.  *  String readLine()
  22.  *           读取一个文本行。如果已到达流末尾，则返回 null
  23.  */
  24. public class Demo02 {
  25.     public static void main(String[] args) {
  26.         BufferedReader reader = null;
  27.         try {
  28.             reader = new BufferedReader(new InputStreamReader(new FileInputStream("D://x.txt")));
  29.             String line;
  30.             while((line = reader.readLine()) != null){
  31.                 System.out.println(line);
  32.             }
  33.         } catch (IOException exception) {
  34.             exception.printStackTrace();
  35.         }finally {
  36.             // close
  37.         }
  38.     }
  39. }

什么情况使用字节流；什么情况使用字符流

  • 字节流是万能的，什么情况下都可以使用。
  • 字符流只能用于记事本打开后不乱码的文件。
  • 如果字节流和字符流都可以操作文件的时候，想读取文件中的内容使用字符流。因为字节流读取出来的是字节，遇到中文的时候，我们自己处理会很麻烦的。

数据流

DataOutputStream-数据字节输出流

数据输出流允许应用程序以适当方式将基本 Java 数据类型写入输出流中。然后，应用程序可以使用数据输入流将数据读入。

  1. package com.powernode.p3;
  3. import java.io.DataOutputStream;
  4. import java.io.FileNotFoundException;
  5. import java.io.FileOutputStream;
  6. import java.io.IOException;
  8. /**
  9.  * DataOutputStream-数据字节输出流
  10.  *  数据输出流允许应用程序以适当方式将基本 Java 数据类型写入输出流中
  11.  *
  12.  * 构造方法摘要
  13.  * DataOutputStream(OutputStream out)
  14.  *           创建一个新的数据输出流，将数据写入指定基础输出流。
  15.  *
  16.  * 方法摘要
  17.  *  void writeBoolean(boolean v)
  18.  *           将一个 boolean 值以 1-byte 值形式写入基础输出流。
  19.  *  void writeByte(int v)
  20.  *           将一个 byte 值以 1-byte 值形式写出到基础输出流中。
  21.  *  void writeChar(int v)
  22.  *           将一个 char 值以 2-byte 值形式写入基础输出流中，先写入高字节。
  23.  *  void writeDouble(double v)
  24.  *           使用 Double 类中的 doubleToLongBits 方法将 double 参数转换为一个 long 值，然后将该 long 值以 8-byte 值形式写入基础输出流中，先写入高字节。
  25.  *  void writeFloat(float v)
  26.  *           使用 Float 类中的 floatToIntBits 方法将 float 参数转换为一个 int 值，然后将该 int 值以 4-byte 值形式写入基础输出流中，先写入高字节。
  27.  *  void writeInt(int v)
  28.  *           将一个 int 值以 4-byte 值形式写入基础输出流中，先写入高字节。
  29.  *  void writeLong(long v)
  30.  *           将一个 long 值以 8-byte 值形式写入基础输出流中，先写入高字节。
  31.  *  void writeShort(int v)
  32.  *           将一个 short 值以 2-byte 值形式写入基础输出流中，先写入高字节。
  33.  *  void writeUTF(String str)
  34.  *           以与机器无关方式使用 UTF-8 修改版编码将一个字符串写入基础输出流。
  35.  */
  36. public class Demo04 {
  38.     public static void main(String[] args) {
  39.         DataOutputStream dos = null;
  40.         try {
  41.             dos = new DataOutputStream(new FileOutputStream("D://data.txt"));
  42.             // DataOutputStream 是将数据按照每一个字节的方式写入文件的
  43.            dos.writeByte(97);
  44.            dos.writeShort(100);
  45.            dos.writeInt(200);
  46.            dos.writeLong(1000);
  47.            dos.writeChar('我');
  48.            dos.writeFloat(3.14f);
  49.            dos.writeDouble(13.14);
  50.            dos.writeBoolean(true);
  52.            // writeUTF写入的字符串字节总数不能超过65535
  53.            dos.writeUTF("你说啥呢");
  54.         } catch (IOException exception) {
  55.             exception.printStackTrace();
  56.         }finally {
  57.             // close
  58.         }
  59.     }
  60. }

DataInputStream-数据字节输入流

数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。应用程序可以使用数据输出流写入稍后由数据输入流读取的数据。

  1. package com.powernode.p3;
  3. import java.io.DataInputStream;
  4. import java.io.FileInputStream;
  5. import java.io.FileNotFoundException;
  6. import java.io.IOException;
  8. /**
  9.  * DataInputStream-数据字节输入流
  10.  * 构造方法摘要
  11.  * DataInputStream(InputStream in)
  12.  *           使用指定的底层 InputStream 创建一个 DataInputStream。
  13.  *
  14.  * 方法摘要
  15.  *  boolean readBoolean()
  16.  *  byte readByte()
  17.  *  char readChar()
  18.  *  double readDouble()
  19.  *  float readFloat()
  20.  *  int readInt()
  21.  *  long readLong()
  22.  *  short readShort()
  23.  *  String readUTF()
  24.  *
  25.  */
  26. public class Demo05 {
  28.     public static void main(String[] args) {
  29.         DataInputStream dis = null;
  30.         try {
  31.             dis = new DataInputStream(new FileInputStream("D://data.txt"));
  32.             // 读取数据的顺序必须和写数据的顺序一致；否则数据错乱
  33.             System.out.println(dis.readByte());
  34.             System.out.println(dis.readShort());
  35.             System.out.println(dis.readInt());
  36.             System.out.println(dis.readLong());
  37.             System.out.println(dis.readChar());
  38.             System.out.println(dis.readFloat());
  39.             System.out.println(dis.readDouble());
  40.             System.out.println(dis.readBoolean());
  41.             System.out.println(dis.readUTF());
  42.         } catch (IOException exception) {
  43.             exception.printStackTrace();
  44.         }finally {
  45.             // close
  46.         }
  47.     }
  48. }

数据流的作用：

  1. 可以使用IO流直接操作基本数据类型的数据
  2. 可以用来将基本类型的数据和字符串数据进行序列化

序列化：将数据转字节的过程

反序列化：将字节转数据的过程

将数据持久化存储或者在网络中传输，数据是必须序列化的。

对象流⭐⭐⭐

当两个程序通信时，彼此可以发送任意数据类型的数据。 无论是何种类型的数据，都会以二进制序列的形式在网络上传送（序列化）。比如，我们可以通过发送字符串、基本数据类型的数据信息，我们也可以在网络上直接发送Java对象。发送方需要把这个Java对象转换为字节序列（序列化），才能在网络上传送；接收方则需要把字节序列再恢复为Java对象（反序列）。

ObjectOutputStream-对象序列化流

对象序列化：将对象转字节的过程

只能将支持 java.io.Serializable 接口的对象写入流中。每个 serializable 对象的类都被编码，编码内容包括类名和类签名、对象的字段值和数组值，以及从初始对象中引用的其他所有对象。

注意：java中的对象要序列化必须实现Serializable 接口。

  1. package com.powernode.p4;
  3. import java.io.Serializable;
  4. /**
  5.  * 如果一个接口只有声明，没有任何成员信息，那么这个接口叫做标记接口
  6.  * 也就是说这个接口的作用仅仅是用作标记。
  7.  *
  8.  * 对象的默认序列化机制写入的内容是：对象的类，类签名，以及非瞬态和非静态字段的值。
  9.  *
  10.  * 瞬态字段和静态字段是不会被序列化的。
  11.  *
  12.  * 瞬态字段：被关键字transient修饰的字段
  13.  * transient：表示短暂的意思
  14.  *
  15.  * 如果对象中的某些字段不希望被持久化，那么可以这些字段可以变成瞬态字段和静态字段
  16.  *
  17.  */
  18. public class Student implements Serializable {
  19.     /*
  20.     * serialVersionUID是根据当前类的信息生成的值
  21.     * 如果序列化和反序列后serialVersionUID不一致会出现无效类的异常
  22.     *
  23.     * 在开发中我们都是手动显式的给出serialVersionUID值，这样就可以避免无效类的异常的发生
  24.      */
  25.     private static final long serialVersionUID = -3174090006999218597L;
  26.     // 瞬态字段
  27.     private transient String name;
  28.     // 静态字段
  29.     private static int age;
  30.     private String sex;
  32.     public Student() {
  33.     }
  35.     public Student(String name, int age, String sex) {
  36.         this.name = name;
  37.         this.age = age;
  38.         this.sex = sex;
  39.     }
  41.     public String getName() {
  42.         return name;
  43.     }
  45.     public void setName(String name) {
  46.         this.name = name;
  47.     }
  49.     public int getAge() {
  50.         return age;
  51.     }
  53.     public void setAge(int age) {
  54.         this.age = age;
  55.     }
  57.     public String getSex() {
  58.         return sex;
  59.     }
  61.     public void setSex(String sex) {
  62.         this.sex = sex;
  63.     }
  65.     @Override
  66.     public String toString() {
  67.         return "Student{" +
  68.                 "name='" + name + '\'' +
  69.                 ", age=" + age +
  70.                 ", sex='" + sex + '\'' +
  71.                 '}';
  72.     }
  73. }
  1. package com.powernode.p4;
  3. import java.io.FileOutputStream;
  4. import java.io.IOException;
  5. import java.io.ObjectOutputStream;
  7. /**
  8.  * ObjectOutputStream对象序列化流
  9.  *    作用： 将对象转字节
  10.  *
  11.  *  构造方法摘要
  12.  *   ObjectOutputStream(OutputStream out)
  13.  *           创建写入指定 OutputStream 的 ObjectOutputStream。
  14.  *
  15.  *  常用方法：
  16.  *  void writeObject(Object obj)
  17.  *           将指定的对象写入 ObjectOutputStream。
  18.  *
  19.  */
  20. public class Demo01 {
  22.     public static void main(String[] args) {
  23.         ObjectOutputStream oos = null;
  24.         try {
  25.             oos = new ObjectOutputStream(new FileOutputStream("D://obj.txt"));
  26.             Student student = new Student("张三", 22, "male");
  27.             // java中的对象要序列化必须实现Serializable 接口
  28.             oos.writeObject(student);
  29.         } catch (IOException exception) {
  30.             exception.printStackTrace();
  31.         }finally {
  32.             // close
  33.         }
  34.     }
  35. }

ObjectInputStream-对象反序列化流

ObjectInputStream 对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化。

  1. package com.powernode.p4;
  3. import java.io.FileInputStream;
  4. import java.io.IOException;
  5. import java.io.ObjectInputStream;
  6. /**
  7.  * ObjectInputStream对象反序列化流
  8.  *   作用：将字节数据转对象
  9.  *
  10.  */
  11. public class Demo02 {
  12.     public static void main(String[] args) {
  13.         ObjectInputStream ois = null;
  14.         try {
  15.             ois = new ObjectInputStream(new FileInputStream("D://obj.txt"));
  16.             Student obj = (Student) ois.readObject();
  17.             System.out.println(obj);
  18.         } catch (IOException exception) {
  19.             exception.printStackTrace();
  20.         } catch (ClassNotFoundException e) {
  21.             e.printStackTrace();
  22.         }finally {
  23.             // close
  24.         }
  25.     }
  26. }

serialVersionUID

serialVersionUID是根据当前类的信息生成的值
如果序列化和反序列后serialVersionUID不一致会出现无效类的异常
在开发中我们都是手动显式的给出serialVersionUID值，这样就可以避免无效类的异常的发生

transient关键字

transient：表示短暂的意思

瞬态字段：被关键字transient修饰的字段

瞬态字段不能被序列化

字节数组流（内存流）

ByteArrayOutputStream 内存输出流 ⭐⭐

此类实现了一个输出流，其中的数据被写入一个 byte 数组。缓冲区会随着数据的不断写入而自动增长。可使用 toByteArray() 和 toString() 获取数据。

关闭 ByteArrayOutputStream 无效。此类中的方法在关闭此流后仍可被调用，而不会产生任何 IOException。

  1. package com.powernode.p1;
  3. import java.io.ByteArrayOutputStream;
  4. import java.io.IOException;
  6. /**
  7.  * 构造方法摘要
  8.  * ByteArrayOutputStream()
  9.  *           创建一个新的 byte 数组输出流。
  10.  * ByteArrayOutputStream(int size)
  11.  *           创建一个新的 byte 数组输出流，它具有指定大小的缓冲区容量（以字节为单位）。
  12.  *
  13.  *方法摘要
  14.  *  int size()
  15.  *           返回缓冲区的当前大小。
  16.  *  byte[] toByteArray()
  17.  *           创建一个新分配的 byte 数组。
  18.  *  String toString()
  19.  *           使用平台默认的字符集，通过解码字节将缓冲区内容转换为字符串。
  20.  *  String toString(String charsetName)
  21.  *           使用指定的 charsetName，通过解码字节将缓冲区内容转换为字符串。
  22.  *  void write(byte[] b, int off, int len)
  23.  *           将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此 byte 数组输出流。
  24.  *  void write(int b)
  25.  *           将指定的字节写入此 byte 数组输出流。
  26.  *
  27.  */
  28. public class Demo01 {
  29.     public static void main(String[] args) {
  30.         // 缓冲区的最大值 2G
  31.         ByteArrayOutputStream bos = new ByteArrayOutputStream();
  32.         try {
  33.             bos.write("好嗨哟".getBytes());
  34.         } catch (IOException exception) {
  35.             exception.printStackTrace();
  36.         }
  38.         // 可使用 toByteArray()  和 toString() 获取数据。
  39.         System.out.println(bos.toString());
  40.     }
  41. }

使用场景演示

  1. package com.powernode.p1;
  3. import java.io.*;
  5. /**
  6.  * 需求： 将图片显示加载（微信头像，朋友圈）
  7.  *
  8.  * 本地有一张图，需要将这个图片加载显示
  9.  * 1. 将图片读取出来  --- 字节缓冲输入流
  10.  * 2. 字节数据转图片，需要获取到整张图片的字节数据后再转图片
  11.  * 不能拿到图片的一部分数据就开始转图片，这样图片会损坏的。
  12.  *
  13.  */
  14. public class Demo02 {
  16.     public static void main(String[] args) {
  17.         ByteArrayOutputStream baos = null;
  18.         BufferedInputStream bis = null;
  19.         try {
  20.             bis = new BufferedInputStream(new FileInputStream("D://mm.webp"));
  21.             baos = new ByteArrayOutputStream();
  22.             int len;
  23.             byte[] bs = new byte[1024];
  24.             while((len = bis.read(bs)) != -1){
  25.                 // 读取图片数据 -- 将图片的字节数据保存到内存流中
  26.                 baos.write(bs,0,len);
  27.             }
  28.             /*
  29.             *  while循环完成后，内存流中就保存了整张图片的字节数据
  30.             */
  31.             // 获取图片的字节数据
  32.             byte[] bytes = baos.toByteArray();
  33.             // 我们就可以使用相关的工具类将字节数组转图片显示
  34.         } catch (IOException exception) {
  35.             exception.printStackTrace();
  36.         }finally {
  37.             // bis  close
  38.         }
  39.     }
  40. }

ByteArrayInputStream 内存输入流

ByteArrayInputStream 包含一个内部缓冲区，该缓冲区包含从流中读取的字节。

关闭 ByteArrayInputStream 无效。此类中的方法在关闭此流后仍可被调用，而不会产生任何 IOException。

  1. package com.powernode.p1;
  3. import java.io.ByteArrayInputStream;
  4. import java.io.ByteArrayOutputStream;
  5. import java.io.IOException;
  7. /**
  8.  * ByteArrayInputStream 内存输入流
  9.  *
  10.  *构造方法摘要
  11.  * ByteArrayInputStream(byte[] buf)
  12.  *           创建一个 ByteArrayInputStream，使用 buf 作为其缓冲区数组。
  13.  * ByteArrayInputStream(byte[] buf, int offset, int length)
  14.  *           创建 ByteArrayInputStream，使用 buf 作为其缓冲区数组。
  15.  *
  16.  * 方法摘要
  17.  *  int read()
  18.  *           从此输入流中读取下一个数据字节。
  19.  *  int read(byte[] b, int off, int len)
  20.  *           将最多 len 个数据字节从此输入流读入 byte 数组。
  21.  */
  22. public class Demo03 {
  24.     public static void main(String[] args) {
  25.         // 缓冲区的最大值 2G
  26.         ByteArrayOutputStream bos = new ByteArrayOutputStream();
  27.         try {
  28.             bos.write("abc".getBytes());
  29.             // 读取内存流中的数据
  30.             ByteArrayInputStream bais = new ByteArrayInputStream(bos.toByteArray());
  31.             int b = bais.read();
  32.             System.out.println(b);
  33.         } catch (IOException exception) {
  34.             exception.printStackTrace();
  35.         }
  36.     }
  37. }

打印流

打印流只有输出流没有输入流。

PrintStream 字节打印流

  1. public class PrintStream extends FilterOutputStream implements Appendable, Closeable

PrintStream 为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式。

与其他输出流不同，PrintStream 永远不会抛出 IOException

  1. package com.powernode.p1;
  3. import java.io.*;
  5. /**
  6.  * PrintStream 字节打印流
  7.  *
  8.  * 构造方法摘要
  9.  * PrintStream(File file)
  10.  *           创建具有指定文件且不带自动行刷新的新打印流。。
  11.  * PrintStream(OutputStream out)
  12.  *           创建新的打印流。
  13.  * PrintStream(OutputStream out, boolean autoFlush)
  14.  *           创建新的打印流。
  15.  * PrintStream(String fileName)
  16.  *           创建具有指定文件名称且不带自动行刷新的新打印流。
  17.  */
  18. public class Demo04 {
  19.     public static void main(String[] args) {
  20.         PrintStream ps = null;
  21.         try {
  22.             // autoFlush表示自动刷新，字节打印流中需要配合缓冲字节输出流使用。节点流使用该参数无效。
  23.             ps = new PrintStream(new BufferedOutputStream(new FileOutputStream("D://a.txt")),true);
  24.             ps.print("这是字节打印流");
  25.         } catch (FileNotFoundException exception) {
  26.             exception.printStackTrace();
  27.         }finally {
  28. //            ps.close();
  29.         }
  31.     }
  32. }

PrintWriter 字符打印流

  1. public class PrintWriter extends Writer

与 [PrintStream](../../java/io/PrintStream.html) 类不同，如果启用了自动刷新，则只有在调用 println、printf 或 format 的其中一个方法时才可能完成此操作。

PrintWriter 构造中既能接受字节流也能接受字符流。

  1. package com.powernode.p1;
  3. import java.io.FileWriter;
  4. import java.io.IOException;
  5. import java.io.PrintWriter;
  7. /**
  8.  * PrintWriter字符打印流
  9.  *
  10.  *  与 PrintStream  类不同，如果启用了自动刷新，则只有在调用 println、printf 或 format  的其中一个方法时才可能完成此操作。
  11.  */
  12. public class Demo05 {
  14.     public static void main(String[] args) {
  15.         PrintWriter pw = null;
  16.         try {
  17.             pw = new PrintWriter(new FileWriter("D://b.txt"), true);
  18.             // 如果启用了自动刷新，则只有在调用 println、printf 或 format  的其中一个方法时才可能完成此操作。
  19.             pw.println("字符打印流");
  20.         } catch (IOException exception) {
  21.             exception.printStackTrace();
  22.         }finally {
  23.             pw.close(); // close也会刷新数据
  24.         }
  25.     }
  26. }

标准流

标准输入流（System.in）：计算机中的最重要的输入设备是键盘，所以标准输入流就是读取键盘输入的数据

标准输出流（System.out）：计算机中的最重要的输出设备是显示器，所以标准输出流就是将数据写到显示器上（控制台输出）

static PrintStream **err**
“标准”错误输出流。
static InputStream **in**
“标准”输入流。
static PrintStream **out**
“标准”输出流。		 
  1. package com.powernode.p1;
  3. import java.io.*;
  5. /**
  6.  * 需求：接受键盘录入的数据。不允许使用Scanner类。
  7.  *
  8.  * 1. 接受键盘录入的数据需要用到标准输入流
  9.  *    System.in  --> InputStream
  10.  * 2. 假设键盘录入的数据是中文，字节流处理起来有点麻烦。
  11.  *    键盘录入的数据只会是字符串，不可能出现图片、音频、视频
  12.  *    所以这里使用字符流会更合适
  13.  */
  14. public class Demo06 {
  15.     public static void main(String[] args) {
  17.         System.out.println("请输入数据：");
  18.         InputStream in = System.in;
  19.         BufferedReader reader = null;
  20.         BufferedWriter writer = null;
  22.         try {
  23.             reader = new BufferedReader(new InputStreamReader(in));
  24.             writer = new BufferedWriter(new FileWriter("D://in.txt"));
  26.             String line = reader.readLine();
  27.             System.out.println(line);
  28.             // 将键盘录入的数据保存到文件中
  29.             writer.write(line);
  30.             writer.flush();
  32.         } catch (IOException exception) {
  33.             exception.printStackTrace();
  34.         }finally {
  35.             // close
  36.         }
  37.     }
  38. }

IO流关闭的工具类

  1. package com.powernode.p1;
  3. /**
  4.  * IO工具类
  5.  *
  6.  */
  7. public class IOUtils {
  8.     private IOUtils(){}
  10.     /**
  11.      * 关闭流，释放资源
  12.      */
  13.     public static void close(AutoCloseable... closeable){
  14.         for (AutoCloseable autoCloseable : closeable) {
  15.             try {
  16.                 autoCloseable.close();
  17.             } catch (Exception e) {
  18.                 e.printStackTrace();
  19.             }
  20.         }
  21.     }
  22. }

Properties-属性集⭐⭐⭐

  1. public class Properties extends Hashtable<Object,Object>

通过以上的继承关系我们可以知道，Properties中的数据是kv键值对格式的。

Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。

属性列表中每个键及其对应值都是一个字符串。

将属性集的数据持久化

  1. package com.powernode.p2;
  3. import java.io.FileWriter;
  4. import java.io.IOException;
  5. import java.util.Properties;
  7. /**
  8.  * 构造方法摘要
  9.  * Properties()
  10.  *           创建一个无默认值的空属性列表。
  11.  *
  12.  * 方法摘要
  13.  * --------------------------------- 操作kv的方法
  14.  *  String getProperty(String key)
  15.  *           用指定的键在此属性列表中搜索属性。
  16.  *  String getProperty(String key, String defaultValue)
  17.  *           用指定的键在属性列表中搜索属性。
  18.  *  Object setProperty(String key, String value)
  19.  *           调用 Hashtable 的方法 put。
  20.  *  Set<String> stringPropertyNames()
  21.  *           返回此属性列表中的键集，其中该键及其对应值是字符串，如果在主属性列表中未找到同名的键，则还包括默认属性列表中不同的键。
  22.  *
  23.  * ---------------------------------  读取数据到属性集中
  24.  *  void load(InputStream inStream)
  25.  *           从输入流中读取属性列表（键和元素对）。
  26.  *  void load(Reader reader)
  27.  *           按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。
  28.  *
  29.  * --------------------------------- 将集合中的数据保存成文件
  30.  *  void store(OutputStream out, String comments)
  31.  *           以适合使用 load(InputStream) 方法加载到 Properties 表中的格式，将此 Properties 表中的属性列表（键和元素对）写入输出流。
  32.  *  void store(Writer writer, String comments)
  33.  *           以适合使用 load(Reader) 方法的格式，将此 Properties 表中的属性列表（键和元素对）写入输出字符。
  34.  *
  35.  *
  36.  */
  37. public class Demo01 {
  38.     public static void main(String[] args) {
  39.         Properties prop = new Properties();
  41.         // 设置kv数据
  42.         prop.setProperty("name","zhangsan");
  43.         prop.setProperty("age","20");
  44.         prop.setProperty("sex","male");
  46.         // 将属性集中的数据持久化,文件的扩展名就是.properties
  47.         // .properties文件中使用#表示注释
  48.         try {
  49.             // 第二个参数是文件的说明信息
  50.             prop.store(new FileWriter("day23/user.properties"),"用户信息");
  51.         } catch (IOException exception) {
  52.             exception.printStackTrace();
  53.         }
  54.     }
  55. }

将文件的数据加载到属性集中

  1. package com.powernode.p2;
  3. import java.io.FileReader;
  4. import java.io.IOException;
  5. import java.util.Properties;
  6. import java.util.Set;
  8. public class Demo02 {
  9.     public static void main(String[] args) {
  10.         Properties properties = new Properties();
  11.         try {
  12.             properties.load(new FileReader("day23/user.properties"));
  13.             System.out.println(properties);
  14.             // 如果name1不存在，就返回默认值abc
  15.             System.out.println(properties.getProperty("name1","abc"));
  16.             Set<String> set = properties.stringPropertyNames();
  17.             for (String key : set) {
  18.                 System.out.println(key+"->"+properties.getProperty(key));
  19.             }
  20.         } catch (IOException exception) {
  21.             exception.printStackTrace();
  22.         }
  23.     }
  24. }

复制多级文件夹

  1. package com.powernode.p2;
  3. import com.powernode.p1.IOUtils;
  5. import java.io.*;
  7. /**
  8.  * 复制多级文件夹
  9.  *
  10.  * 分析：
  11.  *   1. 判断源文件路径是文件还是文件夹
  12.  *        文件：直接复制
  13.  *       文件夹：
  14.  *           a. 在目标路径上创建该文件夹
  15.  *           b. 获取文件夹下的所有内容
  16.  *               回到1
  17.  *
  18.  * 用过以上的分析发现需要使用递归
  19.  */
  20. public class CopyFloderDemo {
  22.     public static void main(String[] args) {
  23.         copyFloder(new File("D://a"),new File("E://"));
  25.     }
  27.     /**
  28.      * 复制多级文件夹
  29.      * @param src 源路径
  30.      * @param dest 目标路径
  31.      */
  32.     private static void copyFloder(File src, File dest){
  33.         // 1. 判断源文件路径是文件还是文件夹
  34.         // src = D://a.txt   dest = E://
  35.         if(src.isFile()){
  36.             // 文件：直接复制
  37.             // 将目标路径和源文件的文件名组成新的文件路径
  38.             // newFile =  E://a.txt
  39.             File newFile = new File(dest,src.getName());
  40.             copyFile(src,newFile);
  41.         }else{
  42.             // 是 文件夹：
  43.             // src = D://a   dest = E://
  44.             //  a. 在目标路径上创建该文件夹
  45.             // newFloder = E://a
  46.             File newFloder = new File(dest,src.getName());
  47.             // 创建文件夹
  48.             newFloder.mkdirs();
  49.             // b. 获取源文件夹下的所有内容
  50.             File[] files = src.listFiles();
  51.             for (File file : files) {
  52.                 // file = D://a/a.txt  newFloder = E://a
  53.                 //   回到1
  54.                 copyFloder(file,newFloder);
  55.             }
  56.         }
  57.     }
  59.     /**
  60.      * 复制文件
  61.      * @param src 源路径
  62.      * @param dest 目标路径
  63.      */
  64.     private static void copyFile(File src, File dest){
  65.         BufferedInputStream bis = null;
  66.         BufferedOutputStream bos = null;
  67.         try {
  68.             bis = new BufferedInputStream(new FileInputStream(src));
  69.             bos = new BufferedOutputStream(new FileOutputStream(dest));
  70.             int len;
  71.             byte[] bs = new byte[1024];
  72.             while((len = bis.read(bs)) != -1){
  73.                 bos.write(bs,0,len);
  74.             }
  75.             bos.flush();
  76.         } catch (IOException exception) {
  77.             exception.printStackTrace();
  78.         }finally {
  79.             IOUtils.close(bos,bis);
  80.         }
  81.     }
  82. }