Java进阶之I/O流

Java进阶之I/O流

Java进阶之I/O流

• 将数据从一种平台转移到另外一种平台的技术手段

I(输入流)/O(输出流)

流分类

• 按方向分
• 输入流
• 输出流
• 按单位分
• 字节型输入流FileInputStream
• 字节型输出流FileOutputStream
• 字符型输入流FileReader
• 字符型输出流FileWriter
• 按功能分
• 节点流
• 处理流

I/O流工作机制

• 输入流用来将硬盘上的文件内容从硬盘读取到内存里，输入流用来进行读操作
• 输出流是用来将内存的文件内容从内存中写入到硬盘里，输出流用来进行写操作
• 电脑A输出流 = 电脑B输入流，反之
• 决定文件的不是文件名+后缀名，文件内容是决定文件类型的关键，后缀名决定的是默认打开方式

File类 Java中用来表示文件或文件夹的一种类，而且是一种抽象的表现形式

    public static void fileTest(){
        File file = new File("d://testIO/test/test.txt");
        File file1 = new File("d://testIO/test");
        //流会有编译时异常
        try {
            file1.mkdirs();
            file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

File常用类

• 当文件不存在时创建：createNewFile()
• 删除： delete()
• 判断文件或目录是否存在：exists()
• 获取文件或目录的名称(相对路径)：getName()
• 获取绝对路径：getPath
• 判断这个路径是否是绝对的：isAbsolute()
• 判断是文件还是文件夹：isDirectory()
• 判断文件是什么文件： 普通文件isFile()，隐藏文件isHidden()
• 返回文件上一次修改时间：lastModified
• 创建文件夹：mkdir()
• 级联创建文件夹：mkdirs()
• 重命名：renameTo()

字符集

• 规定拆分和重组时的算法，同一字符集拆分重组算法互逆
• 重组之前内容不可改变
• 规定了码值的取值范围

IO流

• 输入流
• 字节输入流
• 输入流读取，从硬盘(操作系统 拆分成字节)读取到内存(将传输的数据重组)
• FileInputStream fileInputStream = new FileInputStream(file)
• 读取一个字符fileInputStream.read() -- 获取到的是int类型，输出需要转型
• 关闭链接 fileInputStream.close()

public class TestInputStream {
    public static void main(String[] args) throws FileNotFoundException {
        FileInputStream fileInputStream = new FileInputStream("d://Test、、test.txt");
    }
}

• 字符输入流

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class TestReader {
    public void testReader() {
        FileReader fileReader = null;
        try {
            fileReader = new FileReader(new File("d://Test//test.txt"));

            char[] c = new char[20];
            int i = fileReader.read(c);
            while(i != -1){
                String s = new String(c,0,i);
                System.out.println(s);
                i = fileReader.read(c);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fileReader != null){
                try {
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

• 输出流
• 字节输出流
• 内存拆分->传输->硬盘重组
• 非追加模式FileOutputStream fileOutputStream = new FileOutputStream(file)
• fileOutputStream.write('a');
• fileOutputStream.flush();
• 追加模式FileOutputStream fileOutputStream = new FileOutputStream(file,true)

public class TestOutputStream {
    public static void main(String[] args) throws FileNotFoundException {
        FileOutputStream fileOutputStream = new FileOutputStream(new File("d://Test//test.txt"));
    }
}

• 字符输出流

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class TestWriter {
    public void testWriter() {
        FileWriter fileWriter = null;
        try {
            fileWriter = new FileWriter(new File("d://Test/test.txt"),true);
            fileWriter.write("
哔哩哔哩干杯
");
            fileWriter.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(fileWriter != null){
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
    }
}

• 缓冲流
• BufferedInputStream
• BufferedOutputStream
• BufferedReader
• BufferedWriter
• 缓冲流和普通流方法一样，但是效率更高
• 缓冲流可以使用readLine()，读取一行

import java.io.*;

public class BufferedIO {
    public void bufferedIO() throws IOException{
        File file = new File("d://Test/test.txt");
//        FileInputStream fileInputStream = new FileInputStream(file);
//        BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);

//        FileOutputStream fileOutputStream = new FileOutputStream(file);
//        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);

        FileReader fileReader = new FileReader(file);
        BufferedReader bufferedReader = new BufferedReader(fileReader);
        String string = bufferedReader.readLine();
        while(string!=null){
            System.out.println(string);
            //一次读一行
            string = bufferedReader.readLine();
        }

        FileWriter fileWriter = new FileWriter(file);
        BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
        bufferedWriter.newLine();
        bufferedWriter.write("写进去一整行");
        bufferedWriter.flush();
        bufferedWriter.close();
        bufferedReader.close();
//        bufferedOutputStream.close();
//        bufferedInputStream.close();
        fileWriter.close();
        fileReader.close();
//        fileOutputStream.close();
//        fileInputStream.close();
    }
}

流的一般应用

• 文件写入读取流----数据的持久化操作->将数据保存在硬盘上，以便于之后继续使用
• 标准输入输出流
• Scanner扫描器
• 序列化
• 对象流
• 将对象进行存储(文件、网络)，从存储媒体中(文件、网络)中直接读取对象信息本身
• 将对象按对象流存储时要将对象序列化,序列化要实现Serializable接口(示意性接口)
• 可以自定义序列号 栗子：ANY-ACCESS-MODIFIER private static final long(向下兼容) serialVersionUID = 42L
• 关键字transient，可以声明序列化中特殊的存在 栗子：private transient String tmp
• 使用transient后，序列化时不会将被transient所描述的对象序列化

import java.io.Serializable;

public class ObjectIO implements Serializable {
    private String name;
    private int age;

    public ObjectIO(){

    }
    public ObjectIO(String name,int age){
        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;
    }
}

import java.io.*;
public class ObjectStream {
    public static void main(String[] args) throws Exception {
        ObjectIO objectIO = new ObjectIO("张三",10);
        FileOutputStream fileOutputStream = new FileOutputStream("E:\JAVA\Java2006\src\com\xumouren\work0814\testObjectIO.txt");
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
        //将对象写入
        objectOutputStream.writeObject(objectIO);
        objectOutputStream.flush();
        objectOutputStream.close();

        FileInputStream fileInputStream = new FileInputStream("E:\JAVA\Java2006\src\com\xumouren\work0814\testObjectIO.txt");
        ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
        objectIO = (ObjectIO)objectInputStream.readObject();
        System.out.println(objectIO.getName()+objectIO.getAge());
    }
}