11 IO流 - 其他流 - 《JavaSE》

标准输入、输出流
打印流
数据流
对象流
- 对象的序列化
任意存取文件流
流的基本应用总结

javajavase

标准输入、输出流

System.in：标准的输入流，默认从键盘输入
System.out：标准的输出流，默认从控制台输出
主要方法
System类的**setIn(InputStream is)**方式重新指定输入的流
System类的**setOut(PrintStream ps)**方式重新指定输出的流

练习

/*
    从键盘输入字符串，要求将读取到的整行字符串转成大写输出。然后继续进行输入操作，
    直至当输入“e”或者“exit”时，退出程序。
    方法一：使用Scanner实现，调用next()返回一个字符串
    方法二：使用System.in实现。System.in ---> 转换流 ---> BufferedReader的readLine()
 */
    public static void main(String[] args) {    // IDEA不支持test控制台输入
    BufferedReader br = null;
    try {
        InputStreamReader isr = new InputStreamReader(System.in);
        br = new BufferedReader(isr);
        while (true) {
            System.out.println("请输入字符串：");
            String data = br.readLine();
            if ("e".equalsIgnoreCase(data) || "exit".equalsIgnoreCase(data)) {
                System.out.println("程序结束");
                break;
            }
            String upperCase = data.toUpperCase();
            System.out.println(upperCase);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (br != null) {
            try {
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

// MyInput.java: Contain the methods for reading int, double, float, boolean, 
// short, byte and string values from the keyboard
import java.io.*;
public class MyInput {
    // Read a string from the keyboard
    public static String readString() {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        // Declare and initialize the string
        String string = "";
        // Get the string from the keyboard
        try {
            string = br.readLine();
        } catch (IOException ex) {
            System.out.println(ex);
        }
        // Return the string obtained from the keyboard
        return string;
    }
    // Read an int value from the keyboard
    public static int readInt() {
        return Integer.parseInt(readString());
    }
    // Read a double value from the keyboard
    public static double readDouble() {
        return Double.parseDouble(readString());
    }
    // Read a byte value from the keyboard
    public static double readByte() {
        return Byte.parseByte(readString());
    }
    // Read a short value from the keyboard
    public static double readShort() {
        return Short.parseShort(readString());
    }
    // Read a long value from the keyboard
    public static double readLong() {
        return Long.parseLong(readString());
    }
    // Read a float value from the keyboard
    public static double readFloat() {
        return Float.parseFloat(readString());
    }
}

打印流

实现将基本数据类型的数据格式转化为字符串输出
PrintStream和PrintWriter
说明

提供了一系列重载的print()和println()方法，用于多种数据类型的输出
输出不会抛出IOException异常
有自动flush功能

System.out返回的是PrintStream的实例

@Test
public void test2() {
  PrintStream ps = null;
  try {
      FileOutputStream fos = new FileOutputStream(new File("D:\\IO\\text.txt"));
      // 🔴创建打印输出流,设置为自动刷新模式(写入换行符或字节'\n'时都会刷新输出缓冲区)
      ps = new PrintStream(fos, true);
      if (ps != null) {
          System.setOut(ps);    // 把标准输出流(控制台输出)改成文件
      }
      for (int i = 0; i <= 255; i++) {    // 输出ASCII字符
          System.out.print((char) i);
          if (i % 50 == 0) {    // 每50个数据一行
              System.out.println();    // 换行
          }
      }
  } catch (FileNotFoundException e) {
      e.printStackTrace();
  } finally {
      if (ps != null) {
          ps.close();
      }
  }
}

数据流

DataInputStream 和 DataOutputStream
作用：用于读取或写出基本数据类型的变量、字节数组、字符串

@Test
public void test3() throws IOException {
    DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
    dos.writeUTF("川建国");
    dos.flush();//刷新操作，将内存中的数据写入文件
    dos.writeInt(78);
    dos.flush();
    dos.writeBoolean(true);
    dos.flush();
    dos.close();
}

将文件中存储的基本数据类型变量和字符串读取到内存中，保存在变量中

@Test
public void test4() throws IOException {
    DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
    String name = dis.readUTF();
    int age = dis.readInt();
    boolean isMale = dis.readBoolean();
    System.out.println("name = " + name);
    System.out.println("age = " + age);
    System.out.println("isMale = " + isMale);
    dis.close();
}

对象流

ObjectInputStream 和 ObjectOutputStream
作用

ObjectOutputStream：内存中的对象—->存储中的文件、通过网络传输出去：序列化过程
ObjectInputStream：存储中的文件、通过网络接收过来 —->内存中的对象：反序列化过程

对象的序列化
对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。当其它程序获取了这种二进制流，就可以恢复成原来的Java对象
序列化的好处在于可将任何实现了Serializable接口的对象转化为字节数据，使其在保存和传输时可被还原
序列化是RMI（Remote Method Invoke-远程方法调用）过程的参数和返回值都必须实现的机制，RMI是JavaEE的基础。因此序列化机制是JavaEE平台的基础。
如果需要让某个对象支持序列化机制，则必须让对象所属的类及其属性是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一。否则，会抛出 NotserializableEXception异常
- Serializable
- Externalizable
凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量

**private static final long serialVersionUID;**

serialVersionUID用来表明类的不同版本间的兼容性。简言之，其目的是以序列化对象进行版本控制，有关各版本反序列化时是否兼容
如果类没有显示定义这个静态常量，它的值是Java运行时环境根据类的内部细节自动生成的。若类的实例变量做了修改，serialVersionUID可能发生变化，故建议显式声明
- 简单来说，Java的序列化机制是通过在运行时判断类的serialversionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的serialversionUID与本地相应实体类的serialversionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常。(InvalidCastException)

实现序列化的对象所属的类需要满足

需要实现接口：Serializable（标识接口）
当前类提供一个全局常量：serialVersionUID（序列版本号）
除了当前Person类需要实现Serializable接口之外，还必须保证其内部所属性也必须是可序列化的

默认情况下，基本数据类型可序列化

ObjectOutputStream 和 ObjectInputStream不能序列化static和transient修饰的成员变量

对象流的使用
序列化：将对象写入磁盘或进行网络传输
要求被序列化对象必须实现序列化

// 序列化过程：将内存中的java对象保存到磁盘中或通过网络传输出去,使用ObjectOutputStream实现
@Test
public void testObjectOutputStream() {
    ObjectOutputStream oos = null;
    try {
        oos = new ObjectOutputStream(new FileOutputStream("object.dat"));
        oos.writeObject(new String("我爱北京天安门"));
        oos.flush();
        oos.writeObject(new Person("王铭", 23));
        oos.flush();
        oos.writeObject(new Person("张学良", 23, 1001, new Account(5000)));
        oos.flush();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if(oos != null){
            try {
                oos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

反序列化：将磁盘的对象数据源读出

// 反序列化：将磁盘文件中的对象还原为内存中的一个java对象,使用ObjectInputStream来实现
@Test
public void testObjectInputStream(){
    ObjectInputStream ois = null;
    try {
        ois = new ObjectInputStream(new FileInputStream("object.dat"));
        String obj = (String)ois.readObject();
        Person p = (Person) ois.readObject();
        Person p1 = (Person) ois.readObject();
        System.out.println(str);
        System.out.println(p);
        System.out.println(p1);
    } catch (IOException e) {
        e.printStackTrace();
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } finally {
        if(ois != null){
            try {
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Person implements Serializable {
    public static final long serialVersionUID = 475463534532L;
    private String name;
    private int age;
    private int id;
    private Account acct;
    public Person() {}
    public Person(String name, int age, int id) {
        this.name = name;
        this.age = age;
        this.id = id;
    }
    public Person(String name, int age, int id, Account acct) {
        this.name = name;
        this.age = age;
        this.id = id;
        this.acct = acct;
    }
    // toString() getXxx()/setXxx()方法略
}
class Account implements Serializable {
    public static final long serialVersionUID = 4754534532L;
    private double balance;
    public Account(double balance) {
        this.balance = balance;
    }
}

任意存取文件流

RandomAccessFile

RandomAccessFile 直接继承于Object类，实现了DataInput 和 DataOutput接口
RandomAccessFile 既可以作为一个输入流，又可以作为一个输出流
RandomAccessFile 类支持“随机访问”的方式，程序可以直接跳到文件的任意地方来读、写文件
- 支持只访问文件的部分内容
- 可以向已存在的文件后追加内容
RandomAccessFile 对象包含一个记录指针，用以标示当前读写处的位置
RandomAccessFile 类对象可以自由移动记录指针
- **long getFilePointer()**获取文件记录指针的当前位置
- **void seek(long pos)**将文件记录指针定位到pos位置

构造器
**public RandomAccessFile(File file, String mode)**
**public RandomAccessFile(String name, String mode)**
使用说明

如果RandomAccessFile作为输出流时，写出到的文件如果不存在，则在执行过程中自动创建
如果写出到的文件存在，不是对文件覆盖，而是对对原文件内容进行覆盖（默认情况下，从头覆盖）
可以通过相关的操作，实现RandomAccessFile“插入”数据的效果，借助seek(int pos)方法
创建RandomAccessFile类实例需要指定一个mode参数，该参数指定RandomAccessFile的访问模式
- r：以只读方式打开
- rw：打开以便读取和写入，数据不会立即写入硬盘中，若发生异常则丢失
- rwd：打开以便读取和写入；同步文件内容的更新
- rws：打开以便读取和写入；同步文件内容和元数据的更新，数据立即写入硬盘中
如果模式为只读r则不会创建文件，而是会去读取一个已经存在的文件，读取的文件不存在则会出现异常；

如果模式为rw读写文件不存在则会去创建文件，存在则不会创建

// 文件的读取和写出操作
@Test
public void test1() {
 RandomAccessFile raf1 = null;
 RandomAccessFile raf2 = null;
 try {
     raf1 = new RandomAccessFile(new File("爱情与友情.jpg"),"r");
     raf2 = new RandomAccessFile(new File("爱情与友情1.jpg"),"rw");
     byte[] buffer = new byte[1024];
     int len;
     while((len = raf1.read(buffer)) != -1) {
         raf2.write(buffer, 0, len);
     }
 } catch (IOException e) {
     e.printStackTrace();
 } finally {
     if(raf1 != null){
         try {
             raf1.close();
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
     if(raf2 != null){
         try {
             raf2.close();
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
 }
}

覆盖

@Test
public void test2() throws IOException {
 RandomAccessFile raf = new RandomAccessFile("hello.txt","rw");
 // hello.txt文件内容为"abcdefg"
 // 文件存在，写入并不是覆盖整个文件，而是从开头起覆盖
 raf.seek(3);    // 将指针调到角标为3的位置
 raf.write("xyz".getBytes());    // hello.txt文件内容改为"abcxyzg"
 raf.close();
}

使用RandomAccessFile实现数据的插入效果

@Test
public void test3() throws IOException {
 RandomAccessFile raf1 = new RandomAccessFile("hello.txt", "rw");
 raf1.seek(3);    // 将指针调到角标为3的位置
 // 保存指针3后面的所有数据到StringBuilder中
 StringBuilder builder = new StringBuilder((int) new File("hello.txt").length());
 byte[] buffer = new byte[20];
 int len;
 while ((len = raf1.read(buffer)) != -1) {
     builder.append(new String(buffer, 0, len));
 }
 // 调回指针，写入“xyz”
 raf1.seek(3);
 raf1.write("xyz".getBytes());
 //将StringBuilder中的数据写入到文件中
 raf1.write(builder.toString().getBytes());
 raf1.close();
 //思考：将StringBuilder替换为ByteArrayOutputStream
}

```java @Test public void test1() throws Exception { FileInputStream fis = new FileInputStream(“abc.txt”); String info = readStringFromInputStream(fis); System.out.println(info); }

private String readStringFromInputStream(FileInputStream fis) throws IOException { // BufferedReader reader = new BufferedReader(new InputStreamReader(fis)); // char[] buf = new char[10]; // int len; // String str = “”; // while ((len = reader.read(buf)) != -1) { // str += new String(buf, 0, len); // } // return str;

// 避免出现乱码
ByteArrayOutputStream baos = new ByteArrayOutputStream();
byte[] buffer = new byte[10];
int len;
while ((len = fis.read(buffer)) != -1) {
    baos.write(buffer, 0, len);
}
return baos.toString();

} ```

流的基本应用总结

流是用来处理数据的
处理数据时，一定要先明确数据源，与数据目的地数据源可以是文件，可以是键盘数据。目的地可以是文件、显示器或者其他设备
而流只是在帮助数据进行传输，并对传输的数据进行处理，比如过滤处理、转换处理等
除去RandomAccessFile类外所有的流都继承于四个基本数据流抽象类InputSteam、OutputSteam、Reader、Writer
不同的操作流对应的后缀均为四个抽象基类中的某一个
不同处理流的使用方式都是标准操作
- 创建文件对象，创建相应的流
- 处理流数据
- 关闭流
- 用try-catch-finally处理异常

其他流

标准输入、输出流

打印流

数据流

对象流

对象的序列化

任意存取文件流

流的基本应用总结