java基础入门第二版课后答案(java基础面试题)

内存与存储设备直接传输的通道输入流：将存储设备中的数据读取到内存中，方便程序操作输出流：将内存中的数据写入存储设备中，进行保存

按单位

字节流：以字节为单位，可以读写所有数据字符流：以字符为单位，只能读写文本数据 按功能

节点流：具有实际传输数据的读写功能（如底层流，真正进行读写数据的流）过滤流：在节点流的基础之上增强功能（如缓冲流）
  二、字节流

字节流的父类（抽象类）

InputStream：字节输入流OutputStream：字节输出流

字节流的实现类

FileInputStreamFileOutputStreamBufferedInputStreamBufferedOutputStream

    public static void main(String[] args) throws IOException {
        // 一、输入

        // 1.创建流
		// FileInputStream fis = new FileInputStream("");
		// BufferedInputStream bis = new BufferedInputStream(fis);
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\开发学习记录\IO\test.txt"));
        // 2.读取
        int data = 0;
        while((data = bis.read()) != -1){
            System.out.print((char)data);
        }
        System.out.println();

        // 二、输出

        // 1.创建流
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("E:\开发学习记录\IO\output.txt"));
        // 2.写入
        for (Integer i = 0; i < 10; i++) {
            bos.write("hello,".getBytes());
            bos.write("rn".getBytes());
            bos.flush();
        }
        System.out.println("output done");


        // 关闭

        bis.close();
        bos.close();


    }
}

序列化（输出）

ObjectOutputStream实现对象的序列化

要求序列化的类必须实现Serializable接口

序列化版本号ID，保证序列化的类和反序列化的类是同一个类

使用transient（瞬时的，瞬间的） 修饰属性，这个属性就不能被序列化了

静态属性不能序列化

序列化多个对象时可以使用集合，如ArrayList

public class Student implements Serializable{
    //序列化版本号ID
    private static final long serialVersionUID = 1L;   
    private transient int age;
}

反序列化（读取）

相比于字节流，字符流可以保证汉字等多字节构成的字符被正常读取和写入

public static void main(String[] args) throws IOException {
    // 1.创建流
    FileReader fileReader = new FileReader("");
    FileWriter fileWriter = new FileWriter("");
    // 2.读取
    char[] buffer = new char[1024];
    int count;
    while((count = fileReader.read(buffer))!= -1){
        System.out.println(new String(buffer,0,count));
    }

    // 3.写入
    for (int i = 0; i < 10; i++) {
        fileWriter.write("你好");
        fileWriter.flush();
    }

    // 4.close
    fileReader.close();
    fileWriter.close();
}

字节缓冲流PrintWriter

public static void main(String[] args) throws IOException {
    // 1.创建流
    BufferedReader br = new BufferedReader(new FileReader(""));
    BufferedWriter bw = new BufferedWriter(new FileWriter(""));
    PrintWriter pw = new PrintWriter("");
    // 2.读取
    String line = null;
    //String line = br.readLine(); // 按行读取
    while((line = br.readLine())!= null){
        System.out.println(line);
    }


    // 3.1 输出
    for (int i = 0; i < 10; i++) {
        bw.write("你好");
        bw.newline(); // 换行符
        bw.flush();
    }

    // 3.2 PrintWriter
    pw.println("hello");
    pw.println(true);
    pw.print(123);
    pw.print('a');

    // 4.关闭
    br.close();
    bw.close();
    pw.close();
}

转换流（可将字节流转为字符流）

InputStreamReaderOutputStreamWriter

InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream(""));
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream(""));

int data;
while((data=inputStreamReader.read())!=-1){
    System.out.println((char) data);
}

for (int i = 0; i < 10; i++) {
    outputStreamWriter.write("你好rn");//使用rn来换行
    outputStreamWriter.flush();
}
inputStreamReader.close();
outputStreamWriter.close();