Java之IO流

最新推荐文章于 2024-08-16 23:08:28 发布

荼蘼2021

最新推荐文章于 2024-08-16 23:08:28 发布

阅读量59

点赞数

分类专栏： Java基础文章标签： java eclipse tomcat

本文链接：https://blog.csdn.net/weixin_43915128/article/details/120420329

版权

Java基础专栏收录该内容

6 篇文章 0 订阅

订阅专栏

File类：

File类的构造方法：

File(File parent, String child)
通过父级路径file对象+子路径String创建file对象
File(String pathname)
通过路径String创建file对象
File(String parent, String child)
通过父级路径String+子路径String创建file对象
File(URI uri)
通过file:uri创建file对象
uri：统一资源标识符，用来唯一标识某个资源
url：统一资源定位符，uri的一个子类，实现定位的uri

常用方法：

boolean createNewFile()
当文件不存在时，创建该文件
boolean mkdir()
创建目录，该方法在父级路径存在时才会创建成功
boolean mkdirs()
创建目录，该方法在父级目录不存在时，也会创建父级目录
boolean delete()
删除文件或目录
boolean exists()
判断file是否存在
boolean isAbsolute()
判断是否是绝对路径
boolean isDirectory()
判断是否是目录
boolean isFile()
判断是否是文件
File getAbsoluteFile()
获得file的绝对路径，以File对象形式返回
String getAbsolutePath()
获得file的绝对路径，以字符串形式返回
String getName()
获得文件或目录名
String getParent()
获得父级目录的路径
File getParentFile()
获得父级目录的路径
String getPath()
file路径转换为字符串形式
String[] list()
以字符串形式返回file路径下的文件和目录
File[] listFiles()
以file形式返回file路径下的文件和目录
boolean renameTo(File dest)
重命名

遍历文件

	/**
     * 获得该目录下的所有文件及子文件
     *
     * @param path
     * @return
     */
    public static void getAllFile(String path) {
        File root = new File(path);
        if(!root.exists()){
            return;
        }
        File[] files = root.listFiles();
        for (File file : files){
            if(file.isDirectory()){//如果是目录，则继续遍历
                getAllFile(file.getAbsolutePath());
            }else {
                System.out.println(file.getAbsolutePath());
            }
        }
    }

Java的IO架构

I即Input，外部程序向Java程序传递数据
O即Output，Java程序向外部程序传递数据
这里是IO流的大致框架，网上抠的

字节流

InputStream：字节输入流的父类接口
OutputStream：字节输出流的父类接口

常用方法

OutputStream：

void write(byte[] b)
将数组写入到输出流
void write(byte[] b, int off, int len)
将数组从off位置，写入len个长度到输出流
void write(int b)
将指定字节写入输出流，b会强转成byte类型
void close()
关闭流

InputStream：

int read()
从输入流读取数据的下一个字节
int read(byte[] b)
从输入流读取字节，并存储到b
int read(byte[] b, int off, int len)
从输入流off位置，读取len个字节，并存储到b
void close()
关闭流

对文件写入和读取

	public static void main(String[] args) throws IOException {
    InputStream is = null;
    OutputStream os = null;
    File file = new File("H://a.txt");
    is = new FileInputStream(file);
    os = new FileOutputStream(file, true);//追加模式，默认为覆盖
    byte[] bytesWrite = "我是Java界的小学生".getBytes();
    os.write(bytesWrite);
    os.close();//用完就关闭
    int len = 0;
    byte[] bytesRead = new byte[1024];
    while ((len = is.read(bytesRead)) != -1) {//读完返回-1
        System.out.println(new String(bytesRead,0,len));
    }
    is.close();
}

字符流

Reader：字符输入流父类接口
Writer：字符输出流父类接口

常用方法

Writer

Writer append(char c)
链式编程，将字符写入该字符输出流，并返回该输出流
void write(int c)
将字符写入该字符输出流
void write(char[] cbuf)
将字符数组写入该字符输出流
void write(String str)
将字符串写入该字符输出流
void write(String str, int off, int len)
将该字符串，从off开始，写len个长度到该字符输出流
void flush()
刷新流，将缓冲区的字符写入文件，当close()时会调用，也可以通过该方法强制刷新

Reader

int read()
读取一个字符
int read(char[] cbuf)
将字符读入数组
int read(char[] cbuf, int off, int len)
将字符从off读取len个长度到数组

使用字符流重写上面的程序

	public static void main(String[] args) throws IOException {
        Reader is = null;
        Writer os = null;
        File file = new File("H://a.txt");

        is = new FileReader(file);
        os = new FileWriter(file, true);//追加模式，默认为覆盖
        String w = "我是Java界的小学生";
        os.write(w);
        os.flush();//不关闭时，必须刷新
        os.close();//关闭自动刷新
        int len = 0;
        char[] r = new char[1024];
        while ((len = is.read(r)) != -1) {//读完返回-1
            System.out.println(new String(r,0,len));
        }
        is.close();
    }

转换流

用于将字节流转换为字符流
InputStreamReader：将字节输入流转换为字符输入流
OutputStreamWriter：将字节输出流转换为字符输出流

将字节流转换为字符流后写入读取文件

public static void main(String[] args) throws IOException {
    InputStream is = null;
    OutputStream os = null;
    File file = new File("H://a.txt");
    is = new FileInputStream(file);
    os = new FileOutputStream(file, true);//追加模式，默认为覆盖
    //字节转字符
    InputStreamReader inputStreamReader = new InputStreamReader(is, "utf-8");//指定字符集
    OutputStreamWriter outputStreamWriter = new OutputStreamWriter(os, "utf-8");
    String w = "我是Java界的小学生";
    outputStreamWriter.write(w);
    outputStreamWriter.flush();//不关闭时，必须刷新
    outputStreamWriter.close();//关闭自动刷新
    int len = 0;
    char[] r = new char[1024];
    while ((len = inputStreamReader.read(r)) != -1) {//读完返回-1
        System.out.println(new String(r,0,len));
    }
    is.close();
}

缓冲流

当对文件频繁操作时，性能和效率低。缓冲流就是将数据先缓存起来，然后一起写入或读取，可以提高文件操作的效率。
缓冲流分为字节缓冲流和字符缓冲流

字节缓冲流

public static void main(String[] args) {
    BufferedInputStream bis = null;
    BufferedOutputStream bos = null;
    try{
        bis = new BufferedInputStream(new FileInputStream("H://a.txt"));
        bos = new BufferedOutputStream(new FileOutputStream("H://a.txt"));
        bos.write("我是Java界的小学生".getBytes());
        bos.flush();
        byte[] c = new byte[1024];
        int len = 0;
        while ((len = bis.read(c))!= -1){
            System.out.println(new String(c,0,len));
        }
    }catch (Exception e){
        e.printStackTrace();
    } finally {
        try {
            bis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            bos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

字符缓冲流

public static void main(String[] args) {
    BufferedReader bis = null;
    BufferedWriter bos = null;
    try{
        bis = new BufferedReader(new FileReader("H://a.txt"));
        bos = new BufferedWriter(new FileWriter("H://a.txt"));
        bos.write("我是Java界的小学生");
        bos.flush();
        char[] c = new char[1024];
        int len = 0;
        while ((len = bis.read(c))!= -1){
            System.out.println(new String(c,0,len));
        }
    }catch (Exception e){
        e.printStackTrace();
    } finally {
        try {
            bis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            bos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

序列化

ObjectInputStream&ObjectOutputStream

使用DataOutputStream可以将对象存入文件
使用DataInputStream可以取出该对象
使用他们的前提是，该对象及其属性都实现了序列化
首先构建一个实现了序列化的类

class Stu implements Serializable{
    String name;
    String clazz;
    int age;
    @Override
    public String toString() {
        return "Stu{" +
                "name='" + name + '\'' +
                ", clazz='" + clazz + '\'' +
                ", age=" + age +
                '}';
    }
}

然后将该对象存入文件

public static void main(String[] args) {
        ObjectInputStream is = null;
        ObjectOutputStream os = null;
        FileOutputStream fileOutputStream = null;
        FileInputStream fileInputStream = null;
        try {
            fileInputStream = new FileInputStream("H://a.txt");
            fileOutputStream = new FileOutputStream("H://a.txt");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        try {
            os = new ObjectOutputStream(fileOutputStream);
            is = new ObjectInputStream(fileInputStream);
            Stu s = new Stu();
            s.age = 18;
            s.clazz = "1年级1班";
            s.name = "荼蘼";//超级留级生
            os.writeObject(s);
            os.flush();

            Stu o = (Stu) is.readObject();
            System.out.println(o);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

Stu{name='荼蘼', clazz='1年级1班', age=18}

容易产生的问题

java.io.EOFException
	at java.io.ObjectInputStream$PeekInputStream.readFully(ObjectInputStream.java:2638)
	at java.io.ObjectInputStream$BlockDataInputStream.readShort(ObjectInputStream.java:3113)
	at java.io.ObjectInputStream.readStreamHeader(ObjectInputStream.java:853)
	at java.io.ObjectInputStream.<init>(ObjectInputStream.java:349)
	at com.dmlll.objects.Test.main(Test.java:19)

当新建一个文件存储ObjectOutputStream文件时，如果把ObjectInputStream放在ObjectOutputStream之前声明，则会报这个错误
读源码得知：
在这里插入图片描述

局部序列化

transient
修改Stu

class Stu implements Serializable {
    transient String name;
    String clazz;
    int age;
    @Override
    public String toString() {
        return "Stu{" +
                "name='" + name + '\'' +
                ", clazz='" + clazz + '\'' +
                ", age=" + age +
                '}';
    }
}

main方法不变
输出结果

Stu{name='null', clazz='1年级1班', age=18}

static
修改Stu

class Stu implements Serializable {
    static String name;
    String clazz;
    int age;
    @Override
    public String toString() {
        return "Stu{" +
                "name='" + name + '\'' +
                ", clazz='" + clazz + '\'' +
                ", age=" + age +
                '}';
    }
}

读取前将name设置为“小明”

Stu{name='小明', clazz='1年级1班', age=18}

在没有拿到序列化后的对象时，值可以被改变，说明name没有被序列化
3.实现Externalizable，重写writeExternal和readExternal
该类实际就是继承了Serializable接口，抽象出了这两个方法。
实现Serializable接口，重写这两个方法也可以
Java会调用ObjectOutputStream类检查Stu是否有私有的、无返回值的writeObject方法，如果有，Stu会委托该方法进行对象序列化。

修改Stu

class Stu implements Externalizable {
    String name;
    String clazz;
    int age;

    public Stu() {
    }

    @Override
    public String toString() {
        return "Stu{" +
                "name='" + name + '\'' +
                ", clazz='" + clazz + '\'' +
                ", age=" + age +
                '}';
    }

    public Stu(String name, String clazz, int age) {//必须要有构造器
        this.name = name;
        this.clazz = clazz;
        this.age = age;
    }

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeObject(clazz);
        out.writeObject(age);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        clazz = (String) in.readObject();
        age = (int)in.readObject();
    }
}

结果

Stu{name='null', clazz='1年级1班', age=18}

异常处理中流的关闭

1.7可以这么关

public static void main(String[] args) {
        try (FileOutputStream fileOutputStream = new FileOutputStream("H://a.txt");
             FileInputStream fileInputStream = new FileInputStream("H://a.txt");
        ObjectOutputStream os = new ObjectOutputStream(fileOutputStream);
            ObjectInputStream is = new ObjectInputStream(fileInputStream)){
            Stu s = new Stu();
            s.age = 18;
            s.clazz = "1年级1班";
            s.name = "荼蘼";//超级留级生
            os.writeObject(s);
            os.flush();
            s.name = "小明";
            Stu o = (Stu) is.readObject();
            System.out.println(o);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

但是如果有多个try块也挺麻烦的
java9可以这么搞

public static void main(String[] args) throws IOException {
        FileOutputStream fileOutputStream = new FileOutputStream("H://a.txt");
        FileInputStream fileInputStream = new FileInputStream("H://a.txt");
        ObjectOutputStream os = new ObjectOutputStream(fileOutputStream);
        ObjectInputStream is = new ObjectInputStream(fileInputStream);
        try (fileOutputStream;fileInputStream;os;is){
            Stu s = new Stu();
            s.age = 18;
            s.clazz = "1年级1班";
            s.name = "荼蘼";//超级留级生
            os.writeObject(s);
            os.flush();
            s.name = "小明";
            Stu o = (Stu) is.readObject();
            System.out.println(o);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

荼蘼2021

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java之IO流

File类：提示：这里可以添加学习目标例如：一周掌握 Java 入门知识学习内容：提示：这里可以添加要学的内容例如：1、搭建 Java 开发环境2、掌握 Java 基本语法3、掌握条件语句4、掌握循环语句学习时间：提示：这里可以添加计划学习的时间例如：1、周一至周五晚上 7 点—晚上9点2、周六上午 9 点-上午 11 点3、周日下午 3 点-下午 6 点学习产出：提示：这里统计学习计划的总量例如：1、技术笔记 2 遍2、CSDN 技术博客 3
复制链接

扫一扫