Java IO框架

最新推荐文章于 2024-07-20 23:59:39 发布

南风未凉

最新推荐文章于 2024-07-20 23:59:39 发布

阅读量171

点赞数 1

分类专栏： java初学文章标签： java

本文链接：https://blog.csdn.net/memory_share/article/details/114489930

版权

java初学专栏收录该内容

14 篇文章 0 订阅

订阅专栏

I/O框架

什么是流

概念：内存与存储设备之间传输数据的通道。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-72mGHw62-1615108051169)(D:\QQ\378214218\FileRecv\MobileFile\qq_pic_merged_1612340541618.jpg)]

流的分类

按方向【重点】：
- 输入流：将<存储设备>中的内容读到<内存>中。
- 输出流：将<内存>中的内容写入到<存储设备>中。
  
  输入流输出流

文件 ---------------------------------->程序--------------------------------------->文件

按单位：
- 字节流：以字节为单位，可以读写所有数据。
- 字符流：以字符为单位，只能读写文本数据。
按功能：
- 节点流：具有实际传输数据的读写功能。
- 过滤流：再节点流基础之上增强功能。

字节流

字节流的父类（抽象类）：
- InputStream：字节输入流
- OutputStream：字节输出流

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NyFR0Xdw-1615108051171)(D:\QQ\378214218\FileRecv\MobileFile\qq_pic_merged_1612354878604.jpg)]

文件字节流

FileInputStream:
- public int read(byte[] b) //从流中读取多个字节，将读到内容存入b数组，返回实际读到的字节数；如果达到文件的尾部，则返回-1。
FileOutputStream:
- public void write(byte[] b) //一次写多个字节，将b数组中所有字节，写入输出流。

文件字节输入流使用

package com.io;

import java.io.FileInputStream;
//演示FileInputStream的使用
//文件字节输入流 
public class Demo01 {
    public static void main(String[] args) throws Exception{
        //1.FileInputStream，并指定文件路径
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        //2.读取文件
        //fis.read();
        //单个字节读取
        /*int date = 0;
        while ((date = fis.read())!=-1){
            System.out.println((char) date);
        }
        System.out.println("读取完毕");*/
        //2.2一次读取多个字节
        byte arr[] = new byte[1024];
        int count = 0;
        while ((count = fis.read(arr))!=-1){
            System.out.println((new String(arr,0,count)));
        }

        //3.关闭
        fis.close();

    }
}

文件字节输出流使用

package com.io;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.charset.StandardCharsets;

// 演示文件字节输出流的使用
// FileOutputStream
public class Demo02 {
    public static void main(String[] args)throws Exception {
        //1.创建一个文件输出流对象
        FileOutputStream fos = new FileOutputStream("D:\\bbb.txt");
        //2.写入文件
        //fos.write(97);
        //fos.write('b');
        //fos.write('c');
        String  string = "helloworld";
        fos.write(string.getBytes());
        //3.关闭
        fos.close();
        System.out.println("执行完毕");
    }
}

案例：复制一个照片

package com.io;

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

//使用字节流实现文件的复制
public class Demo03 {
    public static void main(String[] args) throws Exception{
        //1.创建流
        //1.1文件字节输入流
        FileInputStream fis = new FileInputStream("D:\\001.png");
        //1.2文件字节输出流
        FileOutputStream fos = new FileOutputStream("D:\\002.png");
        //2.一边读一边写
        byte[] buf = new byte[1024];
        int count = 0;
        while ((count = fis.read(buf))!=-1){
            fos.write(buf,0,count);
        }
        //3.关闭流
        fis.close();
        fos.close();
        System.out.println("复制完毕");

    }
}

字节缓冲流

缓冲流：BufferedInputStream/BufferedOutputStream
- 提高IO效率，减少访问磁盘的次数；
- 数据存储在缓冲区中，flush是将缓存区的内容写入文件中，也可以直接close。

字节缓存流输入

package com.io;

import java.io.BufferedInputStream;
import java.io.FileInputStream;

//字节缓存流
public class Demo04 {
    public static void main(String[] args) throws Exception{
        //1.创建BufferedInputStream
        FileInputStream fis = new FileInputStream("D:\\aaa.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);
        //2.读取
        /*int data = 0;
        while ((data = bis.read())!=-1){
            System.out.print((char) data);
        }*/
        //2.1
        byte[] buf = new byte[1024];
        int count = 0;
        while ((count = bis.read(buf))!=-1){
            System.out.println((new String(buf,0,count)));
        }
        //3.关闭
        bis.close();
    }
}

字节缓存流输出

package com.io;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;

//使用字节缓存流写入文件
public class Demo05 {
    public static void main(String[] args) throws Exception{
        //1.创建字节输出缓存流
        FileOutputStream fos = new FileOutputStream("d:\\buffer.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        //2.写入文件
        for (int i = 0; i < 10; i++) {
            bos.write("helloworld\n".getBytes());//写入8k缓存区
            bos.flush();//刷新到硬盘
        }
        //3.关闭（内部调用flush方法）
        bos.close();
    }
}

对象流

对象流：ObjectOutputStream / ObjectInputStream
- 增强了缓存区功能
- 增强了读写8种基本数据类型和字符串功能
- 增强了读写对象的功能
  - readObject() 从流中读取一个对象
  - writeObject（Object obj）向流中写入一个对象
- 使用流传输对象的过程称为序列化(Out)、反序列化(In)。

序列化

序列化必须实现Serializable的接口

package com.io;

import java.io.Serializable;

//学生类
public class Student implements Serializable {
    private static final long serialVersionUID = 100L;//序列化版本号ID
    private String name;
    private int age;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
=======================
package com.io;

import java.io.*;

//使用ObjectInputStream实现对象的序列化
//注意事项：
// (1).序列化必须实现Serializable的接口
// (2).序列化中对象属性要求实现Serializable接口
// (3).序列化版本号ID，保证序列化的类和反序列化的类是同一个类。
// (4).使用transient(瞬间的)修饰属性，这个属性就不能序列化
// (5).静态属性不能序列化
// (6).序列化多个对象可以使用集合实现
public class Demo06 {
    public static void main(String[] args) throws Exception{
        //1.创建对象流
        FileOutputStream fos = new FileOutputStream("d:\\stu.bin");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        //2.实现序列化（写入操作）
        Student zhangsan = new Student("zhangsan",24);
        oos.writeObject(zhangsan);
        //3.关闭
        oos.close();
        System.out.println("序列号完毕");

    }
}

反序列化

注意事项：
- 序列化必须实现Serializable的接口
- 序列化中对象属性要求实现Serializable接口
- 序列化版本号ID，保证序列化的类和反序列化的类是同一个类。
- 使用transient(瞬间的)修饰属性，这个属性就不能序列化
- 静态属性不能序列化
- 序列化多个对象可以使用集合实现

package com.io;

import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.util.ArrayList;
//使用ObjectInputStream实现反序列化(读取重构成对象)

public class Demo07 {
    public static void main(String[] args) throws Exception{
        //1.创建一个对象流
        FileInputStream fis = new FileInputStream("D:\\stu.bin");
        ObjectInputStream ois = new ObjectInputStream(fis);
        //2.读取文件(反序列化)
        //Student s = (Student)ois.readObject();
        ArrayList<Student> list = (ArrayList<Student>) ois.readObject();
        //3.关闭
        ois.close();
        System.out.println("执行完毕");
        System.out.println(list.toString());

    }
}

字符编码

ISO-8859-1收录除了ASCII外，还包括西欧、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号。
UTF-8 针对Unicode码标的可变长度字符编码
GB2312 简体中文
GBK 简体中文、扩充
BIG5台湾繁体中文

注：当编码方式和解码方式不一致时，会出现乱码。

字符流

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kqONOP9v-1615108051173)(D:\QQ\378214218\FileRecv\MobileFile\Screenshot_20210204_183417.jpg)]

文件字符流

FileReader:
- public int read (char[] c) //从流中读取多个字符，将读到的内容存入c数组，返回实际读到的字符数；如果达到文件的尾部，则返回-1.
FileWrite:
- public void write(String str) //一次写多个字符，将b数组中所有字符，写入输出流.

文件字符流读取使用

package com.io.chars;

import java.io.FileReader;

//使用FileReader读取文件
public class Demo01 {
    public static void main(String[] args) throws Exception {
        //1.创建FileReader 文件字符输入流
        FileReader fr = new FileReader("D:\\hello.txt");
        //2.读取
        //2.1单个读取
        /*int data = 0;
        while ((data = fr.read())!=-1){//读取一个字符
            System.out.print((char) data);
        }*/
        //2.2多个读取
        char[] buf = new char[1024];
        int count = 0;
        while ((count = fr.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
        //3.关闭
        fr.close();
    }
}

文件字符流写入文件

package com.io.chars;

import java.io.FileWriter;

//使用FileWrite写入文件
public class Demo02 {
    public static void main(String[] args)throws Exception {
        //1.创建一个FileWrite对象
        FileWriter fw = new FileWriter("D:\\abc.txt");
        //2.写入文件
        //fw.write("java牛逼");
        for (int i = 0; i < 10; i++) {
            fw.write("java是世界上最好的语言\n");
            fw.flush();
        }
        //3.关闭
        fw.close();
        System.out.println("执行完毕");
    }
}

案例：字符流复制文件（只能复制文本文件）

package com.io.chars;

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

//使用FileRead和FileWrite复制文本文件，不能复制图片或二进制文件
//使用字节流复制任意文件
public class Demo03 {
    public static void main(String[] args) throws Exception{
        //1.创建FileRead和FileWrite
        FileReader fr = new FileReader("d:\\abc.txt");
        FileWriter fw = new FileWriter("d:\\abc2.txt");
        //2.读写
        int data = 0;
        while ((data = fr.read())!=-1){
          fw.write(data);
        }
        fw.flush();
        //3.关闭
        fw.close();
        fr.close();
    }
}

字符缓存流

缓存流：BufferedReader/BufferedWriter
- 高效读写
- 支持输入换行符
- 可一次写一行、读一行

字符缓存流读取

package com.io.chars;

import java.io.BufferedReader;
import java.io.FileReader;

//使用字符缓存流读取文件
public class Demo04 {
    public static void main(String[] args) throws Exception{
        //1.创建一个缓冲流
        FileReader fr = new FileReader("D:\\abc.txt");
        BufferedReader br = new BufferedReader(fr);
        //2.读取
        //2.第一种方式
        /*char[] buf = new char[1024];
        int count = 0;
        while ((count = br.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }*/
        //2.2一行一行的读取
        String line = null;
        while ((line = br.readLine())!=null){
            System.out.println(line);
        }
        //3.关闭
        br.close();
    }
}

字符缓存流写入

package com.io.chars;

import java.io.BufferedWriter;
import java.io.FileWriter;

//使用字符缓存流
public class Demo05 {
    public static void main(String[] args)throws Exception {
        //1.创建一个BufferedWriter对象
        FileWriter fw = new FileWriter("d:\\buffer1.txt");
        BufferedWriter bw = new BufferedWriter(fw);
        //2.写入
        for (int i = 0; i < 10; i++) {
            bw.write("好好学习，天天向上");
            bw.newLine();//写入一个换行符
            bw.flush();
        }
        //3.关闭
        bw.close();
        System.out.println("执行完毕");
    }
}

打印流

PrintWriter：

封装了print（）/ println（）方法，支持写入后换行。
支持数据原样打印

package com.io.chars;

import java.io.PrintWriter;

//演示PrintWrite的使用
public class Demo06 {
    public static void main(String[] args)throws Exception {
        //1.创建打印流
        PrintWriter pw = new PrintWriter("D:\\print.txt");
        //2.打印
        pw.println(97);//97
        pw.println(true);
        pw.println(3.14);
        pw.println('a');
        //3.关闭
        pw.close();
        System.out.println("执行完毕");

    }
}

转换流

桥转换流：InputStreanReader/OutputStreanReader
- 可将字节流转换为字符流
- 可设置字符的编码方式

读取文件，指定使用的编码

package com.io.transition;

import java.io.FileInputStream;
import java.io.InputStreamReader;

//使用InputStreamReader读取文件，指定使用的编码
public class Demo01 {
    public static void main(String[] args)throws Exception {
        //1.创建一个InputStreamReader对象
        FileInputStream fis = new FileInputStream("D:\\abc.txt");
        InputStreamReader isr = new InputStreamReader(fis,"utf-8");
        //2.读取文件
        int data = 0;
        while ((data = isr.read())!=-1){
            System.out.print((char) data);
        }
        //3.关闭
        isr.close();
    }
}

写入文件，指定编码

package com.io.transition;

import java.io.FileOutputStream;
import java.io.OutputStreamWriter;

//使用OutputStreamWriter写入文件，指定编码
public class Demo02 {
    public static void main(String[] args)throws Exception{
        //1.创建OutputStreamReader对象
        FileOutputStream fos = new FileOutputStream("d:\\info.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");
        //2.写入
        for (int i = 0; i < 10; i++) {
            osw.write("我爱中国，我爱故乡\n");
            osw.flush();
        }
        //3.关闭
        osw.close();
        System.out.println("执行完毕");
    }
}

File类

概念：代表物理盘符中的一个文件或者一个文件夹。
方法
- createNewFile() //创建一个新文件
- mkdir () //创建一个新目录
- delete () //删除文件或空目录
- exists() // 判断File对象所对象所代表的对象是否存在
- getAbsolutePath () // 获取文件的绝对路径
- getName () //取得名字
- getParent () //获取文件/目录所在的目录
- isDirectory () //是否是目录
- isFile () //是否是文件
- length () //获得文件的长度
- listFiles () // 列出目录中的所有内容
- renameTo () //修改文件名为

文件操作

package com.io.transition;

import java.io.File;
import java.util.Date;

//File类的使用
//(1).分隔符
//(2).文件操作
//(3).文件夹操作
public class Demo03 {
    public static void main(String[] args)throws Exception {
        separator();
        fileOpe();
    }
    //(1).分隔符
    public static void separator(){
        System.out.println("路径分隔符"+ File.pathSeparator);
        System.out.println("名称分隔符"+File.separator);
    }
    //(2).文件操作
    public static void fileOpe()throws Exception{
        //1.创建文件
        File file = new File("D:\\file.txt");
        //System.out.println(file.toString());
        if (!file.exists()) {//如果不存在就创建
            boolean b = file.createNewFile();
            System.out.println("创建结果：" + b);
        }
        //2.删除文件
        //2.1直接删除
        //System.out.println(file.delete());

        //2.2使用JVM退出时删除
        //file.deleteOnExit();
        //Thread.sleep(5000);//休眠五秒钟

        //3.获取文件信息
        System.out.println("文件的绝对路径"+file.getAbsolutePath());
        System.out.println("获取路径"+file.getPath());
        System.out.println("获取文件名称"+file.getName());
        System.out.println("获取父目录"+file.getParent());
        System.out.println("获取文件的长度"+file.length());
        System.out.println("获取文件的创建时间"+new Date(file.lastModified()).toLocaleString());
        //4.判断
        System.out.println("是否可写"+file.canWrite());
        System.out.println("是不是文件"+file.isFile());//还可能是文件夹
        System.out.println("是否隐藏"+file.isHidden());
    }
}
==============在IDEA的输出结果为：
    路径分隔符;
名称分隔符\
文件的绝对路径D:\file.txt
获取路径D:\file.txt
获取文件名称file.txt
获取父目录D:\
获取文件的长度15
获取文件的创建时间2021-2-5 13:04:54
是否可写true
是不是文件true
是否隐藏false

Process finished with exit code 0

文件夹操作

package com.io.transition;

import java.io.File;
import java.util.Date;

//文件夹操作
public class Demo04 {
    public static void main(String[] args)throws Exception {
        directpryope();
    }

    //文件夹操作
    public static void directpryope()throws Exception {
        //(1).创建文件夹
        File file = new File("d:\\aaa\\bbb\\ccc");
        System.out.println(file.toString());
        if (!file.exists()){
            //file.mkdir();//只能创建单级目录
            file.mkdirs();//可以创建多级目录
            System.out.println("创建结果"+file.mkdirs());
        }
        //(2).删除文件夹
        // 2.1直接删除（只能删除空目录）且只删除了ccc目录
        //System.out.println("删除结果"+file.delete());
        //2.2使用JVM删除
        //file.deleteOnExit();
        //Thread.sleep(5000);
        //(3).获取文件夹信息
        System.out.println("文件夹的绝对路径"+file.getAbsolutePath());
        System.out.println("获取路径"+file.getPath());
        System.out.println("获取文件夹名称"+file.getName());//最里面的文件夹名称
        System.out.println("获取父目录"+file.getParent());
        System.out.println("获取文件的创建时间"+new Date(file.lastModified()).toLocaleString());
        //(4).判断
        System.out.println("是不是文件夹"+file.isDirectory());
        System.out.println("是否隐藏"+file.isHidden());
        //(5).遍历文件夹
        File file1 = new File("D:\\照片");
        String[] files = file1.list();
        System.out.println("===========");
        for (String string:files) {
            System.out.println(string);
        }
    }
}
===========在IDEA的输出结果为：
    d:\aaa\bbb\ccc
文件夹的绝对路径d:\aaa\bbb\ccc
获取路径d:\aaa\bbb\ccc
获取文件夹名称ccc
获取父目录d:\aaa\bbb
获取文件的创建时间2021-2-5 13:27:59
是不是文件夹true
是否隐藏false
===========
doc.png
QQ图片20201219010226.jpg
QQ截图20201219110718.png
命令行传递参数.png
屏幕截图 2020-12-18 151657.png

FileFilter接口

public interface FileFilter
- boolean accept (File pathname)
在调用File类中的 listFiles ()方法时，支持传入FileFilter接口接口实现类，对·获取文件进行过滤，只有满足条件的文件才可出现在listFlies () 的返回值中。

System.out.println("=====FileFilter接口的使用=======");
file2[] files1 = file1.listFiles(new FileFilter() {
    @Override
    public boolean accept(File pathname) {
        if (pathname.getName().endsWith(".jpg")){
        return true;
        }
        return false;
    }
});
for (File file2: files1) {
    System.out.println(file.getName());
}

递归遍历和递归删除

package com.io.transition;

import javax.jws.soap.SOAPBinding;
import java.io.File;
import java.util.Arrays;

//案例1：递归遍历文件夹
//案例2：递归删除文件夹
public class ListDemo {
    public static void main(String[] args) {
        //listDir(new File("D:\\myfiles"));
        deleteDir(new File("D:\\myfiles"));
    }
    public static void listDir(File dir){
        File[] files = dir.listFiles();
        System.out.println(dir.getAbsolutePath());
        if (files!=null&&files.length!=0){
            for (File file:files) {
                if (file.isDirectory()){
                    listDir(file);//递归
                }
                else
                    System.out.println(file.getAbsolutePath());
            }
        }
    }
    //案例2：递归删除文件夹
    public static void deleteDir(File dir){
        File[] files = dir.listFiles();
        if (files!=null&&files.length!=0){
            for (File file:files) {
                if (file.isDirectory()){
                    deleteDir(file);//递归
                }
                else {
                    //删除文件
                    System.out.println(file.getAbsolutePath()+"删除"+file.delete());
                }
            }
           
        }
        System.out.println(dir.getAbsolutePath()+"删除"+dir.delete());
    }
}
==============在IDEA的输出结果为：
    D:\myfiles\新建 XLSX 工作表.xlsx删除true
D:\myfiles\新建文件夹\新建 PPT 演示文稿.ppt删除true
D:\myfiles\新建文件夹\新建文本文档.txt删除true
D:\myfiles\新建文件夹删除true
D:\myfiles\新建文件夹 (2)\新建 DOC 文档.doc删除true
D:\myfiles\新建文件夹 (2)\新建文本文档.txt删除true
D:\myfiles\新建文件夹 (2)删除true
D:\myfiles\新建文本文档.txt删除true
D:\myfiles删除true

Process finished with exit code 0

补充：Properties

Properties:属性集合
特点：
- 1.存储属性名和属性值
- 2.属性名和属性值都是字符串类型、
- 3.没有泛型
- 4.和流有关

package com.io.properties;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.util.Properties;
import java.util.Set;

//演示Properties的使用
public class Demo01 {
    public static void main(String[] args) throws Exception{
        //1。创建集合
        Properties properties = new Properties();
        //2.添加数据
        properties.setProperty("username","zhangsan");
        properties.setProperty("age","20");
        System.out.println(properties.toString());
        //3.遍历
        //3.1keySet
        //3.2enerySet
        //3.3stringPropertyNames()
        Set<String> pronames = properties.stringPropertyNames();
        for (String pro:pronames) {
            System.out.println(pro+"========"+properties.getProperty(pro));
        }
        //4.和流有关的方法
        //4.1  list方法
        //PrintWriter pw = new PrintWriter("d:\\print.txt");
       // properties.list(pw);
        //pw.close();
        //4.2  store方法  保存
        //FileOutputStream fos = new FileOutputStream("d:\\store.properties");
        //properties.store(fos,"注释");
        //fos.close();
        //4.3  load方法    加载
        Properties properties1 = new Properties();
        FileInputStream fis = new FileInputStream("d:\\store.properties");
        properties1.load(fis);
        fis.close();
        System.out.println(properties1.toString());
    }
}

总结

流的概念:
- 内存与存储设备之间传输数据的通道。
流的分类:
- 输入流、输出流; 字节流、字符流; 节点流、过滤流;
序列化、反序列化
- 将对象通过流写入到文件，或将对象通过流读取到内存，必须实现Serializable接口。
File对象
- 代表物理盘符中的一个文件或者文件夹。

南风未凉

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Java IO框架

I/O框架什么是流概念：内存与存储设备之间传输数据的通道。[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-72mGHw62-1615108051169)(D:\QQ\378214218\FileRecv\MobileFile\qq_pic_merged_1612340541618.jpg)]流的分类按方向【重点】：输入流：将<存储设备>中的内容读到<内存>中。输出流：将<内存>中的内容写入到<存储设备&gt
复制链接

扫一扫