IO流和输入输出

叫我剑锋

已于 2023-03-18 22:04:10 修改

阅读量159

点赞数

分类专栏： JavaSE 文章标签： java

于 2023-03-18 22:01:53 首次发布

本文链接：https://blog.csdn.net/weixin_56846554/article/details/129642435

版权

JavaSE 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

一、File类

File类是java.io包中很重要的一个类；
File类的对象可以表示计算机硬盘上的文件或目录，在程序中一个File类对象可以代表一个文件或目录；
File对象可以对文件或目录的属性进行操作，获取文件信息、创建文件、删除文件；
File对象无法操作文件的具体数据，即不能直接对文件进行读/写操作。

File类的构造方法：

方法原型	说明
File（String pathname）	指定文件（或目录）名和路径创建文件对象

//在当前目录下创建一个与aaa.txt文件名相关联的文件对象

File f1 = new File("aaa.txt");

//指明详细的路径以及文件名，请注意双斜线或用反斜杠

File f2 = new File("D:\\Java\\Hello.java");

//指明详细的路径以及目录名，请注意双斜线

File f3 = new File("D:\\Java");

File类的常用方法

方法原型	说明
boolean exists()	判断文件是否存在，存在返回true，否则返回false
boolean isFile()	判断是否为文件，是文件返回true，否则返回false
boolean isDirectory()	判断是否为目录，是目录返回true，否则返回false
String getName()	获得文件的名称
long length()	获得文件的长度（字节数）
boolean createNewFile() throws IOException	创建新文件，创建成功返回true，否则返回false，有可能抛出IOException异常，必须捕捉
boolean delete()	删除文件，删除成功返回true，否则返回false
public String[] list()	将目录下的子目录及文件的名字，返回到String数组中
public File[] listFiles()	将目录下的子目录及文件的实例返回到File数组中

代码示例：

    public static void main(String[] args) {
        //E盘在demo文档最后修改时间
        File f = new File("E:/demo.txt");
        System.out.println(new Date(f.lastModified()));

        //把父集跟子集拆分，可写多个子集
        String p = "E:/";
        File f5 = new File(p,"demo.txt");
        File f6 = new File(p,"demo.txt");
        System.out.println(f5.lastModified());

        File pf = new File("E:");
        File fn = new File(pf,"demo.txt");
        System.out.println(fn.lastModified());

        File f1 = new File("E:/demo.txt");
        //测试程序是否可以执行此路径名表示的文件
        System.out.println(f1.canExecute());
        //测试程序是否可以读取此路径名表示的文件
        System.out.println(f1.canRead());
        //测试程序是否可以修改此路径名表示的文件
        System.out.println(f1.canWrite());


        System.out.println("===============");
        //路径表示的文件或目录是否存在
        System.out.println(f1.exists());
        System.out.println(f1.getAbsolutePath());//获得文件绝对地址
        //返回路径表示的文件或目录的名称
        System.out.println(f1.getName());
        //将此路径名转化为路径名字符串
        System.out.println(f1.getPath());

        System.out.println(f1.isAbsolute());//是不是绝对路径

        System.out.println(f1.isDirectory());//是否为目录
        System.out.println(f1.isFile());
        System.out.println(f1.isHidden());//是不是隐藏文件

        System.out.println(new Date(f1.lastModified()));//文件最后一次修改时间
        System.out.println(f1.length());//文件字节长度
    }

文件操作：

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

        File F = new File("E:/a.txt");

        //底层代码
        /*
        if(!f.exists()){
            try {
                f.createNewFile();//创建一个文件
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        */

        //删除文件，存在返回true，不存在返回false；
        System.out.println(f.delete());

        File d = new File("E:/a/b/c");//无后缀就是文件夹
             d.mkdir();//创建单级文件夹
             d.mkdirs();//创建多级文件夹
             d.delete();//删除文件夹，文件夹必须是空的

        //过滤文件
        File f1 = new File("E:/api");
        String[] fs1 = f1.list();
        for (String s : fs1){
            System.out.println(s);
        }

        //获取指定目录下的所以子集文件和目录，过滤筛选指定文件
        File f = new File("E:/api");
        File[] fs = f.listFiles((e)->{return e.getName().endsWith("chm");});
        for (File s : fs){
            System.out.println(s);
        }
    }
}

二、输入输出的概念

输入输出（I/O）

把电脑硬盘上的数据读到程序中，称为输入,即input,进行数据的read操作
从程序往外部设备写数据，称为输出，即output，进行数据的write操作

三、输入流和输出流

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

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

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

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

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

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

主要处理字符或字符串，字符流处理单元为1个字符。

字节流将读取到的字节数据，去指定的编码表中获取对应文字。

四、字节流和字符流

按照流（java提供的读写文件的类）的读写单位划分为：

字节流：每次读写是以字节为单位（计算机中的所有数据存储都是字节为单位）
可以读取任意文件
字符流：每次读写是以字符为单位，只能读取纯文本文件（txt,java,html）

字节流中常用类

字节输入流 FileInputStream

字节输出流 FileOutputStream

字符流中常用类

字符输入流 FileReader

字符输出流 FileWriter

五、输入输出节点字节流

● 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 StreamDemo01 {

    public static void main(String[] args) throws IOException {
        //创建一个输入流字节对象，并为其指定要读入的对象
        FileInputStream in = new FileInputStream("E:/demo.txt");
        //输入的源文件不存在，会报错
        FileOutputStream out = new FileOutputStream("E:/demo.txt");
        //输出时文件不存在是可以自动创建的

        //in.read() 没有参数,每次读到一个字节的数据，并返回，直到读完后返回-1；
        System.out.println(in.read());
        System.out.println(in.read());
        System.out.println(in.read());

        int b = 0;
        while((b=in.read())!=-1){
            //System.out.println(b);
            out.write(b);
        }
        in.close();
        out.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 StreamDemo02 {
    public static void main(String[] args) throws IOException {

        FileInputStream in = new FileInputStream("E:\\非凡英才\\1Java\\2021-12-25IO\\练习\\练习.txt");
        FileOutputStream out = new FileOutputStream("E:/demo.txt");
        //read()  write(int b) 每次只能读入写出一个字节，效率低，读写次数多

        //in.read(b); 每次读一个byte数组个字节内容，返回实际向数组装入的字节数量，读完也是返回-1；
                   byte[] b = new byte[1024];
                   int size = 0;//实际字节长度
                   in.read(b);
                   int num = 0;
                   while((size=in.read())!=-1){
                       num++;
                       System.out.println(size);
                       out.write(b,0,size);
                       //out.write(b,0,size); 每次向外写出一个byte数组个字节，从第0个开始，写size个
                   }
        System.out.println(num);//循环次数
                   in.close();
                   out.close();
    }
}

七、Print流

Print 打印流：只做输出没有输入
打印流分为字节打印流和字符打印流
PrintWriter：字符打印流
print方法可以打印各种类型数据

八、对象输入输出流

对象---java程序运行产生的对象
例如：new Date() new String() 内存中存储将程序运行时，创建的对象输出到一个文件中

为什么将运行时对象输出到文件中？
为了实现数据永久保存，0有时服务器关闭（程序要结束运行）结束运行时，将一些保存下来

对象输出-->对象序列化

将对象信息输出到文件中称为将对象序列化

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Date date = new Date();
        String s = new String("abc");
        User user = new User(1, "abc");

        //将对象信息输出到文件中  称为将对象序列化
        //兑现固定类必须实现java.io.Serializable接口
        FileOutputStream out = new FileOutputStream("E:/obj.txt");
        ObjectOutputStream objectOut = new ObjectOutputStream(out);
        objectOut.writeObject(date);
        objectOut.writeObject(s);
        objectOut.flush();
        objectOut.close();
}

对象的输入输出流 : 主要的作用是用于写入对象信息与读取对象信息。

对象信息一旦写到文件上那么对象的信息就可以做到持久化了

对象的输出流： ObjectOutputStream

对象的输入流: ObjectInputStream

要将序列化之后的对象保存下来，需要通过对象输出流(ObjectOutputStream)

将对象状态保存，之后再通过对象输入流(ObjectInputStream)将对象状态恢复。

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

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

//需要对序列化的类，必须实现Serializable接口，会为类生成一个序列化的id号，是唯一的与类对应
public class User implements Serializable {

    private int id;
    private String name;

    public User(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //对象反序列化  将文件中的信息输入到程序中，再创建一个对象
        FileInputStream in = new FileInputStream("E:/obj.txt");
        ObjectInputStream objectIn = new ObjectInputStream(in);
        Date date = (Date) objectIn.readObject();
        String s = (String) objectIn.readObject();
        User user = (User)objectIn.readObject();
        System.out.println(date);
        System.out.println(s);
        System.out.println(user.getId()+":"+user.getName());

    }
}

九、节点流与处理流

根据封装类型不同划分流：

节点流
处理流

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

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

节点流中常用类

字节输入流	FileInputStream
字节输出流	FileOutputStream
字符输入流	FileReader
字符输出流	FileWriter

处理流中常用类

缓冲字节输出流	BufferedOutputStream
缓冲字节输入流	BufferedInputStream
缓冲字符输入流	BufferedReader
缓冲字符输出流	BufferedWriter

叫我剑锋

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
IO流和输入输出

流是个抽象的概念，是对输入输出设备的抽象，Java程序中，对于数据的输入/输出操作都是以“ …流具有方向性，至于是输入流还是输出流则是一个相对的概念，一般以程序为参考，如果数据的流向是程序至设备，我们成为输出流，反之我们称为输入流。
复制链接

扫一扫