IO流笔记

最新推荐文章于 2024-09-25 10:59:43 发布

ayou2020

最新推荐文章于 2024-09-25 10:59:43 发布

阅读量123

点赞数

分类专栏： IO流文章标签： java

本文链接：https://blog.csdn.net/ayou2020/article/details/119741459

版权

IO流专栏收录该内容

1 篇文章 0 订阅

订阅专栏

本文详细讲解了Java中的IO流、文件操作、单元测试及高级特性，包括文件复制、目录管理、流分类、缓冲区机制、字符与字节流转换，以及对象流的序列化与反序列化。通过实例演示，提升开发者对IO操作的理解和实践能力。

摘要由CSDN通过智能技术生成

文件传输方向---------以程序为参照物

文件读写规则

按照读取单位

转换流

内存流-----------本质上为字节流

打印流----只有输出没有输入，直接打印数据

随机访问流-----------RandomAccessFile

缓冲区----Buffer-----默认缓冲区大小---8192byte

单元测试：

在方法上加上单元测试注解@Test
方法访问修饰符不能为private
不能有test类
方法不能为静态
需要导入Test包
不需要main方法

文件

文件---直接调用delete方法删除。

拷贝指定目录

//拷贝指定目录
public class Demo01 {
    public static void main(String[] args) {
        File file = new File("D:\\a");
        File file2 = new File("D:\\bbb");
        method(file.getAbsolutePath(), file2.getAbsolutePath());
    }

    //拷贝文件
    public static void method1(String fispath, String fospath) {
        FileInputStream fis1 = null;
        FileOutputStream fos2 = null;
        try {
            fis1 = new FileInputStream(fispath);
            fos2 = new FileOutputStream(fospath);
            byte[] bytes = new byte[1024];
            int len;
            while ((len = fis1.read(bytes)) != -1) {
                fos2.write(bytes, 0, len);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            closeAll(fis1, fos2);
        }
    }

    //拷贝目录
    public static void method(String formpath, String topath) {
        File file = new File(formpath);
        File file1 = new File(topath);
        File[] files = file.listFiles();
        if (!file.isDirectory()) {
            return;
        }
        //如果file1目录不存在，创建
        if (!file1.exists()) {
            file1.mkdir();
        }
        for (File f : files) {
            if (f.isDirectory()) {
                //递归
                method(formpath+File.separator+f.getName(),topath+File.separator+f.getName());
            } else {
                //进来说明是文件
                method1(formpath+File.separator+f.getName(), topath+File.separator+f.getName());
            }
        }
    }

    //关闭所有资源
    public static void closeAll(Closeable... closeables) {
        for (Closeable c : closeables) {
            if (c != null) {
                try {
                    c.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

IO流------会抛出IO异常

IO流分类

每次需要关流---封装成工具类，直接调用

public class Utils {
    public static void closeAll(Closeable ...closeables){
        for (Closeable c:closeables) {
            if(c != null){
                try {
                    c.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

文件传输方向---------以程序为参照物

输入：文件------->程序====读入------FileInputStream（字节）-----FileReader(字符）

输出：程序------->文件====写出------FileOutputStream（字节）------FileWriter(字符）

文件读写规则

1.构造方法创建输出流，默认每次写入都会清空文件内容

fos = new FileOutputStream("a\\a.txt");

2.构造方法创建输出流，在路径后面加ture，不清空文件内容，实现末尾追加内容

fos = new FileOutputStream("a\\a.txt",true);

按照读取单位

字节-------byte---------一次读取一个字节

读取文件中的所有字节-------可以定义一个byte[]数组自定义大小，充当缓冲区，提高效率

int read;//定义变量接收字节。
//读取，判断，打印
//file.read()返回下一个数据字节；如果已到达文件末尾，则返回 -1。
while ((read = file.read()) != -1){//不等于-1即没有下一个字节
    System.out.print((char) read);//输出强转为char
}

字符-------char---------一次读取一个字符------针对文本文件

读取文件中所有字符----可以定义一个char[]数组自定义大小，充当缓冲区，提高效率

int len;//定义长度
//定义一个字符数组接收字符，充当缓冲区作用，提高读写效率
char[] chars = new char[1024];//一次读写1024字节的数组数据
//当读写完一次数组，继续读写下一次，直到读取完文件内容
while ((len = fd.read(chars)) != -1){
    //输出一个字符串，
    System.out.println(new String(chars,0,len));
}

对象流----Object-------本质字节流---------一次读取一个对象

多个对象写入-------使用集合

ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("a.txt"));
    //创建集合
    ArrayList<User> list = new ArrayList();
    //往集合里添加对象
    list.add(new User(1,"ZS"));
    list.add(new User(2,"LS"));
    list.add(new User(3,"WW"));
    //写入集合
    oos.writeObject(list);

读取文件中的所有对象-------使用集合

//传过来的是集合，需要遍历
ArrayList list = (ArrayList) ois.readObject();//强制转换为集合
//使用lambda表达式循环输出
list.forEach(System.out::println);

对象类需要实现Serializable接口，进行序列化

序列化------>写反序列化------读

使用对象流进行对象的读写操作需要对象的类实现Serializable接口

本质上读写操作是在进行序列化和反序列化
写入对象到文件中序列化操作
读取对象为反序列化
私有的静态属性不会被序列化
私有的transient属性不会被序列化

转换流

转换流:字节通向字符的桥梁,本质上是字符流

InputStreamReader:把文件中的字节转换成程序的字符

OutputStreamWriter:把程序的字符转换成文件的字节

1.字节与字符的转换

2.读写不同的编码格式文件

//创建一个使用给定字符集解码器的InputStreamReader。

//读取GBK编码文件

InputStreamReader inputStreamReader =

new InputStreamReader(new FileInputStream("D:\\a\\a.txt"),"GBK");

内存流-----------本质上为字节流

ByteArrayOutputStream------程序-->内存

ByteArrayInputStream----内存----->程序

打印流----只有输出没有输入，直接打印数据

PrintStream:打印字节流

PrintWriter:打印字符流

set in 重新分配“标准”输入流-------输入重定向

setOut 重新分配“标准”输出流------输出重定向

随机访问流-----------RandomAccessFile

1.只有一个类RandomAccessFile，由一个类创建的不同对象完成写入和读取

2.拥有指针（偏移量）

3.每次实例化后，偏移量为0

4.每次实例化对象不会清空文件，只会从偏移量开始处进行覆盖写入

5.可以在文件指定位置进行读写操作

注意：

插入时：

设置seek偏移量，是从当前偏移位置开始写，一个字节对应文件的一个字节。

如果需要插入的字节比文件中指针之后到数据结尾的数据长度小，则插入多少字节覆盖多少字节。后面的字节不会覆盖。

如果需要插入的字节比文件中指针之后到数据结尾的字节长度大，则直接覆盖。

缓冲区----Buffer-----默认缓冲区大小---8192byte

优点：

1.缓冲区是程序到文件的桥梁

2.缓冲区可以提高读写速度，减少跟磁盘的交互

3.系统自带缓冲区

缓冲区写入写出机制：

1.调用flush（）方法刷新，实现读写功能

2.实现close（）方法关闭资源，会自动调用flush方法刷新缓冲区，实现读写功能

3.缓存区容量满，会自动调用flush()方法刷新缓冲区，将缓冲区的数据读入写出

区别

带缓冲区的字节流

写出缓冲区BufferedOutputStream

读入缓冲区BufferedInputStream

带缓冲区的字符流

BufferedReader -- readLine()为独有的方法 ---读取一行字符串

BufferedWriter -- newLine()为独有的方法-----写一行行分隔符

Line规则：一行被视为由换行符（'\ n'），回车符（'\ r'）中的任何一个或随后的换行符终止。

//读取一行字符
//定义一个String接收一行字
String str;
while ((str = bufferedReader.readLine()) != null){
    System.out.println(str);//输出一行字符
}

//将文件一行一行写入
//定义一个字符串接收一行文字
String str;
//读一行文字。 一行被视为由换行符（'\ n'），回车符（'\ r'）中的任何一个或随后的换行符终止。
// 包含行的内容的字符串，不包括任何行终止字符，如果已达到流的末尾，则为null
while ((str = bufferedReader.readLine()) != null){
    bufferedWriter.write(str);//每次写入一行字符
    bufferedWriter.newLine();//加上换行符
}