I/O流技术

最新推荐文章于 2021-03-21 17:53:40 发布

渔饵

最新推荐文章于 2021-03-21 17:53:40 发布

阅读量229

点赞数

本文链接：https://blog.csdn.net/mradxddzym/article/details/46235437

版权

IO流

  |--字节流
   |--字节输入流
    InputStream
     int read():一次读取一个字节
     int read(byte[] bys):一次读取一个字节数组

     |--FileInputStream
     |--BufferedInputStream
   |--字节输出流
    OutputStream
     void write(int by):一次写一个字节
     void write(byte[] bys,int index,int len):一次写一个字节数组的一部分

     |--FileOutputStream
     |--BufferedOutputStream
  |--字符流
   |--字符输入流
    Reader
     int read():一次读取一个字符
     int read(char[] chs):一次读取一个字符数组

     |--InputStreamReader
      |--FileReader
     |--BufferedReader
      String readLine():一次读取一个字符串
   |--字符输出流
    Writer
     void write(int ch):一次写一个字符
     void write(char[] chs,int index,int len):一次写一个字符数组的一部分

     |--OutputStreamWriter
      |--FileWriter
     |--BufferedWriter
      void newLine():写一个换行符

      void write(String line):一次写一个字符串
IO流的分类：
  流向：
   输入流读取数据
   输出流写出数据
  数据类型：
   字节流
    字节输入流读取数据 InputStream
    字节输出流写出数据 OutputStream
   字符流
    字符输入流读取数据 Reader
    字符输出流写出数据 Writer
  注意：一般我们在探讨IO流的时候，如果没有明确说明按哪种分类来说，默认情况下是按照数据类型来分的。
注意：每种基类的子类都是以父类名作为后缀名。
  XxxOutputStream
  XxxInputStream
  XxxReader
  XxxWriter
FileOutputStream的构造方法：
   FileOutputStream(File file)
  FileOutputStream(String name)

字节输出流操作步骤：
   A:创建字节输出流对象
    创建字节输出流对象了做了几件事情：
     调用系统功能去创建文件
     创建fos对象
     把fos对象指向这个文件
   B:写数据
   C:释放资源
   关闭此文件输出流并释放与此流有关的所有系统资源。
   为什么一定要close()
    A:让流对象变成垃圾，这样就可以被垃圾回收器回收了
    B:通知系统去释放跟该文件相关的资源
public void write(int b):写一个字节
public void write(byte[] b):写一个字节数组
public void write(byte[] b,int off,int len):写一个字节数组的一部分
如何实现数据的换行
  为什么现在没有换行呢?因为你值写了字节数据，并没有写入换行符号。
  刚才我们看到了有写文本文件打开是可以的，通过windows自带的那个不行，为什么呢?
  因为不同的系统针对不同的换行符号识别是不一样的?
  windows:\r\n
   linux:\n
  Mac:\r
  而一些常见的个高级记事本，是可以识别任意换行符号的。
如何实现数据的追加写入?
  用构造方法带第二个参数是true的情况即可
字节输入流操作步骤：
A:创建字节输入流对象
B:调用read()方法读取数据，并把数据显示在控制台
C:释放资源
读取数据的方式：
A:int read():一次读取一个字节
B:int read(byte[] b):一次读取一个字节数组：返回值其实是实际读取的字节个数。
我们每次获取到一个字节数据，就把该字节数据转换为了字符数据，然后输出到控制台。
而这一次通过IO流读取数据，写到文本文件，你读取一个字节，我就写入一个字节，没有做任何的转换，它会自己做转换。
计算机是如何识别什么时候该把两个字节转换为一个中文
在计算机中中文的存储分两个字节：
  第一个字节肯定是负数。
  第二个字节常见的是负数，可能有正数。
注意：虽然我们有两种方式可以读取，但是，请注意，这两种方式针对同一个对象在一个代码中只能使用一个。
通过定义数组的方式确实比以前一次读取一个字节的方式快很多，所以，看来有一个缓冲区还是非常好的。
既然是这样的话，那么，java开始在设计的时候，它也考虑到了这个问题，就专门提供了带缓冲区的字节类。
这种类被称为：缓冲区类(高效类)
写数据：BufferedOutputStream
读数据：BufferedInputStream
构造方法可以指定缓冲区的大小，但是我们一般用不上，因为默认缓冲区大小就足够了。
为什么不传递一个具体的文件或者文件路径，而是传递一个OutputStream对象呢?
原因很简单，字节缓冲区流仅仅提供缓冲区，为高效而设计的。但是呢，真正的读写操作还得靠基本的流对象实现。
String(byte[] bytes, String charsetName):通过指定的字符集解码字节数组
byte[] getBytes(String charsetName):使用指定的字符集合把字符串编码为字节数组
编码:把看得懂的变成看不懂的
String -- byte[]
解码:把看不懂的变成看得懂的
byte[] -- String
编码问题简单，只要编码解码的格式是一致的。
InputStreamReader(InputStream is):用默认的编码读取数据
InputStreamReader(InputStream is,String charsetName):用指定的编码读取数据
InputStreamReader的方法：
int read():一次读取一个字符
int read(char[] chs):一次读取一个字符数组
OutputStreamWriter(OutputStream out):根据默认编码把字节流的数据转换为字符流
OutputStreamWriter(OutputStream out,String charsetName):根据指定编码把字节流数据转换为字符流
OutputStreamWriter的方法：
public void write(int c):写一个字符
public void write(char[] cbuf):写一个字符数组
public void write(char[] cbuf,int off,int len):写一个字符数组的一部分
public void write(String str):写一个字符串
public void write(String str,int off,int len):写一个字符串的一部分
把字节流转换为字符流。
字符流 = 字节流 +编码表。
close()和flush()的区别?
A:close()关闭流对象，但是先刷新一次缓冲区。关闭之后，流对象不可以继续再使用了。
B:flush()仅仅刷新缓冲区,刷新之后，流对象还可以继续使用。
字符缓冲流的特殊方法：
BufferedWriter:字符缓冲输出流
   public void newLine():根据系统来决定换行符
BufferedReader:字符缓冲输入流
  public String readLine()：一次读取一行数据
  包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null
案例一：复制文件a.txt内容复制到另一个目录下的b.txt中(一次一个字节)

public class CopyFileDemoOne {
 public static void main(String[] args) throws IOException {
  // 封装数据源
  FileInputStream fis = new FileInputStream("a.txt");
  // 封装目的地
  FileOutputStream fos = new FileOutputStream("b.txt");
  int by = 0;
  while ((by = fis.read()) != -1) {
   fos.write(by);
  }
  // 释放资源(先关谁都行)
  fos.close();
  fis.close();
 }
}

案例二：复制文件a.txt内容复制到另一个目录下的b.txt中(一次读取一个数组长度)

public class CopyFileDemoTwo {
 public static void main(String[] args) throws IOException {
  // 封装数据源
  FileInputStream fis = new FileInputStream("a.txt");
  // 封装目的地
  FileOutputStream fos = new FileOutputStream("b.txt");
  byte [] bys = new byte[1024];
  int len = 0
  while ((len = fis.read(bys)) != -1) {
   fos.write(by,0,len);
  }
  // 释放资源(先关谁都行)
  fos.close();
  fis.close();
 }
}

案例三：把e:\\海贼王700.mp4复制到当前项目目录下的copy.mp4中

字节流四种方式复制文件：
基本字节流一次读写一个字节： 共耗时：117235毫秒
基本字节流一次读写一个字节数组： 共耗时：156毫秒
高效字节流一次读写一个字节： 共耗时：1141毫秒
高效字节流一次读写一个字节数组： 共耗时：47毫秒
public class CopyMp4Demo {
 public static void main(String[] args) throws IOException {
  long start = System.currentTimeMillis();
  method1("e:\\海贼王700.mp4", "copy1.mp4");
  method2("e:\\海贼王700.mp4", "copy2.mp4");
  method3("e:\\海贼王700.mp4", "copy3.mp4");
  method4("e:\\海贼王700.mp4", "copy4.mp4");
  long end = System.currentTimeMillis();
  System.out.println("共耗时：" + (end - start) + "毫秒");
 }
 // 高效字节流一次读写一个字节数组：
 public static void method4(String srcString, String destString)
   throws IOException {
  BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
    srcString));
  BufferedOutputStream bos = new BufferedOutputStream(
    new FileOutputStream(destString));
  byte[] bys = new byte[1024];
  int len = 0;
  while ((len = bis.read(bys)) != -1) {
   bos.write(bys, 0, len);
  }
  bos.close();
  bis.close();
 }
 // 高效字节流一次读写一个字节：
 public static void method3(String srcString, String destString)
   throws IOException {
  BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
    srcString));
  BufferedOutputStream bos = new BufferedOutputStream(
    new FileOutputStream(destString));
  int by = 0;
  while ((by = bis.read()) != -1) {
   bos.write(by);
  }
  bos.close();
  bis.close();
 }
 // 基本字节流一次读写一个字节数组
 public static void method2(String srcString, String destString)
   throws IOException {
  FileInputStream fis = new FileInputStream(srcString);
  FileOutputStream fos = new FileOutputStream(destString);
  byte[] bys = new byte[1024];
  int len = 0;
  while ((len = fis.read(bys)) != -1) {
   fos.write(bys, 0, len);
  }
  fos.close();
  fis.close();
 }
 // 基本字节流一次读写一个字节
 public static void method1(String srcString, String destString)
   throws IOException {
  FileInputStream fis = new FileInputStream(srcString);
  FileOutputStream fos = new FileOutputStream(destString);
  int by = 0;
  while ((by = fis.read()) != -1) {
   fos.write(by);
  }
  fos.close();
  fis.close();
 }
}

案例四：复制文本文件

分析：
  复制数据，如果我们知道用记事本打开并能够读懂，就用字符流，否则用字节流。
  通过该原理，我们知道我们应该采用字符流更方便一些。
  而字符流有5种方式，所以做这个题目我们有5种方式。推荐掌握第5种。
数据源：
  c:\\a.txt -- FileReader -- BufferdReader
目的地：
  d:\\b.txt -- FileWriter -- BufferedWriter
public class CopyFileDemo {
 public static void main(String[] args) throws IOException {
  String srcString = "c:\\a.txt";
  String destString = "d:\\b.txt";
  method1(srcString, destString);
  method2(srcString, destString);
  method3(srcString, destString);
  method4(srcString, destString);
  method5(srcString, destString);
 }
 // 字符缓冲流一次读写一个字符串
 private static void method5(String srcString, String destString)
   throws IOException {
  BufferedReader br = new BufferedReader(new FileReader(srcString));
  BufferedWriter bw = new BufferedWriter(new FileWriter(destString));
  String line = null;
  while ((line = br.readLine()) != null) {
   bw.write(line);
   bw.newLine();
   bw.flush();
  }
  bw.close();
  br.close();
 }
 // 字符缓冲流一次读写一个字符数组
 private static void method4(String srcString, String destString)
   throws IOException {
  BufferedReader br = new BufferedReader(new FileReader(srcString));
  BufferedWriter bw = new BufferedWriter(new FileWriter(destString));
  char[] chs = new char[1024];
  int len = 0;
  while ((len = br.read(chs)) != -1) {
   bw.write(chs, 0, len);
  }
  bw.close();
  br.close();
 }
 // 字符缓冲流一次读写一个字符
 private static void method3(String srcString, String destString)
   throws IOException {
  BufferedReader br = new BufferedReader(new FileReader(srcString));
  BufferedWriter bw = new BufferedWriter(new FileWriter(destString));
  int ch = 0;
  while ((ch = br.read()) != -1) {
   bw.write(ch);
  }
  bw.close();
  br.close();
 }
 // 基本字符流一次读写一个字符数组
 private static void method2(String srcString, String destString)
   throws IOException {
  FileReader fr = new FileReader(srcString);
  FileWriter fw = new FileWriter(destString);
  char[] chs = new char[1024];
  int len = 0;
  while ((len = fr.read(chs)) != -1) {
   fw.write(chs, 0, len);
  }
  fw.close();
  fr.close();
 }
 // 基本字符流一次读写一个字符
 private static void method1(String srcString, String destString)
   throws IOException {
  FileReader fr = new FileReader(srcString);
  FileWriter fw = new FileWriter(destString);
  int ch = 0;
  while ((ch = fr.read()) != -1) {
   fw.write(ch);
  }
  fw.close();
  fr.close();
 }
}