首页 > 代码库 > 第11篇-JAVA IO

第11篇-JAVA IO

2024-11-25 08:21:39   203人阅读

第11篇-JAVA IO

  • 每篇一句 ：不要在失败时才想起别人的忠告，不要在失去之后才想起珍惜

  • 初学心得： 环境越艰难，越会出聪明人

  • (笔者：JEEP/711)[JAVA笔记 | 时间:2017-04-17| JAVA IO流 ]

1.流概念

流是指一连串流动的字符,是以先进先出方式发送信息的通道 
即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作

2.JAVA IO流

Java的IO流是实现输入/输出的基础，它可以方便地实现数据的输入/输出操作

Java中把不同的输入/输出源（键盘、文件、网络连接等）抽象表述为“流”（stream），通过流的方式允许Java程序使用相同的方式来访问不同的输入/输出源。stream是从起源（source）到接收（sink）的有序数据 
Java把所有传统的个流类型（类或抽象类）都放在java.io包中，用以实现输入/输出功能

3.JAVA IO流分类

按流向来分类：可以分为输入流和输出流：

  • 输入流：只能从中读取数据，而不能向其写出数据

  • 输出流：只能向其写出数据，而不能从中读取数据

字节流和字符流： 
按照流的角色分，可以分为节点流和处理流

IO流的四个基类： 
Java把所有设备里的有序数据抽象成流模型简化了输入/输出的处理 
Java的IO流共涉及到40多个类，这些类看上去芜杂而凌乱，但实际上是非常规则、而且彼此之间存在非常紧密的联系 
Java的IO流的40多个类都是从4个抽象基类派生出来的：

  • InputStream/Reader：所有输入流的基类，前者是输入字节流，后者是输入字符。

  • OutputStream/Writer：所有输出流的基类，前者是输出字节流，后者是输出字符流

- 输入流：InputStream和Reader是所有输入流的基类，它们都是两个抽象类，本身并不能创建实例来执行输入，但它们将所谓所有输入流的模板，所以它们的方法是所有输入流都可使用的方法

  • int read()：从输入流中读取单个字节（相当于从图15.5所示水管中取出一滴水），返回所读取的字节数据（字节数据可直接转换为int类型）

  • int read(byte[]/char[] b)：从输入流中读取最多b.length个字节的数据，并将其存储在字节数组b中，返回实际读取的字节数

  • int read(byte[]/char[] b, int off, int len)：从输入流中读取最多len字节的数据，并将其存储在数组 b 中，放入b数组中时，并不是从数组起点开始，而是从off位置开始，返回实际读取的字节数

- 输出流：OutputStream和Writer也非常相似，它们采用模型来执行输出，两个流都提供了如下三个方法

  • void write(int c)：将指定的字节/字符输出到输出流中，其中c既可以代表字节，也可以代表字符

  • void write(byte[]/char[] buf)：将字节数组/字符数组中的数据输出到指定输出流中

  • void write(char[] cbuf, int off, int len)：将字节数组/字符数组中从off位置开始，长度为len的字节/字符输出到输出流中

处理流的用法：

  • 使用处理流来包装节点流，程序通过处理流来执行输入/输出功能，让节点流与底层的I/O设备、文件交互

  • 程序使用处理流非常简单，通常只需要在创建处理流时传入一个节点流作为构造器参数即可，这样创建的处理流就是包装了该节点流的处理流

4.流的操作规律

  • 1、明确源和目的。 
    数据源：就是需要读取，可以使用两个体系：InputStream、Reader； 
    数据汇：就是需要写入，可以使用两个体系：OutputStream、Writer；

  • 2、操作的数据是否是纯文本数据？ 
    如果是：数据源：Reader 
    数据汇：Writer 
    如果不是：数据源：InputStream 
    数据汇：OutputStream

  • 3、虽然确定了一个体系，但是该体系中有太多的对象，到底用哪个呢？ 
    明确操作的数据设备。 
    数据源对应的设备：硬盘(File)，内存(数组)，键盘(System.in) 
    数据汇对应的设备：硬盘(File)，内存(数组)，控制台(System.out)

  • 4、需要在基本操作上附加其他功能吗？比如缓冲，如果需要就进行装饰

5.java.io包

文本文件的读写：

  • 用FileInputStream读文件

  • 用FileOutputStream写文件

  • 用BufferedReader读文本文件

  • 用BufferedWriter写文本文件

二进制文件的读写：

  • DataOutputStream

  • DataInputStream

6.字节流文件拷贝

1.public class IoTest {
2.  public static void main(String[] args) throws IOException,InterruptedException {
3.      String path = "c:\\b.txt";
4.      readFile(path);
5.  }
6.  private static void readFile(String path) {
7.      FileInputStream fis = null;
8.      try {
9.          fis = new FileInputStream(path);
10.          byte[] byt = new byte[1024];
11.          int len = fis.read(byt);
12.          System.out.println(new String(byt, 0, len));
13.      } catch (IOException e) {
14.          // 抛出运行时异常
15.          throw new RuntimeException(e);
16.      } finally {
17.          // 把close方法放入finally中保证一定会执行
18.          // 先判断是否空指针
19.          if (fis != null) {
20.              try {
21.                  fis.close();
22.              } catch (Exception e) {
23.                  throw new RuntimeException(e);
24.              }
25.          }
26.      }
27.  }
28.}
1.public static void copyFile(String srcPath, String destPath) {
2.      FileInputStream fis = null;
3.      FileOutputStream fos = null;
4.      try {
5.          fis = new FileInputStream(srcPath);
6.          fos = new FileOutputStream(destPath);
7.          byte[] byt = new byte[1024 * 1024];
8.          int len = 0;
9.          while ((len = fis.read(byt)) != -1) {
10.              fos.write(byt, 0, len);
11.          }
12.      } catch (IOException e) {
13.          throw new RuntimeException(e);
14.      } finally {
15.          try {
16.              if (fis != null) {
17.                  fis.close();
18.              }
19.          } catch (IOException e) {
20.              throw new RuntimeException(e);
21.          } finally {
22.              if (fos != null) {
23.                  try {
24.                      fos.close();
25.                  } catch (IOException e) {
26.                      throw new RuntimeException(e);
27.                  }
28.              }
29.          }
30.      }
31.  }

7.字符流文件拷贝

1.public static void main(String[] args) throws Exception {
2.      String path1 = "c:/a.txt";
3.      String path2 = "c:/b.txt";
4.      copyFile2(path1, path2);
5.  }
6./**
7.   * 使用字符流拷贝文件，有完善的异常处理
8.   */
9.public static void copyFile2(String path1, String path2) {
10.      Reader reader = null;
11.      Writer writer = null;
12.      try {
13.          // 打开流
14.          reader = new FileReader(path1);
15.          writer = new FileWriter(path2);
16.          // 进行拷贝
17.          int ch = -1;
18.          while ((ch = reader.read()) != -1) {
19.              writer.write(ch);
20.          }
21.      } catch (Exception e) {
22.          throw new RuntimeException(e);
23.      } finally {
24.          // 关闭流，注意一定要能执行到close()方法，所以都要放到finally代码块中
25.          try {
26.              if (reader != null) {
27.                  reader.close();
28.              }
29.          } catch (Exception e) {
30.              throw new RuntimeException(e);
31.          } finally {
32.              try {
33.                  if (writer != null) {
34.                      writer.close();
35.                  }
36.              } catch (Exception e) {
37.                  throw new RuntimeException(e);
38.              }
39.          }
40.      }
41.  }

初学(JAVA IO流 高级阶段) 难点: ★★★★★

希望每一篇文章都能够对读者们提供帮助与提升，这乃是每一位笔者的初衷

感谢您的阅读 欢迎您的留言与建议

  • FaceBook：JEEP SevenEleven

  • Twitter：@JEEP7ll

  • 新浪官方微博: @JEEP-711

  • Github博客: https://github.com/jeep711/jeep711.github.io

  • Blog Garden：http://www.cnblogs.com/JEEP711/

  • W3C/Blog：http://www.w3cschool.cn/jeep711blog/

  • CSDN/Blog：http://blog.csdn.net/jeep911

  • 51CTO/Blog：http://jeep711.blog.51cto.com/

  • 码云：http://git.oschina.net/JEEP711/jeep711.github.io

  • 邮箱: jeep711@qq.com，JEEP-711@outlook.com



本文出自 “JEEP711” 博客，请务必保留此出处http://jeep711.blog.51cto.com/12970787/1955574

第11篇-JAVA IO


联系
我们