数据源

datasource。提供原始数据的原始媒介，常见的：数据库、文件、其他程序、内存、网络设备、IO设备等。

IO流以程序为中心

由数据源(文件、内存、数据库)流入程序中去为输入流；由程序流出到目的地(文件、内存、数据库)中为输出流。

核心类

1、File 文件类

2、InputStream 字节输入流

3、OutputStream 字节输出流

4、Rader 字符输入流

5、Writer 字符输出流

6、Closeable 关闭流接口

7、Flushable 强制刷新流接口

8、Serializable 序列化接口

IO流分类

  • 节点流：可以直接从数据源或目的地读写数据。
    05.IO流（一） - 图1

  • 处理流（包装流）：不直接连接到数据源或目的地，对其他流进行封装，目的是简化操作和提高性能。
    05.IO流（一） - 图2

节点流和处理流的关系：

①、节点流处于IO流的一线，所有操作必须通过他们进行

②、处理流可以对其他流进行处理（提高效率或操作灵活性）

  • 字节流：按照字节读取数据（InputStream、OutputStream）
  • 字符流：按照字符读取数据（Reader、Writer），因为文件编码不同，从而有了对字符进行高效操作的字符流对象。

原理：底层还是基于字节流操作，自动搜寻了指定的码表。

IO流

节点流

四大抽象类

1、IntputStream：字节输入流

2、outPutStream：字节输出流

3、read：字符输入流

4、write：字符输出流

操作对象源文件存储在硬盘上，java对其操作需要借助操作系统OS，并且通知操作系统关闭资源

IO操作的四大步骤

1、创建源

2、选择流

3、操作（读/写）

4、释放资源

字节流

字节输入流：IntputStream

特性

1、字节输入流的父类

2、数据单位为字节(byte)

子类

1、FileInputStream

2、ByteArrayInputStream

FileInputStream：文件字节输入流

通过字节的方式读取文件，适合读取所有类型的文件（图像、音频）

基本方法

1、构造方法：newFileInputStream（）

2、读取操作：read/read（byte[]b）

3、关闭资源，close（）

  2. /**
  3.  *案例：一
  4.  * FileIntputStream 文件字节输入流
  5.  * 1、创建源
  6.  * 2、选择流
  7.  * 3、读取操作:read():一个字节一个字节的读取，返回实际读取到的数据值
  8.  * 4、释放资源
  9.  */
  10. public class FileInputStreamTest {
  11.     public static void main(String[] args) {
  12.         //1、创建源
  13.         File src=new File("test.txt");
  14.         //2、选择流
  15.         InputStream is=null;
  16.         try {
  17.             is=new FileInputStream(src);
  18.             int temp=-1;
  19.             //3、读取操作
  20.             while ((temp=is.read())!=-1){
  21.                 System.out.println((char) temp);
  22.             }
  23.         } catch (FileNotFoundException e) {
  24.             e.printStackTrace();
  25.         } catch (IOException e) {
  26.             e.printStackTrace();
  27.         } finally {
  28.             //4、释放资源
  29.                 try {
  30.                     if(null!=is) {
  31.                         is.close();
  32.                     }
  33.                 } catch (IOException e) {
  34.                     e.printStackTrace();
  35.                 }
  36.             }
  37.         }
  38.     }
  1. /**
  2.  *案例：二（字节数组方式读取）
  3.  * FileIntputStream 文件字节输入流
  4.  * 1、创建源
  5.  * 2、选择流
  6.  * 3、读取操作:    read(byte[] b):从该输入流读取最多 b.length个字节的数据到字节数组中（缓冲区），返回实际读取到的数据的大小。
  7.  * 4、释放资源
  8.  */
  9. public class FileInputStreamTest02 {
  10.     public static void main(String[] args) {
  11.         //1、创建源
  12.         File src=new File("test.txt");
  13.         //2、选择流
  14.         InputStream is=null;
  15.         try {
  16.             is=new FileInputStream(src);
  17.             //3、读取操作(分段读取)
  18.             byte[]flush=new byte[1024];//缓冲容器
  19.             int len=-1; //接收长度
  20.             while ((len=is.read(flush))!=-1){
  21.                 //字节数组-->字符串（解码）
  22.                String str=new String(flush,0,len);
  23.                System.out.println(str);
  24.             }
  25.         } catch (FileNotFoundException e) {
  26.             e.printStackTrace();
  27.         } catch (IOException e) {
  28.             e.printStackTrace();
  29.         } finally {
  30.             //4、释放资源
  31.                 try {
  32.                     if(null!=is) {
  33.                         is.close();
  34.                     }
  35.                 } catch (IOException e) {
  36.                     e.printStackTrace();
  37.                 }
  38.             }
  39.         }
  40.     }

ByteArrayInputStream（字节数组输入流）

1、操作的数据在内存中，处理数据不要太大

2、资源释放不用通知操作系统OS，JAVA GC垃圾回收机制会自动处理

  1. /**
  2.  * @auther TongFangPing
  3.  * @date 2019/9/26 13:47.
  4.  * ByteArrayIntputStream 字节数组输入流
  5.  * ByteArrayIntputStream和ByteArrayOutputStream。作用：用IO流的方式来完成对字节数组的读写
  6.  *原因：
  7.  *      流的来源或目的地并不一定是文件，也可以是内存中的一块空间，例如一个字节数组。
  8.  *      java.io.ByteArrayInputStream、java.io.ByteArrayOutputStream就是将字节数组当作流输入来源、
  9.  *      输出目的地的类。
  10.  *      如果在程序运行过程中产生过一些临时文件，就可以使用虚拟文件的方式来实现，不需要访问硬盘，而是直接访问内存。
  11.  *      提高了效率
  12.  * 1、创建源：字节数组,不要太大
  13.  * 2、选择流
  14.  * 3、读取操作:    read(byte[] b):从该输入流读取最多 b.length个字节的数据到字节数组中（缓冲区），返回接收大小。
  15.  * 4、释放资源:可以不用处理：数据在内存当中，java垃圾回收机制会处理。
  16.  */
  17. public class ByteArrayInputStreamTest01 {
  18.     public static void main(String[] args) {
  19.         //1、创建源
  20.         byte[]src="talk is cheap show me the code".getBytes();
  21.         //2、选择流
  22.         InputStream is=null;
  23.         try {
  24.             is=new ByteArrayInputStream(src);
  25.             int temp;
  26.             //3、读取操作(分段读取)
  27.             byte[]flush=new byte[4];//缓冲容器,每次读取4个字节到缓冲区容器中去
  28.             int len=-1; //接收长度
  29.             while ((len=is.read(flush))!=-1){
  30.                 //字节数组-->字符串（解码）
  31.                String str=new String(flush,0,len);
  32.                System.out.println(str);
  33.             }
  34.         }catch (IOException e) {
  35.             e.printStackTrace();
  36.         } finally {
  37.             //4、释放资源，可以不用处理，不用通知操作系统OS去释放资源。
  38.                 try {
  39.                     if(null!=is) {
  40.                         is.close();
  41.                     }
  42.                 } catch (IOException e) {
  43.                     e.printStackTrace();
  44.                 }
  45.             }
  46.         }
  47.     }

字节输出流：outPutStream

特性

1、字节输出流的父类

2、数据单位为字节(byte)

子类

1、FileOutputStream

2、ByteArrayOutputStream

FileOutputStream

用于将数据写入到输出流File，适合所有类型的文件（图像、音频）

基本方法

1、构造方法：newFileOutputStream（）

2、写入操作：Write（）

3、刷新操作：flush（）

4、关闭资源：close（）

  1. /**
  2.  * FileOutputStream 文件字节输出流
  3.  *  * 1、创建源
  4.  *  * 2、选择流
  5.  *  * 3、写入操作:write():
  6.  *  * 4、释放资源
  7.  */
  8. public class FileOutputStreamStudy01 {
  9.     public static void main(String[] args) {
  10.         //1、创建源
  11.         File file=new File("paji.txt");
  12.         OutputStream os=null;
  13.         try {
  14.             //2、选择流，非追加方式
  15.             os=new FileOutputStream(file);
  16.             //2、追加方式
  17.             //os=new FileOutputStream(file,true);
  18.             String msg="我是扒鸡我最棒！";
  19.             //字符-->字节（编码）
  20.             byte[] datas=msg.getBytes();
  21.             //3、写出操作
  22.             os.write(datas,0,datas.length);
  23.             //刷新此输出流并强制任何缓冲的输出字节被写出。
  24.             os.flush();
  25.         } catch (FileNotFoundException e) {
  26.             e.printStackTrace();
  27.         } catch (IOException e) {
  28.             e.printStackTrace();
  29.         }finally {
  30.                 try {
  31.                     //4、释放资源
  32.                     if(null!=os) {
  33.                         os.close();
  34.                     }
  35.                 } catch (IOException e) {
  36.                     e.printStackTrace();
  37.                 }
  38.             }
  39.         }
  40.     }

ByteArrayOutputStream(字节数组输出流)

1、不用关联File源文件

2、选择流，不使用多态

3、不用释放资源

方法：

toByteArray()：创建一个新分配的字节数组。

  1. /**
  2.  * ByteArrayOutputStream 字节数组输出流
  3.  * 该类实现了将数据写入字节数组的输出流。 不需要指定目的地，因为在内存中，无法指定具体的空间大小，所以内部构造了一个缓冲区，缓冲区会随着写入的字节数自动增长。 数据可以使用toByteArray()和toString()从缓冲区中获取
  4.  *  * 1、创建源：内部维护
  5.  *  * 2、选择流：不关联源
  6.  *  * 3、写入操作:write():
  7.  *  * 4、释放资源：可以不用处理
  8.  */
  9. public class ByteArrayOutputStreamStudy01 {
  10.     public static void main(String[] args) {
  11.         //1、创建源
  12.         byte[]dest=null;
  13.         //2、选择流(新增方法)
  14.         ByteArrayOutputStream baos=null;
  15.         try {
  16.             baos=new ByteArrayOutputStream();
  17.             String msg="我是扒鸡我最棒！";
  18.             //字符-->字节（编码）
  19.             byte[] datas=msg.getBytes();
  20.             //3、写出操作
  21.             baos.write(datas,0,datas.length);
  22.             //刷新此输出流并强制任何缓冲的输出字节被写出。
  23.             baos.flush();
  24.             //获取数据
  25.             dest=baos.toByteArray();//创建一个新分配的字节数组。
  26.             System.out.println(dest.length+"--->"+new String(dest,0,baos.size()));
  27.         } catch (IOException e) {
  28.             e.printStackTrace();
  29.         }finally {
  30.                 try {
  31.                     //4、释放资源,不用处理
  32.                     if(null!=baos) {
  33.                         baos.close();
  34.                     }
  35.                 } catch (IOException e) {
  36.                     e.printStackTrace();
  37.                 }
  38.             }
  39.         }
  40.     }

字符流

read：字符输入流

特性

1、字符输入流的父类

2、数据单位为字符

子类

FileRead：文件字符输入流，只适用于字符文件

FileRead：文件字符输入流

  1. /**
  2.  * FileRead 文件字符输入流，只适用于字符文件
  3.  * 1、创建源
  4.  * 2、选择流
  5.  * 3、读取操作:    read(byte[] b):从该输入流读取最多 b.length个字节的数据到字节数组中（缓冲区），返回大小。
  6.  * 4、释放资源
  7.  */
  8. public class FileReadTest01 {
  9.     public static void main(String[] args) {
  10.         //1、创建源
  11.         File src=new File("test.txt");
  12.         //2、选择流
  13.         Reader reader=null;
  14.         try {
  15.             reader=new FileReader(src);
  16.             int temp;
  17.             //3、读取操作(分段读取)
  18.             char[]flush=new char[1024];//缓冲容器
  19.             int len=-1; //接受长度
  20.             while ((len=reader.read(flush))!=-1){
  21.                 //字符数组-->字符串
  22.                String str=new String(flush,0,len);
  23.                System.out.println(str);
  24.             }
  25.         } catch (FileNotFoundException e) {
  26.             e.printStackTrace();
  27.         } catch (IOException e) {
  28.             e.printStackTrace();
  29.         } finally {
  30.             //4、释放资源
  31.                 try {
  32.                     if(null!=reader) {
  33.                         reader.close();
  34.                     }
  35.                 } catch (IOException e) {
  36.                     e.printStackTrace();
  37.                 }
  38.             }
  39.         }
  40.     }

write：字符输出流

特性

1、字符输出流的父类

2、数据单位为字符(byte)

子类

FileWrite：文件字符输出流，通过字符的方式写入文本，仅适合字符文件

  1. /**
  2.  * FileWrite 文件字符输出流,只适用于字符文件
  3.  *  * 1、创建源
  4.  *  * 2、选择流
  5.  *  * 3、写入操作:write():
  6.  *  * 4、释放资源
  7.  */
  8. public class FileWriteStudy01 {
  9.     public static void main(String[] args) {
  10.         //1、创建源
  11.         File file=new File("paji.txt");
  12.         Writer writer=null;
  13.         try {
  14.             //2、选择流，非追加方式
  15.             writer=new FileWriter(file);
  16.             //2、追加方式
  17.             //os=new FileOutputStream(file,true);
  18.             String msg="我是扒鸡我最棒！";
  19.             String msg2="我最棒";
  20.             char[] datas=msg.toCharArray();
  21.             //3、写入操作
  22.             writer.write(datas,0,datas.length);
  23.             //3、写入方式二，直接写入字符串
  24.             writer.write(msg2);
  25.             //3、写入方式三，append追加方式
  26.             writer.append("dasd").append("fsdfds").append("fsafds");
  27.             //刷新此输出流并强制任何缓冲的输出字节被写出。
  28.             writer.flush();
  30.         } catch (FileNotFoundException e) {
  31.             e.printStackTrace();
  32.         } catch (IOException e) {
  33.             e.printStackTrace();
  34.         }finally {
  35.                 try {
  36.                     //4、释放资源
  37.                     if(null!=writer) {
  38.                         writer.close();
  39.                     }
  40.                 } catch (IOException e) {
  41.                     e.printStackTrace();
  42.                 }
  43.             }
  44.         }
  45.     }

文件拷贝Demo

  1. /**
  2.  * 文件的拷贝：输入流、输出流的结合
  3.  */
  4. public class FileCopy {
  5.     public static void main(String[] args) {
  6.         long t1=System.currentTimeMillis();
  7.         copyFile("G:\\学习相关\\javaweb学习\\jsp视频\\12_EL 表达式 （隐式对象）__rec.avi","C:\\Users\\tfp12\\Desktop\\spp.avi");
  8.         long t2=System.currentTimeMillis();
  9.         System.out.println(t2-t1);
  10.     }
  11.     public static void copyFile(String srcPath,String destPath){
  12.         File src=new File(srcPath);
  13.         File copying=new File(destPath);
  14.         InputStream is=null;
  15.         OutputStream os=null;
  16.         try {
  17.             int len=-1;
  18.             byte[]flush=new byte[1024];
  19.             is=new FileInputStream(src);
  20.             os=new FileOutputStream(copying);
  21.             while ((len=is.read(flush))!=-1){
  22.                 os.write(flush,0,len);
  23.                 os.flush();
  24.             }
  25.         } catch (FileNotFoundException e) {
  26.             e.printStackTrace();
  27.         } catch (IOException e) {
  28.             e.printStackTrace();
  29.         }finally {
  30.             //释放资源，先打开的后关闭
  31.             if(null!=os){
  32.                 try {
  33.                     os.close();
  34.                 } catch (IOException e) {
  35.                     e.printStackTrace();
  36.                 }
  37.             }if (null!=is){
  38.                 try {
  39.                     is.close();
  40.                 } catch (IOException e) {
  41.                     e.printStackTrace();
  42.                 }
  43.             }
  44.         }
  45.     }
  46. }
  1. /**
  2.  * @auther TongFangPing
  3.  * @date 2019/9/27 11:02.
  4.  * 文件（图片）的拷贝：
  5.  * 文件——>程序——>字节数组——>文件
  6.  */
  7. public class FileCopy02 {
  8.     public static void main(String[] args) throws IOException {
  9.         //图片转成字节数组
  10.         byte[]datas=fileToByteArray("super.jpg");
  11.         System.out.println(datas.length);
  12.         byteArrayToFile(datas,"super2.jpg");
  13. //        File f=new File("copysuper.jpg");
  14. //        f.delete();
  15.     }
  17.     /**
  18.      * 1、图片到字节数组:
  19.      * 1、图片到程序：FileInputStream
  20.      * 2、程序到字节数组：ByteArrayOutputStream
  21.      */
  22.     public static byte[] fileToByteArray(String path) {
  23.         //创建源与目的地
  24.         File src = new File(path);
  25.         byte[] dest = null;
  26.         //选择流
  27.         InputStream is = null;
  28.         ByteArrayOutputStream baos = null;
  29.         try {
  30.             is = new FileInputStream(src);
  31.             baos = new ByteArrayOutputStream();
  32.             //操作
  33.             byte[] flush = new byte[1024 * 10];
  34.             int len = -1;
  35.             while ((len = is.read(flush)) != -1) {
  36.                 baos.write(flush, 0, len);
  37.             }
  38.             baos.flush();
  39.             return baos.toByteArray();
  40.         } catch (FileNotFoundException e) {
  41.             e.printStackTrace();
  42.         } catch (IOException e) {
  43.             e.printStackTrace();
  44.         }if(is!=null){
  45.             try {
  46.                 is.close();
  47.             } catch (IOException e) {
  48.                 e.printStackTrace();
  49.             }
  50.         }
  51.             return null;
  52.     }
  55.     /**
  56.      * 1、字节数组到文件
  57.      *      1、字节数组到程序:ByteArrayInputStream
  58.      *      2、程序到文件:FileOutputStream
  59.      */
  60.     public static void byteArrayToFile(byte[]src,String filePath){
  61.         File dest=new File(filePath);
  62.         InputStream is=null;
  63.         OutputStream os=null;
  64.         is=new ByteArrayInputStream(src);
  65.         try {
  66.             os=new FileOutputStream(dest);
  67.             int len=-1;
  68.             byte[]flush=new byte[10];
  69.             while ((len=is.read(flush))!=-1){
  70.                 os.write(flush,0,len);
  71.             }
  72.             os.flush();
  73.         } catch (FileNotFoundException e) {
  74.             e.printStackTrace();
  75.         } catch (IOException e) {
  76.             e.printStackTrace();
  77.         }
  78.         if(os!=null){
  79.             try {
  80.                 os.close();
  81.             } catch (IOException e) {
  82.                 e.printStackTrace();
  83.             }
  84.         }
  86.     }
  88. }

自定义FileUtil工具类

  1. /**
  2.  * @auther TongFangPing
  3.  * @date 2019/9/27 13:50.
  4.  * 封装拷贝
  5.  * 封装释放
  6.  */
  7. public class FileUtil {
  8.     public static void main(String[] args) {
  9.         //文件到文件
  10.         try {
  11.             InputStream is=new FileInputStream("paji.txt");
  12.             OutputStream os=new FileOutputStream("paji1号.txt");
  13.             copyFile(is,os);
  14.         } catch (IOException e) {
  15.             e.printStackTrace();
  16.         }
  17.         //文件到字节数组中
  18.         byte[]datas=null;
  19.         try {
  20.             InputStream is=new FileInputStream("super.jpg");
  21.             ByteArrayOutputStream os=new ByteArrayOutputStream();
  22.             copyFile(is,os);
  23.             datas=os.toByteArray();
  24.             System.out.println(datas.length);
  25.         } catch (IOException e) {
  26.             e.printStackTrace();
  27.         }
  28.         //字节数组到文件
  29.         try {
  30.             InputStream is=new ByteArrayInputStream(datas);
  31.             OutputStream os=new FileOutputStream("p-copy.png");
  32.             copyFile(is,os);
  33.         } catch (IOException e) {
  34.             e.printStackTrace();
  35.         }
  37.     }
  39.     /**
  40.      * 对接输入输出流
  41.      * @param is
  42.      * @param os
  43.      */
  44.     public static void copyFile(InputStream is,OutputStream os){
  45.         try {
  46.             int len=-1;
  47.             byte[]flush=new byte[1024];
  48.             while ((len=is.read(flush))!=-1){
  49.                 os.write(flush,0,len);
  50.                 os.flush();
  51.             }
  52.         } catch (FileNotFoundException e) {
  53.             e.printStackTrace();
  54.         } catch (IOException e) {
  55.             e.printStackTrace();
  56.         }finally {
  57.             //释放资源，先打开的后关闭
  58.             close(is,os);
  59.         }
  60.     }
  62.     /**
  63.      * 释放资源
  64.      * @param is
  65.      * @param os
  66.      */
  67.     public static void close(InputStream is,OutputStream os){
  68.         if(null!=os){
  69.             try {
  70.                 os.close();
  71.             } catch (IOException e) {
  72.                 e.printStackTrace();
  73.             }
  74.         }if (null!=is){
  75.             try {
  76.                 is.close();
  77.             } catch (IOException e) {
  78.                 e.printStackTrace();
  79.             }
  80.         }
  81.     }
  82. }

try…with…resource方式

将输入输出流的声明部分放入try()中,删除finally部分代码

  1. /**
  2.  * 资源的释放：try...with...resource
  3.  * 文件的拷贝：输入流、输出流的结合
  4.  */
  5. public class TryWithResource {
  6.     public static void main(String[] args) {
  7.         copyFile("H:\\迅雷下载\\BANDIZIP-SETUP.EXE","C:\\Users\\tfp12\\Desktop\\sp.exe");
  8.     }
  9.     public static void copyFile(String srcPath,String destPath){
  10.         File src=new File(srcPath);
  11.         File copying=new File(destPath);
  12. //        InputStream is=null;
  13. //        OutputStream os=null;
  14.         //资源释放，没有finally
  15.         try(InputStream is=new FileInputStream(src);
  16.             OutputStream os=new FileOutputStream(copying)) {
  17.             int len=-1;
  18.             byte[]flush=new byte[1024];
  19. //            is=new FileInputStream(src);
  20. //            os=new FileOutputStream(copying);
  21.             while ((len=is.read(flush))!=-1){
  22.                 os.write(flush,0,len);
  23.                 os.flush();
  24.             }
  25.         } catch (FileNotFoundException e) {
  26.             e.printStackTrace();
  27.         } catch (IOException e) {
  28.             e.printStackTrace();
  29.         }
  30.     }
  31. }