JavaIO

最新推荐文章于 2025-11-30 18:24:05 发布

原创最新推荐文章于 2025-11-30 18:24:05 发布 · 926 阅读

15 ·

CC 4.0 BY-SA版权

文章标签：

#java #servlet #开发语言

一，File类

File类时java.io包中很重要的一个类

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

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

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

1.File类的构造方法：

File(String pathName)

String pathName：指定路径地址如：

File file = new File(D:/植物大战僵尸:/植物大战僵尸.exe);

创建一个file对象，该对象内存储的是D盘，植物大战僵尸文件夹中的植物大战僵尸程序

2.File类的常用方法：

        File file = new File("D:\\25822");
        System.out.println(file.length());//获得文件内容长度
        System.out.println(new Date(file.lastModified()));//获得文件最后修改的时间

        System.out.println(file.getName());//获取文件名称
        System.out.println(file.getPath());//获取文件路径

        System.out.println(file.isHidden());//判断文件是否是隐藏文件
        System.out.println(file.canRead());//判断文件是否可读
        System.out.println(file.canWrite());//判断文件是否可写

        System.out.println(file.isFile());//判断File对象是否是文件
        System.out.println(file.isDirectory());//判断是否是文件夹

        System.out.println(file.exists());//判断文件是否存在

            File file = new File("E:b.txt");
            if (!file.exists()){ //判断文件是否存在

                file.createNewFile();//创建文件
            }
//        file.delete();//删除文件
            File file1 = new File("E:/demo/a/b/c");
            if (!file1.exists()){
                file1.mkdir();//创建单级文件夹
                file1.mkdirs();//创建多级文件夹
            }

二，输入及输出的概念：

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

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

三，流

1.流的分类：

从数据流编码格式上分：

字节流（byte）

字符流（char）

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

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

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

2.字节流：

InputStream和OutputStream的子类都是字节流可以读写二进制文件，主要处理音频、图片、歌曲、字节流,处理单元为1个字节。

字节流中常用类

字节输入流 FileInputStream

字节输出流 FileOutputStream

（1）输入流：InputStream的基本方法

int read（）读取一个字节并以整数的形式返回（0~255），如果返回-1已到输入流的末尾

int read（byte[] buffre）读取一系列的字节并存储到一个数组buffer，返回实际读取的字节数，如果读取前已到输入流的末尾返回-1

void close（）关闭流释放内存资源

（2）输出流：OutputStream的基本方法

void write（int b）向输入流中写入一个字节数据，该字节数据为参数b的低8位

void write（byte[] b , int off,int len）将一个字节类型的数组中的从指定位置开始的len个字节写道输入流

void close（）关闭流释放内存资源

        File file = new File("D:/typora-setup-x64.exe");
        Date date = new Date();
        FileInputStream inputStream = new FileInputStream(file);
        FileOutputStream outputStream = new FileOutputStream("D:/c.exe");
        int b = 0;
        while ((b = inputStream.read()) != -1){
            outputStream.write(b);
        }
        inputStream.close();
        outputStream.close();

        Date date1 = new Date();
        System.out.println(date1.getTime()-date.getTime());
        /*
            上面是read（）流的读写速度
         */

        File file = new File("D:/typora-setup-x64.exe");
        Date date = new Date();
        FileInputStream inputStream = new FileInputStream(file);
        FileOutputStream outputStream = new FileOutputStream("D:/c.exe");
        byte[] bytes = new byte[100];
        int length = 0;
        Date date2 = new Date();
        while ((length = inputStream.read(bytes)) != -1){
            length = bytes.length;
            outputStream.write(bytes,0,length);
        }
        outputStream.close();
        inputStream.close();
        System.out.println(date2.getTime()-date1.getTime());
        /*
            上面是read(byte[] b) 的读写速度
         */

由代码可知：使用数组传输的效率快于使用字节传输

3.字符流：

Reader和Witer的子类都是字符流，主要处理字符或字符串，字符流处理单元为一个字符。字符流将读取到的字节数据，去指定的编码表中获取对应的文字字符。

注：字符流只能读取纯文本文件。

字符流中的常用类

字符输入流：FileReader

字符输出流：FileWiter

（1）Reader的基本方法

int read（）读取一个字符并以整数的形式返回，如果返回-1已到输入流的末尾

int read（char[] chars）读取伊西流字符并存储到一个数组chars，返回实际读取的字符数，如果读取前已到输入流的末尾返回-1

void close（）关闭

（2）Writer的基本方法

void write（int c）向输入流中写入一个字符数据，该字节数据为参数b的16位

void write（char[] chars,int offset,int length）将一个字符类型的数组中的从指定位置开始的length个字符写入到输出流

void close（）关闭

        FileReader reader = new FileReader("D:/a.txt");
        FileWriter writer = new FileWriter("D:/b.txt");

        int c = 0;
        while ((c = reader.read()) != -1){
            writer.write(c);
        }
        writer.close();
        reader.close();

        FileReader reader = new FileReader("D:/a.txt");
        FileWriter writer = new FileWriter("D:/b.txt");
        char[] chars = new char[100];
        int length;
        while ((length = reader.read(chars)) != -1){
            writer.write(chars,0,length);
        }
        reader.close();
        writer.close();

4.节点流与处理流

根据封装类型不同的流又分为：节点流，处理流

节点流：

如果流封装的是如文件，字符串，字符串数组等，则称为节点流

处理流：

如果流封装的是其他流对象，称为处理流。处理流提供了额外功能

处理流中常用类：

缓冲字节输入流 BufferedOutputStream

缓冲字节输入流 BufferedInputStream

数据输出流 DataOutputStream

数据输入流 DataInputStream

缓冲字符输出流 BufferedWriter

缓冲字符输入流 BufferedReader

对象的输出流 ObjectOutputStream

对象的输入流 ObjectInputStream

（1）缓冲字节流

        /*
            缓冲字节流，内部有一个默认是8192长度的字节数组，进行一个数据的缓存
         */
        FileInputStream inputStream = new FileInputStream("D:/a.txt");
        BufferedInputStream bufferedInputStream =  new BufferedInputStream(inputStream,2048);
        FileOutputStream outputStream = new FileOutputStream("D:/b.txt");
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream,2048);
        byte[] bytes = new byte[1024];
        int length = 0;
        while ((length = bufferedInputStream.read(bytes)) != -1){
            bufferedOutputStream.write(bytes,0,length);
        }
        bufferedInputStream.close();
        bufferedOutputStream.flush();//刷新缓冲区
        bufferedOutputStream.close();

（2）缓冲字符流

        /*
            缓冲字符流
         */
        FileReader fileReader = new FileReader("D:/a.txt");
        BufferedReader bufferedReader = new BufferedReader(fileReader);

        FileWriter fileWriter = new FileWriter("D:/f.txt",true);//名称后加true，之后存入数据，会在原先数据后面追加
        BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);


/*        bufferedReader.readLine();//每次返回读到的一行信息*/
        String line = "";
        while ((line = bufferedReader.readLine()) != null){
            System.out.println(line);
            bufferedWriter.write(line);
            bufferedWriter.newLine();//换行
        }
        bufferedReader.close();
        bufferedWriter.flush();
        bufferedWriter.close();

（3）数据输入输出流

        String msg = "你好，吃饭了没？";
        FileOutputStream outputStream = new FileOutputStream("D:/msg.txt");
        DataOutputStream dataOutputStream = new DataOutputStream(outputStream);
        dataOutputStream.writeUTF(msg);//直接写出一个字符串
        dataOutputStream.flush();
        dataOutputStream.close();

        FileInputStream inputStream = new FileInputStream("D:/msg.txt");
        DataInputStream dataInputStream = new DataInputStream(inputStream);
        System.out.println(dataInputStream.readUTF());
        inputStream.close();
        dataInputStream.close();

（4）对象的输入输出流

当一个类需要被序列化（对象输出）时，该类需要实现Serializable接口，会自动为我们的类生成一个唯一的编号,
自动生成的编号，一旦类信息发生变化后，编号会自动改变
一般情况下可以为类固定的生成一个编号,当类信息改变时，编号不改变

public class Car implements Serializable {

    private static final long serialVersionUID = 7493226896858938521L;
    private int no;
    private String name;
    private  String color;

    public Car(int no,String name,String color){
        this.no = no;
        this.name = name;
        this.color = color;
    }


    @Override
    public String toString() {
        return "Car{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", color='" + color + '\'' +
                '}';
    }

java中对象都存储在内存中，一旦程序运行结束，内存中的对象都会消失
有时，需要在程序停止时，将对象诗句长久的保存下来，下次启动程序时，继续使用

IO中提供对象输入，输出流
这种对象操作，还称为对象序列化（输出），和反序列化（输入），也是Java中创建对象的一种方法之一

        Car car = new Car(123,"宝马","紫");
        FileOutputStream outputStream = new FileOutputStream("D:/c.txt");
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
        objectOutputStream.writeObject(car);
        System.out.println();
        objectOutputStream.flush();
        objectOutputStream.close();
        outputStream.close();