javaSE (六)：IO

李@*

已于 2024-04-24 16:30:40 修改

阅读量1.1k

点赞数 30

文章标签： java 算法开发语言

于 2024-04-12 21:48:05 首次发布

本文链接：https://blog.csdn.net/m0_70830675/article/details/137610147

版权

● InputStream和OutputStream的子类都是字节流

● Reader和Writer的子类都是字符流

一、File类

①File类是java.io包中很重要的一个类；

②File类的对象可以表示文件，还可以表示目录，在程序中一个File类对象可以代表一个文件或目录；

③File对象可以对文件或目录的属性进行操作，如：文件名、最后修改日期、文件大小等；

④File对象无法操作文件的具体数据，即不能直接对文件进行读/写操作。

● File类的构造方法

● File类的常用方法

！！!具体实现可以看下面这段代码:

public class FileDemo1 {
    public static void main(String[] args) {

        /*
          File类：一个File类对象可以表示一个具体的文件或目录
        */
        File f1 = new File("D:/demo.txt");
        System.out.println(f1.canRead());//是否可以读入
        System.out.println(f1.canWrite());//是否可以写入
        System.out.println(f1.exists());//判断文件或目录是否存在
        System.out.println(f1.getAbsolutePath());//获取文件地址
        System.out.println(f1.getName());//获取文件名称
        System.out.println(f1.getParent());//获取上一级名称
        System.out.println(f1.isDirectory());//是否是一个文件夹
        System.out.println(f1.isFile());//是否是一个文件
        System.out.println(f1.lastModified());//最后一次修改时间
        System.out.println(new Date(1712645438471L));
        System.out.println(f1.length());//获取文件内容长度
        System.out.println(f1.isHidden());//判断文件是否隐藏

    }
}

创建文件，删除文件，操作如下：

public class FileDemo2 {
    public static void main(String[] args) throws IOException {

        File f1 = new File("D:/a.txt");
        if (!f1.exists()){
            System.out.println(f1.createNewFile());//创建文件
        }
        System.out.println(f1.delete());//删除文件或文件夹

        File file = new File("D:/download");
        System.out.println(file.mkdir());//创建单级文件

        File file = new File("D:/download/a/b");
        System.out.println(file.mkdirs());//创建多级对象
      
        File file = new File("D:/download/a/b");
          file.delete();//删除文件夹,先删除最后一级b

给定一个文件目录，如何得到该文件下的子集呢？

 File file = new File("D:/download/a");

        File[] files = file.listFiles();//将子级装进数组里
        for (File f : files){
           System.out.println(f);
        }

删除文件时，文件必须是空的。如果该文件里面有内容，就不会删除，可以先进行判断，判断到底是一个文件还是文件夹，是文件直接删除，是文件夹删除该文件夹的子级

操作如下：

public class FileDemo2 {
    public static void main(String[] args) throws IOException {

        File file = new File("D:/download/a");
//        file.delete();//删除文件夹时，文件夹必须是空的
        File[] files = file.listFiles();
        for (File f : files){
//            System.out.println(f);
            if (f.isFile()){//如果是文件就直接删除
                f.delete();
            }else{//如果是文件夹，输出该文件夹的子集删除
                f.listFiles();
            }

        }
    }
}

二、输入及输出的概念

● 输入输出（I/O）

把电脑硬盘上的数据读到程序中，称为输入,即input，进行数据的read 操作

从程序往外部设备写数据，称为输出，即output，进行数据的write 操作

三、输入流与输出流

● 流按着数据的传输方向分为：

● 输入流：往程序中读叫输入流。

● 输出流：从程序中往外写叫输出流。

●从数据流编码格式上划分为：

● 字节流

● 字符流

● InputStream和OutputStream的子类都是字节流

可以读写二进制文件，主要处理音频、图片、歌曲、字节流,处理单元为1个字节。

● Reader和Writer的子类都是字符流

主要处理字符或字符串，字符流处理单元为1个字符。字节流将读取到的字节数据，去指定的编码表中获取对应文字字符。

四、字节流与字符流

● 字节流中常用类

字节输入流 FileInputStream

字节输出流 FileOutputStream

● 字符流中常用类

字符输入流 FileReader

字符输出流 FileWrite

五、输入输出节点字节流

●InputStream的基本方法

①读取一个字节并以整数的形式返回(0~255),如果返回-1已到输入流的末尾。

int read() throws IOException

②读取一系列字节并存储到一个数组buffer，返回实际读取的字节数，如果读取前已到输入流的末尾返回-1

int read(byte[] buffer) throws IOException

关闭流释放内存资源

void close() throws IOException

● OutputStream的基本方法

①向输出流中写入一个字节数据,该字节数据为参数b的第8位

void write(int b) throws IOException

②将一个字节类型的数组中的从指定位置（off）开始到 len个字节写入到输出流

void write(byte[] b, int off, int len) throws IOException

关闭流释放内存资源

void close() throws IOException

① 读入写入一个字节：

public class StreamDemo1 {
    public static void main(String[] args) throws IOException {
//        输入 ：从硬盘上把文件读入到程序

       // 方式一：
        File file = new File("D:/demo.txt");
        FileInputStream inputStream = new FileInputStream(file);

       // 方式二：
        FileInputStream inputStream = new FileInputStream("D:/demo.txt");

//        输出：将程序中的文件输出到另一个盘上
        FileOutputStream outputStream = new FileOutputStream("C:/demo.txt");

        int b = 0;
        while ((b=inputStream.read())!=-1){
            System.out.println(b);
            outputStream.write(b);
        }

        inputStream.close();//关闭管道
        outputStream.close();
    }
}

②读入写入一系列字节并存储在一个数组中：

public class StreamDemo2 {
    public static void main(String[] args) throws IOException {

        FileInputStream inputStream = new FileInputStream("D:/demo.txt");

        FileOutputStream outputStream = new FileOutputStream("C:/demo.txt");

        byte[] bytes = new byte[10];//相当于将10个字节装进一个小推车
//        read(bytes); 一次读byte数组长度个字节，，文件读取完毕后返回返回-1
//          size 每次实际往数组中加入的元素个数
        int size = 0;
        while ((size = inputStream.read(bytes))!=-1){
            System.out.println(size);
            //一次向外写出一个byte数组长度个字节内容，从指定的位置开始写，写size个
            outputStream.write(bytes,0,size);
        }
        inputStream.close();
        outputStream.close();
    }
}

六、节点流与处理流

● 根据封装类型不同流又分为

节点流

处理流

● 节点流：

如果流封装的是某种特定的数据源，如文件、字符串、字符串数组等，则称为节点流。

节点流中常用类

字节输入流 FileInputStream

字节输出流 FileOutputStream

字符输入流 FileReader

字符输出流 FileWriter

● 处理流:

如果流封装的是其它流对象，称为处理流。处理流提供了缓冲功能，提高读写效率,同时增加了一些新的方法

处理流中常用类

缓冲字节输出流 BufferedOutputStream

缓冲字节输入流 BufferedInputStream

缓冲字符输入流 BufferedReader

缓冲字符输出流 BufferedWriter

①字节流

比如下面写出缓冲字节流输入输出的具体操作：

public class StreamDemo3 {
    public static void main(String[] args) throws IOException {
        //FileInputStream 直接封装数据，称为节点流（最基础去读数据的流）
        FileInputStream inputStream = new FileInputStream("D:/demo.txt");
        //BufferedInoutStream 封装的是一个节点流对象，可以提供缓冲功能，称为处理流或包装流，缓冲字节输入流，默认缓冲区大小是8192个字节
        BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream,20);//可以自定义缓冲区大小

        FileOutputStream outputStream = new FileOutputStream("C:/demo.txt");
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream,20);

           byte[] bytes = new byte[10];
           int size = 0;
           while ((size = bufferedInputStream.read(bytes))!=-1){
           bufferedOutputStream.write(bytes,0,size);
        }

           bufferedInputStream.close();
           bufferedOutputStream.close();
           bufferedOutputStream.flush();
    }
}

下面再举一个数据输入输出流的例子吧

！！！模拟控制台输入信息到D盘中的文本文件再输出回来

public class StreamDemo4 {
    public static void main(String[] args) throws IOException {
        //第一步：控制台输入信息
        Scanner scanner = new Scanner(System.in);
        String message = scanner.next();

        //数据输入输出字节流（包装流/处理流）
        FileOutputStream fileOutputStream = new FileOutputStream("D:/message.txt");

        DataOutputStream dataOutputStream = new DataOutputStream(fileOutputStream);
        dataOutputStream.writeUTF(message);//可以直接将字符串写出（内部进行转换）
        dataOutputStream.flush();
        dataOutputStream.close();

        FileInputStream fileInputStream = new FileInputStream("D:/message.txt");

        DataInputStream dataInputStream = new DataInputStream(fileInputStream);
        String s = dataInputStream.readUTF();//可以直接将读取到的数据转为String
        System.out.println(s);
    }
}

②字符流

比如下面写出缓冲字符流输入输出的具体操作：

public class CharDemo3 {
    public static void main(String[] args) throws IOException {
       
        FileReader reader = new FileReader("D:/demo.txt");
        FileWriter writer = new FileWriter("D:/demo1.txt",true);//保留原来的内容，在原内容的基础上向后续写

        BufferedReader bufferedReader = new BufferedReader(reader);
        BufferedWriter bufferedWriter = new BufferedWriter(writer);

              String line = null;
              while((line = bufferedReader.readLine())!=null){
                 bufferedWriter.write(line);
                 bufferedWriter.newLine();//插入换行符
              }
              bufferedReader.close();
              bufferedWriter.close();
    }
}

七、输入输出节点字符流

●Reader 的基本方法

读取一个字符并以整数的形式返回, 如果返回-1已到输入流的末尾。

int read() throws IOException

读取一系列字符并存储到一个数组buffer，返回实际读取的字符数，如果读取前已到输入流的末尾返回-1

int read( char[] cbuf) throws IOException

关闭void close() throws IOException

• Writer 的基本方法

向输出流中写入一个字符数据,该字节数据为参数b的16位

void write(int c) throws IOException

一个字符类型的数组中的数据写入输出流

void write( char[] cbuf) throws IOException

将一个字符类型的数组中的从指定位置（off set）开始的 length个字符写入到输出流

void write( char[] cbuf, int off set, int length) throws IOException

关闭void close() throws IOException

①读入写入一个字符数据：

public class CharDemo1 {
    public static void main(String[] args) throws IOException {
        /*
         字符流只能读文本文件，会将读到的字节结合编码表转换为一个字符编码
        */
        FileReader reader = new FileReader("D:/demo.txt");
        FileWriter writer = new FileWriter("D:/demo1.txt");
        int c = 0;
        while ((c= reader.read())!=-1){
            writer.write(c);
        }
        reader.close();
        writer.close();
    }
}

②读入写入一系列字符并存储在一个数组中：

public class CharDemo2 {
    public static void main(String[] args) throws IOException {
        /*
         字符流只能读文本文件，会将读到的字节结合编码表转换为一个字符编码
        */
        FileReader reader = new FileReader("D:/demo.txt");
        FileWriter writer = new FileWriter("D:/demo1.txt");
        char[] chars = new char[2];
        int size = 0;
        while ((size= reader.read(chars))!=-1){
            System.out.println(size);
            writer.write(chars,0,size);
        }
        reader.close();
        writer.close();
    }
}

八、对象输入输出流——对象序列化

● 对象的寿命通常随着生成该对象的程序的终止而终止。有时候，可能需要将对象的状态保存下来，在需要时再将对象恢复。

（比如说，系统升级，关闭服务器时将对象保存起来，升级完毕，重新再把数据还原回来）

● 对象的输入输出流 :

主要的作用是用于写入对象信息与读取对象信息。对象信息一旦写到文件上那么对象的信息就可以做到持久化了

（简单来说就是把java中的对象输出到文件中，从文件把对象输入到程序）

①把对象输出到文件的过程也称为对象的序列化

②再把对象从文件输入到程序得过程称为对象的反序列化，反序列化时会生成一个新的对象，所以反序列化也是创建对象的一种形式

对象的输出流:ObjectOutputStream

对象的输入流:ObjectInputStream

● 在ObjectInputStream 中用readObject()方法可以直接读取一个对象

ObjectOutputStream中用writeObject()方法可以直接将对象保存到输出流中

public class ObjectStream {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        String s = new String("abc");
        Date date = new Date();
        //对象输出：对象的序列化
        FileOutputStream fileOutputStream = new FileOutputStream("D:/obj.txt");
        ObjectOutput output = new ObjectOutputStream(fileOutputStream);
                     output.writeObject(s);
                     output.writeObject(date);
                     output.close();
                     output.flush();
        //对象输入：对象的反序列化             
        FileInputStream fileInputStream = new FileInputStream("D:/obj.txt");
        ObjectInput input = new ObjectInputStream(fileInputStream);
                     String s =(String)input.readObject();
                     Date date = (Date) input.readObject();
        System.out.println(s);
        System.out.println(date);
        input.close();
    }
}

新建一个自定义的Student类，如果一个类需要被序列化到文件中，那么这个类需要实现Serializable接口，实现后，会自动为该类生成一个序列化编号，编号是类的唯一标识

public class Student implements Serializable {

    /* 如果一个类需要被序列化到文件中，那么这个类需要实现Serializable接口，实现后，会自动为该类生成一个序列化编号

         编号是类的唯一标识

     但是自动生成的编号在类信息改变后，会重新为类生成一个编号
     可以在类中显示的生成一个编号，这样类信息修改后，也不会改变
   */
    private int num;
    private String name;

    public Student(int num, String name) {
        this.num = num;
        this.name = name;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class ObjectStream1 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
       //当一个类的对象需要被序列化到文件时，这个类必须要生成一个序列化编号
        Student student = new Student(13,"黎明");
        //对象输出：对象的序列化
        FileOutputStream fileOutputStream = new FileOutputStream("D:/obj.txt");
        ObjectOutput output = new ObjectOutputStream(fileOutputStream);
                     output.writeObject(student);
                     output.close();
                     output.flush();

        //对象输入：对象的反序列化
        FileInputStream fileInputStream = new FileInputStream("D:/obj.txt");
        ObjectInput input = new ObjectInputStream(fileInputStream);
        Student student =(Student)input.readObject();
        System.out.println(student);
        input.close();
    }
}

李@*

关注

30
点赞
踩
21

收藏

觉得还不错? 一键收藏
0
评论
javaSE (六)：IO

①File类是java.io包中很重要的一个类；②File类的对象可以表示文件，还可以表示目录，在程序中一个File类对象可以代表一个文件或目录；③File对象可以对文件或目录的属性进行操作，如：文件名、最后修改日期、文件大小等；④File对象无法操作文件的具体数据，即不能直接对文件进行读/写操作。
复制链接

扫一扫