java IO流

阅读数: 次 2020-05-29

1. 字节流
1. 字符流 = 字节流+编码
- 2.1. 字符打印流PrintWriter
1. File类
- 3.1. 对象序列化流ObjectOutputStream
- 3.2. property类和io流的配合使用
1. 总结

io流

java输入输出流（IO流）可以用来读写文件，网络连接等。
而io流又分为字节流和字符流。

1. 字节流

基类是InputStream和OutputStream，分别表示输入和输出字节流。
其中几个常用的方法：
输入流

1
2
3

abstract int read()//从数据中读入一个字节
int read(byte[] b)//读入一个字节数组，并返回实际读入的字节数
//读完数据后会后移，遇到输入流末尾时返回-1

输出流

1
2
3

abstract void write(int n)//写出一个字节的数据
void write(byte[] b)//写入一个字符数组的数据
void write(byte[] b,int off,int len)//写入某个范围的字节

如果需要读写文件，则需要文件字节流FileInputStream和FileoutputStream

构造器中需要提供一个路径或File对象，可以指定是否为追加模式

public class fileinout {
    public static void main(String[] args)throws IOException {
        File f = new File("D:\\Core java2\\3.txt");
        FileOutputStream fs = new FileOutputStream(f);
        //如果没有文件会创建文件
        //创建了字节输出流对象
        //让字节输出流对象指向创建好的文件
        fs.write("中国".getBytes());//向文件中写数据，写一个字节，写入的是数字对应的字符
        //byte[] bytes = {1,2,3,4,5,6};
        byte[] bytes = " 1,2,3,4,5,6".getBytes();//将字符串转换为字节数组
        fs.write(bytes);//写入一个byte数组的数据
        fs.close();//关闭流，释放资源
    }
}

为了提高读取效率，可以使用缓冲流（BufferedOutputStream）来包装字节流，它只提供缓冲区，需要在其构造器中提供一个字节流。

1 2	BufferedOutputStream bs = new BufferedOutputStream(new FileOutputStream("D:\\Core java2\\4.txt")); //输入流同理

字节流可以复制任意类型的数据，一般采用字节缓冲流来一次读取一个字节数组的方式，效率更高

下面例子为复制文件

public class copy {
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        //因为try中的代码对外面不可见，需要在外面定义为null
        try {
            /*复制文本*/
            int by;
            fis = new FileInputStream("D:\\Core java2\\1.txt");
            fos = new FileOutputStream("D:\\Core java2\\2.txt");
            while((by = fis.read())!= -1){
                fos.write((char)by);
            }
            /*复制图片*/
            fis = new FileInputStream("C:\\Users\\MEC\\Pictures\\IMG_2767.JPG");
            fos = new FileOutputStream("D:\\Core java2\\handson boy.jpg");
            byte[] bytes = new byte[1024];
            int len;
            while((len = fis.read(bytes)) != -1){
                fos.write(bytes,0,len);//注意此处，len为返回所读字节的长度
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fis!=null&&fos!=null) {
                try {
                    fis.close();
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

2. 字符流 = 字节流+编码

在用字节流来读取汉字时，可能会出现问题，因为默认UTF-8编码中汉字占三个字节，字节流一次读取一个字节可能会出现乱码，这时候可以采用字符流。

字符流大多数用来读写文本文件，其基类为Reader和Writer。文件字符流为
OutputStreamWriter和InputStreamReader，字符流以Writer或Reader结尾，字节流以Stream结尾。

要构造一个字符流，需要在其构造器中给定一个字节流！可以在构造器中指定编码方式。

1 2	OutputStreamWriter ow = new OutputStreamWriter(new FileOutputStream("D:\\Core java2\\4.txt", true), "UTF-8"); //true为追加模式，采用UTF-8编码方式

字符流的操作和字节流基本相同，其也有字符缓冲流BufferedReader和BufferedWriter，不过这两个流拥有特殊的方法

1
2
3

String readLine()//读一行字符串并返回，读到换行符为止，忽略空格
//如果读到文件末尾则返回null
void newLine()//写入一个换行符

newLine方法可以写入一个换行符，由于操作系统不同，换行符也不同，在windows系统中，换行符为‘\t\n’，newLine可以写入一个适用于各个系统的换行符！

FileReader和FileWriter可以代替OutputStreamWriter和InputStreamReader，其构造器中只需要提供文件的路径就可以了，无须再提供一个字节流。

一般采用字符缓冲流的特有方法来读写文本文件

FileWriter fw = new FileWriter("D:\\Core java2\\4.txt",true);
BufferedWriter bw = new BufferedWriter(fw);//字符缓冲流
for(int i = 0;i <= 4;i++){
    bw.write("hello"+i);
    bw.newLine();//输出一个适用于各种系统的换行符，特有方法
    bw.flush();
}

BufferedReader bb = new BufferedReader(new FileReader("D:\\Core java2\\4.txt"));
String s;
while((s=bb.readLine()) != null){//读一行字符，不包含换行符！
    System.out.print(s);
}

bw.close();
bb.close();

此时注意到代码中有一个flush方法，该方法为刷新缓冲区。close方法会先刷新缓冲区然后再关闭资源。

如果不刷新缓冲区，数据就还留在缓冲区内并没有写出。

字符流和缓冲流都需要刷新缓冲区。

2.1. 字符打印流PrintWriter

该流能够以文本格式打印给定的值，格式类似于标准输出流

1
2
3

void print()
void println();
...

3. File类

File类的构造器中需要给定一个路径

1	File f = new File("D:\\Core java2");

可以利用该类来操纵文件

f.createNewFile();//创建一个空文件，如果文件已存在就抛出异常
f.mkdir();//创建目录
f.mkdirs();//c创建多级目录
f.delete();//删除文件，如果不存在抛出异常
...

还可以获取文件信息

f1.isFile();//是否为文件
f1.getPath();//获得路径
f1.getName();//得到文件名
f1.list();//返回此路径下的文件和目录的名字的字符串数组
f1.listFiles();//......File数组

下面来利用File类来访问一个路径并打印所有文件的名称

public class file {
    public static void main(String[] args) throws IOException {
        Path path = Paths.get("D:\\Core java2");//创建一个路径
        System.out.println(Files.isDirectory(path));//判断该路径是否为目录，true

        File f = new File("D:\\Core java2");
        getPaths(f);
    }

    public static void getPaths(File file){//输出指定目录中的所有文件信息
        File[] files = file.listFiles();
        if(files != null){
            for(File f:files){
                if(f.isDirectory()){
                    getPaths(f);//如果是目录就递归调用
                }
                else System.out.println(f);//如果是文件就输出
            }
        }
    }
}

结果会打印出该路径下所有文件的名称。

3.1. 对象序列化流ObjectOutputStream

对象序列化就是将对象保存在磁盘或者在网络中传输对象。反序列化就是从磁盘中读取出一个对象。

对象序列化流就是用来操纵对象并对其进行序列化，被序列化的类需要实现
Serializable接口，该接口只是个标志，没有方法

下面看个例子，以一个测试类为例

测试类

public class Demo implements Serializable {
    private static final long serialVersionUID = 42L;//当给定序列化id，序列化该类后再修改该类，
                                                     // 不会抛出异常，否则修改后会抛出异常
    private String name;
    private transient int age;//transit代表该成员变量不参与序列化

    public Demo(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Demo() {
    }

    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;
    }
}

序列化和反序列化操作

public class object {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\Core java2\\4.txt"));
        Demo d = new Demo("sucker", 20);
        oos.writeObject(d);//将对象的信息序列化到文件
        oos.close();

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\Core java2\\4.txt"));
        Object o = ois.readObject();//从文件中得到一个对象
        Demo o1 = (Demo) o;
        System.out.println(o1.getName() + " " + o1.getAge());
        ois.close();
    }
}
//输出sucker 0

为什么会输出sucker 0呢？不应该输出sucker 20吗？

因为测试类中的私有字段age被transient关键字修饰了，代表该字段不参与序列化。

注意：如果对象在被序列化之后再被修改了，进行反序列化时会抛出异常！
解决方案：给定序列化id。每个类都有个序列化id，如果被修改了，序列化id也会改变，进行反序列化时如果序列化id与之前不匹配，会抛出异常。如果给定了序列化id，就不会抛出异常。

下面就是给定序列化id

1	private static final long serialVersionUID = 42L;//名字都是固定的

对象序列化流可以保存和传输对象。

3.2. property类和io流的配合使用

property类可以将属性映射保存在流中。

4. 总结

io流中还有许多的类，在这只是列举了常用的类。
字节流为读取字节，字符流读取字符。
字符流使用了缓冲区，需要刷新缓冲区。

使用io流的三个步骤

创建流对象
进行读写操作
关闭流