Java I/O流(File、字节流、字符流、过滤流、对象流）详解

最新推荐文章于 2023-01-21 21:12:27 发布

黎明之道

最新推荐文章于 2023-01-21 21:12:27 发布

阅读量402

点赞数

分类专栏： JAVA 文章标签： I/O java File 输入输出流字符流

本文链接：https://blog.csdn.net/sjjsaaaa/article/details/119276911

版权

JAVA 专栏收录该内容

23 篇文章 1 订阅

订阅专栏

File以及I/O流

一、File类的使用

java.io.File类

java.io.File类作用：
每个File类的对象表示一个磁盘文件或目录，其对象属性中包含了文件或目录的相关信息，如名称、长度、所含文件个数等，调用它的方法则可以完成对文件或目录的常用管理操作，例如，创建、删除等操作。
Java中文件或者目录的路径表示

Windows中文件或者目录的表示D:\Wenjianjia\1.txt
Java中文件或者目录的表示D:\Wenjianjia\1.txt，或者D:/Wenjianjia/1.txt

File类的构造方法:
由于File类的每一个对象都表示的是一个具体的目录或者文件，所以File类没有提供无参的构造方法，File类的所有构造方法都需要一个目录或者文件的路径作为参数

File(String pathname)
File(String parent, String child)
File(File parent, String child)

File类常用方法：

boolean **createNewFile()**创建一个新文件
boolean **mkdir() / mkdirs()**创建新的目录
boolean delete() 删除文件或者目录
void deleteOnExit() 虚拟机退出时删除文件或者目录
boolean exists() 判断当前文件或者目录是否存在
boolean isFile() 判断File对象代表的是否是一个文件
boolean isDirectory() 判断File对象代表的是否是一个目录
String getPath() 返回当前File对象的字符串路径
String **getName()**返回当前File对象的文件名或者目录名
String **getParent()**返回当前File对象的父级目录
String getAbsolutePath()返回当前File对象的绝对路径
String[] **list()**返回当前File对象包含的子目录以及文件
**canExecute()**测试应用程序是否可以执行此抽象路径名表示的文件。
canRead() 是否可读
canWritr() 是否可以修改
isAbsoluteFile() 是否为绝对路径
renameTo() 重命名

package com.File_IO.File_1;

import java.io.File;
import java.io.IOException;
import java.util.Arrays;

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

        File file = new File("H:\\File");//代表硬盘上的一个文件或者目录
        file = new File("src\\com\\File_IO\\File_1");
        //绝对路径：从盘符开始的路径
        //相对路径：参考当前项目的路径

        //测试应用程序是否可以  执行  此抽象路径名表示的文件。
        boolean b = file.canExecute();
        System.out.println(b);//true

        boolean b1 = file.canRead();//是否可以读
        boolean b2 = file.canWrite();//是否可以修改
        //file.delete();//删除此抽象路径名表示的文件或目录。
        //file.deleteOnExit();// 在虚拟机终止时，请求删除此抽象路径名表示的文件或目录。
        boolean exists = file.exists();//测试此抽象路径名表示的文件或目录是否存在。
        String name = file.getName();//返回由此抽象路径名表示的文件或目录的名称。
        String parent = file.getParent();// 返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。
        File parentFile = file.getParentFile();// 返回此抽象路径名父目录的抽象路径名；如果此路径名没有指定父目录，则返回 null。
        String path = file.getPath();// 将此抽象路径名转换为一个路径名字符串。//H:\File
        boolean absolute = file.isAbsolute();//是否为绝对路径
        File absoluteFile = file.getAbsoluteFile();//返回绝对路径

        boolean directory = file.isDirectory();// 测试此抽象路径名表示的文件是否是一个目录。是否为文件夹
        boolean file1 = file.isFile();//是否为文件
        boolean hidden = file.isHidden();//是否是一个隐藏文件。
        long length = file.length();//表示的 文件 的长度。
        String[] list = file.list();//返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录//如果是文件返回Null
        File[] files = file.listFiles();//文件数组
        file.renameTo(new File("H:\\File"));//更名

        System.out.println(Arrays.asList(list));//[Wnjian.java]



        //文件创建
        File fil = new File("H:\\File\\wenjian");//代表硬盘上的一个文件或者目录
        boolean mkdir = fil.mkdir();//创建文件夹，前提是父级目录存在，创建多级目录用mkdirs.

        File fil_1 = new File("H:\\File\\te.txt");//代表硬盘上的一个文件或者目录
        fil_1.createNewFile();//创建文件，必须要父级目录存在
        

    }
}

递归：

package com.File_IO.Digui;

import java.io.File;

public class Main {
    public static void main(String[] args) {
        //递归
        int fbnq = fbnq(10);
        System.out.println(fbnq);//55

        //求和
        int sum = sum(100);
        System.out.println(sum);//5050

        //查看文件的所有文件
        printFile(new File("D:\\AdobeDownloadAssistant"));
    
    }

    //打印出这个文件夹下的所有文件
    public static void printFile(File file){
        if(!file.exists()){
            System.out.println("文件不存在！");
            return;
        }
        if(file.isFile()){
            System.out.println(file);
            return;
        }
        System.out.println(file);//打印本身
        File[] files = file.listFiles();//自己文件或目录
        if(files!=null || files.length>0){
            for (int i = 0; i < files.length; i++) {
                File file1 = files[i];
                printFile(file1);
            }
        }

    }



    //斐波那契数列  ：从第三位开始，后一位是前两位之和
    //1 1  2  3  5  8  13  21
    public static int fbnq(int n){

        if(n == 1 || n==2){
            return 1;
        }
        return fbnq(n-1)+fbnq(n-2);
    }


    //求1-n整数的和
    public static int sum(int n){
        if(n==1){
            return 1;
        }
        int s = n+sum(n-1);
        return s;
    }

}

二、I/O流

1.流的概念

流是一组有序的，有起点和终点的字节集合，是对计算机中数据传输的总称或者抽象
即数据在两个设备间的传输称为流，流的本质是数据传输。
流序列中的数据可以是没有进行加工的原始数据（二进制字节数据），也可以是经过编码的符合某种格式规定的数据，Java中提供了不同的流类对它们进行处理。

请添加图片描述

2.流的分类

按照流传输方向不同

输入流（InputStream）
输出流（OutputStream）

按照处理数据类型的不同

字节流
字符流

按照流的基本功能不同

节点流
过滤流

输入流（InputStream）:
在Java中，程序可以打开一个输入流，输入流的信息源可以位于文件、内存或网络套接字(socket)等地方，信息源的类型可以是包括对象、字符、图像、声音在内的任何类型。一旦打开输入流后，程序就可从输入流串行地读数据。

输出流（OutputStream）:
类似地，程序也能通过打开一个输出流并顺序地写入数据来将信息送至目的端。

①字节流：

字节流的概念
传输的数据单位是字节，也意味着字节流能够处理任何一种文件

字节流的组成

字节输入流 InputStream
字节输出流 OutputStream

请添加图片描述

import java.io.*;

public class Zijie {
    public static void main(String[] args) throws Exception {

//字节流输入流

        //创建FIle对象
        File file = new File("H:\\File\\a.txt");
        //创建流通到
        FileInputStream input = new FileInputStream(file);
        //读数据
//        while (true) {
//            int read = input.read();
//            if(read<0){
//                break;
//            }
//            System.out.println((char) read);
//        }

        int c = -1;
        while ((c = input.read())>0){
            System.out.print((char)c);
        }
        //关闭
        input.close();
        
//字节流输出流

        //创建File对象
        File fi = new File("H:\\File\\te.txt");
        FileOutputStream out  = new FileOutputStream(fi);
        out.write(101);
        out.flush();//刷新
        out.close();//关闭
    }
}

将图片复制到另一个文件夹：

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class Pictu {
    public static void main(String[] args) throws Exception {

        File file = new File("H:\\File\\xxx\\love-018.jpg");
        FileInputStream inp = new FileInputStream(file);

        File file1 =  new File("H:\\File\\yyy\\love-018.jpg");
        if(!file1.exists()){
            file1.createNewFile();
        }
        FileOutputStream out = new FileOutputStream(file1);

        int len = -1;
        byte[] buffer = new byte[1024];

        while ((len = inp.read(buffer))>0){
            out.write(buffer,0,len);
        }

        out.flush();
        out.close();
        inp.close();
    }
}

②字符流：

InputStreamReader OutputStreamWriter

FileReader FileWriter

import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;

public class ZiFuliu {
    public static void main(String[] args) throws Exception{

        //字符流

        //创建Dile对象
        File file = new File("H:\\File\\a.txt");
        //创建字节流
        FileInputStream fis = new FileInputStream(file);
        //创建字符流
        InputStreamReader isr = new InputStreamReader(fis);

        int read = isr.read();
        System.out.println((char)read);//啊

        char[] buf = new char[5];
        int len = -1;
        while ((len = isr.read(buf))>0){
            System.out.print(new String(buf,0,len));
//            System.out.print(buf);
        }


        isr.close();
        fis.close();

    }
}

将文件复制到另一个文件夹：

import java.io.*;

public class WenBenZhuanYi {
    public static void main(String[] args) throws Exception{

        File file = new File("H:\\File\\a.txt");
        FileInputStream fis = new FileInputStream(file);
        InputStreamReader isr = new InputStreamReader(fis);

        File file1 = new File("H:\\File\\yyy\\a.txt");
        if(!file1.exists()){
            file1.createNewFile();
        }
        FileOutputStream fos = new FileOutputStream(file1);
        OutputStreamWriter osw = new OutputStreamWriter(fos);

        char[] buf = new char[1024];
        int len= -1;
        while((len = isr.read(buf))>0){
            osw.write(buf,0,len);
        }
        osw.flush();
        osw.close();
        fos.close();
        isr.close();
        fis.close();
        System.out.println("复制完成！");

    }
}

简单写法：

import java.io.FileReader;
import java.io.FileWriter;

public class File_shur {
public static void main(String[]args)throws Exception{

    //输入流
    FileReader fr = new FileReader("H:\\File\\yyy");
    fr.close();
    
    //输出流      append:ture 是否追加 是的
    FileWriter fw = new FileWriter("H:\\File\\yyy\\a.txt",true);
    fw.write("hello");
    fw.append("hello");
    fw.append("hello");
    fw.append("hello");

    fw.flush();
    fw.close();
    }
}

小结：

File file = new File(“H:\File\a.txt”); 创建File对象
FileInputStream fis = new FileInputStream(file);创建字节输入流
InputStreamReader isr = new InputStreamReader(fis);创建字符输入流

File file1 = new File(“H:\File\yyy\a.txt”);创建file对象

if(!file1.exists()){ 判断文件是否存在
file1.createNewFile();
}
FileOutputStream fos = new FileOutputStream(file1);创建字节输出流
OutputStreamWriter osw = new OutputStreamWriter(fos);创建字符输出流

osw.flush();刷新
osw.close();关闭

FileReader fr = new FileReader(“H:\File\yyy”); 输入流包含上面三个步骤
FileWriter fw = new FileWriter(“H:\File\yyy\a.txt”,true); 输出流包含上面三个步骤

③过滤流：

ObjectStream
ObjectInputStream
ObjectOutputStream
ObjectStream特点
writeObject()
readObject()
对象序列化

Data Stream
DataInputStream
readXxx();
DataOutputStream
writeXxx();

过滤流的开发步骤：

创建节点流
基于节点流创建过滤流
读/写数据
关闭外层流

DataOutputStream DataInputStream

package com.File_IO.GuoLvLiu;

import java.io.*;

public class Data_Stream {
    public static void main(String[] args)throws Exception {

        //过滤流

//写

        //创建目标文件对象
        File file1 = new File("H:\\File\\a.txt");
        //创建字节输出流
        FileOutputStream fos = new FileOutputStream(file1);
        //字节过滤流通道
        DataOutputStream dos = new DataOutputStream(fos);

        dos.writeInt(97);
        dos.flush();
        dos.close();

        System.out.println("存储完成");


//读
        File file2 = new File("H:\\File\\a.txt");
        FileInputStream fis = new FileInputStream(file2);
        DataInputStream dis = new DataInputStream(fis);
        int i = dis.readInt();
        System.out.println(i);
        dis.close();


    }
}

④字节数组输出流：

ByteArrayOutputStream

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;

public class Butter {
    public static void main(String[] args) throws Exception {

        //缓存流

        File file = new File("H:\\File\\a.txt");
        FileInputStream fis = new FileInputStream(file);

        //字节数组输出流
        ByteArrayOutputStream baos = new ByteArrayOutputStream();


        //读
        byte[] a = new byte[10];
        int len = -1;
        while ((len = fis.read(a)) > 0) {
            baos.write(a, 0, len);
//            System.out.print(new String(a,0,len));
        }
        baos.flush();
        fis.close();
        String s = baos.toString();

        System.out.println(s);//sajkdbafuiwqdjkscbjkscbsmbasf

    }
}

⑤字符流的过滤流：

BufferedReader

PrintWriter

transient 关键字
序列化时注意事项
不要使用追加的方式写对象
如果一个对象的属性又是一个对象，则要求这个属性对象也实现了Serializable接口

BufferedReader

字符过滤流
提供了缓冲功能
可以一行一行的读取内容
public String readLine()

完整的字符输入流的开发步骤

创建节点流
桥转换为字符流
在字符流的基础上封装过滤流
读/写数据
关闭外层流

package com.File_IO.Duixiang;

import java.io.*;

public class Main {
    public static void main(String[] args)throws Exception {

//字符流的过滤流

        File file =new File("H:\\File\\a.txt");
        FileInputStream fis = new FileInputStream(file);
        InputStreamReader isr = new InputStreamReader(fis);
//写   FileReader
        //字符流过滤流
        BufferedReader br = new BufferedReader(isr);

        // String s = br.readLine();//读取一行
        // System.out.println(s);

        String s =null;
        while((s = br.readLine())!=null){
            System.out.println(s);
        }
        br.close();
//读  FileWriter


        FileWriter fi = new FileWriter("H:\\File\\bb.txt");
//        BufferedWriter dw = new BufferedWriter(fi);
//        dw.write("sad");
//        dw.newLine();//换行
//        dw.flush();
//        dw.close();

        //常用
        PrintWriter out = new PrintWriter(fi,true);
        //是否自动刷新  true 是
        out.println("asdadadfsdxvnxjvb");
        out.close();


    }
}

三、对象流以及对象的序列化

import java.io.*;

public class DuiXiang  {
    public static void main(String[] args) throws Exception {

        //对象流   输入输出流
//写
        File file = new File("H:\\File\\QQQ.txt");
        FileOutputStream fos = new FileOutputStream(file);

        ObjectOutputStream oos = new ObjectOutputStream(fos);

        //序列化  和反序列化    实现implements Serializable便可以实现序列化
        Student stu =new Student("张三",19);
        Student stu1 =new Student("ad",2);
        Student stu2 =new Student("adasd",4);
        oos.writeObject(stu);
        oos.writeObject(stu1);
        oos.writeObject(stu2);
        oos.flush();
        oos.close();


//读
        File file1 = new File("H:\\File\\QQQ.txt");
        FileInputStream fit = new FileInputStream(file1);
        ObjectInputStream ois = new ObjectInputStream(fit);
//        int len = 0;
        while (fit.available()>0){
            Object o = ois.readObject();
            System.out.println(o);
        }

//        Object o = ois.readObject();
//        System.out.println(o);//Student{name='张三', age=19}
        ois.close();

    }
}