IO流

一、I/O流：

字节流基类：InputStream(读) OutputStream (写) ​ 字符流基类：Reader (读) Writer(写)

二、 FileOutputStream

（OutputStream 的子类，OutputStream 为抽象类，）

2.1、字节输出流操作步骤

A、创建字节输出流对象

B、调用write()方法，写入数据

        public void write(int b):写一个字节
        public void write(byte[] b):写一个字节数组
        public void write(byte[] b,int off,int len):写一个字节数组的一部分，从off开始，长度为len

C、释放资源

2.2、构造方法：

1.FileOutputStream(File file)

2.FileOutputStream(String name)

3.FileOutputStream(String name, true); 用于追加写入数据，否则会一直从头写入

4.FileOutputStream(File file, true);

2.3、创建文本并写入数据：

 File file = new File("D:\\a.txt");
​
//写入数据
 FileOutputStream fileOutputStream = new FileOutputStream(file);
 fileOutputStream.write("hello,I/O".getBytes());
//fileOutputStream.write(97);  写入的值为a，底层二进制数据   -- 通过记事本打开 -- 找97对应的字符值 -- a
​
//释放资源
//关闭此文件输出流并释放与此流有关的所有系统资源
 fileOutputStream.close();

思考：

FileOutputStream fileOutputStream = new FileOutputStream(file);

创建字节输出流对象做了几件事：

A：调用系统功能去创建文件

B：创建fileOutputStream对象

C：把fileOutputStream对象指向这个文件

为什么一定要close()?

A:让流对象变成垃圾，可以被垃圾回收器回收；

B:通知系统释放跟该文件相关的资源

2.4常见问题

如何实现数据的换行?

写入换行符号；

不同的系统针对不同的换行符号识别是不一样的（高级记事本可自动识别）：

windows:\r\n

linux:\n

Mac:\r

        File file = new File("D:\\a.txt");
​
        FileOutputStream fos = new FileOutputStream(file);
​
        // 写数据
        for (int x = 0; x < 10; x++) {
            fos.write(("hello" + x).getBytes());
            fos.write("\r\n".getBytes());
        }
        
        fos.close();

如何实现追加写入？

用构造方法带第二个参数是true的情况即可

        File file = new File("D:\\a.txt");
        //追加写入数据
        FileOutputStream fos = new FileOutputStream(file, true);
​
        // 写数据
        for (int x = 0; x < 10; x++) {
            fos.write(("hello" + x).getBytes());
            fos.write("\r\n".getBytes());
        }
​
        fos.close();

 

三、 FileInputStream

字节流读取数据

3.1字节输入流操作步骤

A:创建字节输入流对象

B:调用read()方法读取数据，并把数据显示在控制台

C:释放资源

3.2构造方法

​
FileInputStream(File file)
FileInputStream(String name)     

 

3.2读取数据的方式：

A: int read() 一次读取下一个数据字节；如果已到达文件末尾，则返回 -1。

B: int read (byte[ ] b ) 一次读取一个字节数组，比read() 快，返回值其实是实际读取的字节个数；数组中元素存储的是字母对应的数值

 

一次读取一个字节

        FileInputStream fis = new FileInputStream("fis.txt");
​
        int read = fis.read();
        System.out.println(read);  //读取一个字节  注意：读取的如果是字母，则会被转换为数字，如a -->97;   换行符也会被读取，如 \n   占一个字节
        System.out.println((char)read); //转换数据类型就可以变为字母
​
        //循环读取所有数据
        int by = 0;
        // 读取，赋值，判断
        while ((by = fis.read()) != -1) {
            System.out.print((char) by);
        }
​
        fis.close();

 

一次读取一个字节数组

        FileInputStream fis = new FileInputStream("fis.txt");
​
        // 数组的长度一般是1024或者1024的整数倍
        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = fis.read(bys)) != -1) {
            System.out.print(new String(bys, 0, len));
        }
        
        fis.close();

 

3.4复制文本文件/视频/图片

// 封装数据源
    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();

3.5 计算机如何识别什么时候该把两个字节转换为一个中文

在计算机中中文的存储分两个字节：

• 第一个字节肯定是负数。

• 第二个字节常见的是负数，可能有正数。但是没影响。

    //String s = "abcde";
    // // [97, 98, 99, 100, 101]
​
    String s = "我爱你中国";
    // [-50, -46, -80, -82, -60, -29, -42, -48, -71, -6]
​
    byte[] bys = s.getBytes();
    System.out.println(Arrays.toString(bys));

 

 

四、字节缓冲输入流和字节缓冲输出流（也称包装流、高效字节流）

写数据：BufferedOutputStream 缓冲输出流

读数据：BufferedInputStream 缓冲输入流

构造方法可以指定缓冲区的大小，但是我们一般用不上，因为默认缓冲区大小就足够了。

 

计算机访问外部设备非常耗时。访问外存的频率越高，造成CPU闲置的概率就越大。

为了减少访问外存的次数，应该在一次对外设的访问中，读写更多的数据。

为此，除了程序和流节点间交换数据必需的读写机制外，还应该增加缓冲机制。

缓冲流就是每一个数据流分配一个缓冲区，一个缓冲区就是一个临时存储数据的内存。

这样可以减少访问硬盘的次数,提高传输效率。

BufferedInputStream:当向缓冲流写入数据时候，数据先写到缓冲区，待缓冲区写满后，系统一次性将数据发送给输出设备。

BufferedOutputStream :当从向缓冲流读取数据时候，系统先从缓冲区读出数据，待缓冲区为空时，系统再从输入设备读取数据到缓冲区。

 

4.1写入数据

    // FileOutputStream fos = new FileOutputStream("bos.txt");
    // BufferedOutputStream bos = new BufferedOutputStream(fos);
    // 简单写法
    BufferedOutputStream bos = new BufferedOutputStream(
        new FileOutputStream("bos.txt"));
​
    // 写数据
    bos.write("hello".getBytes());
​
    // 释放资源
    bos.close();

思考：为什么不传递一个具体的文件或者文件路径，而是传递一个OutputStream对象呢?

原因很简单，字节缓冲区流仅仅提供缓冲区，为高效而设计的。但是呢，真正的读写操作还得靠基本的流对象实现。

 

4.2读取数据

两种方式

 BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bos.txt"));
    //第一种
    // 读取数据
    // int by = 0;
    // while ((by = bis.read()) != -1) {
    // System.out.print((char) by);
    // }
    // System.out.println("---------");
​
    //第二种
    byte[] bys = new byte[1024];
    int len = 0;
    while ((len = bis.read(bys)) != -1) {
      System.out.print(new String(bys, 0, len));
    }
​
    // 释放资源
    bis.close();

注意：虽然我们有两种方式可以读取，但是，请注意，这两种方式针对同一个对象在一个代码中只能使用一个。如果都使用，也只会读取一个，因为read方法已执行到数据末尾。

 

五、字符流

字符流 = 字节流+编码表

5.1 String类中的编码和解码

构造方法 不设置则为使用平台的默认字符集解码，windows为GBK

String(byte[] bytes, String charsetName):通过指定的字符集解码字节数组

方法：不设置则为使用平台的默认字符集解码, windows为GBK

byte[] getBytes(String charsetName):使用指定的字符集合把字符串编码为字节数组

 

编码:把看得懂的变成看不懂的：String -- byte[]

解码:把看不懂的变成看得懂的：byte[] -- String

 

需要保证 编码和解码的格式是一样的，不设置则为使用平台的默认字符集解码

    String s = "你好";
​
    // String -- byte[]
    byte[] bys = s.getBytes(); // [-60, -29, -70, -61]
    // byte[] bys = s.getBytes("GBK");// [-60, -29, -70, -61]
    // byte[] bys = s.getBytes("UTF-8");// [-28, -67, -96, -27, -91, -67]
    System.out.println(Arrays.toString(bys));
​
    // byte[] -- String
    String ss = new String(bys); // 你好
    // String ss = new String(bys, "GBK"); // 你好
    // String ss = new String(bys, "UTF-8"); // ???
    System.out.println(ss);

 

5.2 转换流

OutputStreamWriter 和 InputStreamReader

OutputStreamWriter(OutputStream out):根据默认编码把字节流的数据转换为字符流

OutputStreamWriter(OutputStream out,String charsetName):根据指定编码把字节流数据转换为字符流

 

InputStreamReader(InputStream is):用默认的编码读取数据

InputStreamReader(InputStream is,String charsetName):用指定的编码读取数据

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

 

编码

// 创建对象
    // OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
    // "osw.txt")); // 默认GBK
    // OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
    // "osw.txt"), "GBK"); // 指定GBK
    OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
        "osw.txt"), "UTF-8"); // 指定UTF-8
    // 写数据
    osw.write("中国");
​
    // 释放资源
    osw.close();

 

解码

// 创建对象
    // InputStreamReader isr = new InputStreamReader(new FileInputStream(
    // "osw.txt"));
​
    // InputStreamReader isr = new InputStreamReader(new FileInputStream(
    // "osw.txt"), "GBK");
​
    InputStreamReader isr = new InputStreamReader(new FileInputStream(
        "osw.txt"), "UTF-8");
​
    // 读取数据
    // 一次读取一个字符
    int ch = 0;
    while ((ch = isr.read()) != -1) {
      System.out.print((char) ch);
    }
​
    // 释放资源
    isr.close();

5.2.1 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):写一个字符串的一部分

    // 创建对象
    OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
        "osw2.txt"));
​
    // 写数据
        public void write(int c);//写一个字符
        osw.write('a');
        osw.write(97);
    // 为什么数据没有进去呢?
    // 原因是：字符 = 2字节
    // 文件中数据存储的基本单位是字节。
    //如果没有关闭流close（），则需要刷新缓冲区
    osw.flush();//也可不写
    // 释放资源
    osw.close();

 

面试题：close()和flush()的区别?

A:close()关闭流对象，但是先刷新一次缓冲区。关闭之后，流对象不可以继续再使用了。

B:flush()仅仅刷新缓冲区,刷新之后，流对象还可以继续使用。

 

5.2.2 InputStreamReader

方法

int read():一次读取一个字符

int read(char[] chs):一次读取一个字符数组

    // 创建对象
    InputStreamReader isr = new InputStreamReader(new FileInputStream(
        "StringDemo.java"));
​
    // 一次读取一个字符
    // int ch = 0;
    // while ((ch = isr.read()) != -1) {
    // System.out.print((char) ch);
    // }
​
    // 一次读取一个字符数组
    char[] chs = new char[1024];
    int len = 0;
    while ((len = isr.read(chs)) != -1) {
      System.out.print(new String(chs, 0, len));
    }
​
    // 释放资源
    isr.close();

 

5.2.3 字符流复制文本文件

  // 封装数据源
    InputStreamReader isr = new InputStreamReader(new FileInputStream(
        "a.txt"));
    // 封装目的地
    OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
        "b.txt"));
​
    // 读写数据
    // 方式1
    // int ch = 0;
    // while ((ch = isr.read()) != -1) {
    // osw.write(ch);
    // }
​
    // 方式2
    char[] chs = new char[1024];
    int len = 0;
    while ((len = isr.read(chs)) != -1) {
      osw.write(chs, 0, len);
      // osw.flush();
    }
​
    // 释放资源
    osw.close();
    isr.close();

 

5.3 转换流简写 FileWriter / FileReader （常用）

由于我们常见的操作都是使用本地默认编码，所以，不用指定编码。而转换流的名称有点长，所以，Java就提供了其子类供我们使用。

FileWriter 的编码是根据你的运行平台来获取编码

OutputStreamWriter = FileOutputStream + 编码表

FileWriter = FileOutputStream + 编码表

 

InputStreamReader = FileInputStream + 编码表

FileReader = FileInputStream + 编码表

// 封装数据源
    FileReader fr = new FileReader("a.txt");
    // 封装目的地
    FileWriter fw = new FileWriter("b.txt");
​
    // 一次一个字符
    // int ch = 0;
    // while ((ch = fr.read()) != -1) {
    // fw.write(ch);
    // }
​
    // 一次一个字符数组
    char[] chs = new char[1024];
    int len = 0;
    while ((len = fr.read(chs)) != -1) {
      fw.write(chs, 0, len);
      fw.flush();
    }
​
    // 释放资源
    fw.close();
    fr.close();

 

六、字符缓冲输入/输出流

字符流为了高效读写，也提供了对应的字符缓冲流。

• BufferedWriter:字符缓冲输出流

• BufferedReader:字符缓冲输入流

BufferedWriter:字符缓冲输出流

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

• 可以指定缓冲区的大小，或者接受默认的大小。在大多数情况下，默认值就足够大了。

// BufferedWriter(Writer out)
    // BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
    // new FileOutputStream("bw.txt")));
​
    BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
​
    bw.write("hello");
    bw.write("world");
    bw.write("java");
    bw.flush();
​
    bw.close();

BufferedReader

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

• 可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。

 

// 创建字符缓冲输入流对象
    BufferedReader br = new BufferedReader(new FileReader("bw.txt"));
​
    // 方式1
    // int ch = 0;
    // while ((ch = br.read()) != -1) {
    // System.out.print((char) ch);
    // }
​
    // 方式2
    char[] chs = new char[1024];
    int len = 0;
    while ((len = br.read(chs)) != -1) {
      System.out.print(new String(chs, 0, len));
    }
​
    // 释放资源
    br.close();

 

6.1 复制文本文件

// 封装数据源
    BufferedReader br = new BufferedReader(new FileReader("a.txt"));
    // 封装目的地
    BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));
​
    char[] chs = new char[1024];
    int len = 0;
    while ((len = br.read(chs)) != -1) {
      bw.write(chs, 0, len);
      bw.flush();
    }
​
    // 释放资源
    bw.close();
    br.close();

 

6.2字符缓冲流的特殊方法

BufferedWriter:

• public void newLine():根据系统来决定换行符

BufferedReader:

• public String readLine()：一次读取一行数据

• 包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null

• 无法自己换行，可以配合System.out.println（）使用

 

newLine()

// 创建字符缓冲输出流对象
    BufferedWriter bw = new BufferedWriter(new FileWriter("bw2.txt"));
    for (int x = 0; x < 10; x++) {
      bw.write("hello" + x);
      // bw.write("\r\n");
      bw.newLine();
      bw.flush();
    }
    bw.close();

 

readLine()

// 创建字符缓冲输入流对象
    BufferedReader br = new BufferedReader(new FileReader("bw2.txt"));
    String line = null;
    while ((line = br.readLine()) != null) {
      System.out.println(line);
    }
    
    //释放资源
    br.close();

 

复制文本文件

// 封装数据源
    BufferedReader br = new BufferedReader(new FileReader("a.txt"));
    // 封装目的地
    BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));
​
    // 读写数据
    String line = null;
    while ((line = br.readLine()) != null) {
      bw.write(line);
      bw.newLine();
      bw.flush();
    }
​
    // 释放资源
    bw.close();
    br.close();

 

七、读写 基本数据类型 的流

数据输入流：DataInputStream

DataInputStream(InputStream in)

数据输出流：DataOutputStream

DataOutputStream(OutputStream out)

 

写入

// 创建数据输出流对象
    DataOutputStream dos = new DataOutputStream(new FileOutputStream("dos.txt"));
​
    // 写数据
    dos.writeByte(10);
    dos.writeShort(100);
    dos.writeInt(1000);
    dos.writeLong(10000);
    dos.writeFloat(12.34F);
    dos.writeDouble(12.56);
    dos.writeChar('a');
    dos.writeBoolean(true);
​
    // 释放资源
    dos.close();

 

读取

// 创建数据输入流对象
    DataInputStream dis = new DataInputStream(new FileInputStream("dos.txt"));
​
    // 读数据
    byte b = dis.readByte();
    short s = dis.readShort();
    int i = dis.readInt();
    long l = dis.readLong();
    float f = dis.readFloat();
    double d = dis.readDouble();
    char c = dis.readChar();
    boolean bb = dis.readBoolean();
​
    // 释放资源
    dis.close();
​
    System.out.println(b);
    System.out.println(s);
    System.out.println(i);
    System.out.println(l);
    System.out.println(f);
    System.out.println(d);
    System.out.println(c);
    System.out.println(bb);

 

八、序列化流:

 

序列化流

ObjectOutputStream

反序列化流

ObjectInputStream

序列化流：把对象按照流一样的方式存入文本文件或者在网络中传输。对象 -- 流数据 (ObjectOutputStream)

反序列化流: 把文本文件中的流对象数据或者网络中的流对象数据还原成对象。流数据 -- 对象 (ObjectInputStream)

 

创建对象，并序列化

类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。

该接口没有任何方法，类似于这种没有方法的接口被称为标记接口。

public class Person implements Serializable {
  private static final long serialVersionUID = -2071565876962058344L;
​
  private String name;
​
  // private int age;
  //使用transient关键字声明不需要序列化的成员变量
  private transient int age;
​
  // int age;
​
  public Person() {
    super();
  }
​
  public Person(String name, int age) {
    super();
    this.name = name;
    this.age = age;
  }
​
  public String getName() {
    return name;
  }
​
  public void setName(String name) {
    this.name = name;
  }
​
  public int getAge() {
    return age;
  }
​
  public void setAge(int age) {
    this.age = age;
  }
​
  @Override
  public String toString() {
    return "Person [name=" + name + ", age=" + age + "]";
  }
}
​

private static final long serialVersionUID = -2071565876962058344L是什么？

序列化操作时会把系统当前类的serialVersionUID写入到序列化文件中，当反序列化时系统会自动检测文件中的serialVersionUID，判断它是否与当前类中的serialVersionUID一致。如果一致说明序列化文件的版本与当前类的版本是一样的，可以反序列化成功，否则就失败；

 

private transient int age;

使用transient关键字声明不需要序列化的成员变量

序列化流对象

private static void write() throws IOException {
    // 创建序列化流对象
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("oos.txt"));
​
    // 创建对象
    Person p = new Person("林青霞", 27);
​
    // public final void writeObject(Object obj)
    oos.writeObject(p);
​
    // 释放资源
    oos.close();
  }

反序列化流对象

private static void write() throws IOException {
// 创建反序列化对象
    ObjectInputStream ois = new ObjectInputStream(new FileInputStream("oos.txt"));
​
    // 还原对象
    Object obj = ois.readObject();
​
    // 释放资源
    ois.close();
​
    // 输出对象
    System.out.println(obj);
}

 

九、Properties集合类

Properties:属性集合类。是一个可以和IO流相结合使用的集合类。

Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。

是Hashtable的子类，说明是一个Map集合。

 

添加遍历元素

    Properties prop = new Properties();
​
    // 添加元素
    prop.put("it002", "hello");
    prop.put("it001", "world");
    prop.put("it003", "java");
​
​
    // 遍历集合
    Set<Object> set = prop.keySet();
    for (Object key : set) {
      Object value = prop.get(key);
      System.out.println(key + "---" + value);
    }

 

方法：

public Object setProperty(String key,String value)：添加元素

public String getProperty(String key):获取元素

public Set<String> stringPropertyNames():获取所有的键的集合

// 创建集合对象
    Properties prop = new Properties();
​
    // 添加元素
    prop.setProperty("张三", "30");
    prop.setProperty("李四", "40");
    prop.setProperty("王五", "50");
​
    // public Set<String> stringPropertyNames():获取所有的键的集合
    Set<String> set = prop.stringPropertyNames();
    for (String key : set) {
      String value = prop.getProperty(key);
      System.out.println(key + "---" + value);
    }

 

Properties和IO流结合

集合必须是Properties集合：

public void load(Reader reader):把文件中的数据读取到集合中

public void store(Writer writer,String comments):把集合中的数据存储到文件

 

创建prop.txt文本文件，内容需为键值对的形式：

张三 = 30
李四 = 40

 

读取文件

    Properties prop = new Properties();
​
    // public void load(Reader reader):把文件中的数据读取到集合中
    // 注意：这个文件的数据必须是键值对形式
    Reader r = new FileReader("prop.txt");
    prop.load(r);
    r.close();
​
    System.out.println("prop:" + prop);

 

写入文件

// 创建集合对象
    Properties prop = new Properties();
​
    prop.setProperty("李白", "27");
    prop.setProperty("小白", "30");
    prop.setProperty("小可", "18");
    
    //public void store(Writer writer,String comments):把集合中的数据存储到文件
    Writer w = new FileWriter("name.txt");
    prop.store(w, "helloworld");  //helloworld为属性列表的描述，可随意更改，也可写为null
    w.close();

 

感谢：文章收集整理自  刘意老师视频 与下列 博客

https://blog.csdn.net/ryuenkyo/article/details/81198093