SE02 Unit02 基本IO操作 、 文本数据IO操作

最新推荐文章于 2022-10-16 14:16:01 发布
最新推荐文章于 2022-10-16 14:16:01 发布
阅读量394 收藏
点赞数
分类专栏： Java

Java API

RAF 总结

  1. 理解什么是文件
    • 文件是由byte组成的序列
  2. RAF可以打开文件，在文件的任意位置开始读写
  3. RAF打开文件方式：
    • r 只读
    • rw 读写
  4. 基本的读写方法
    • read() 读取一个byte
    • write() 写出一个byte
    • 文件的读写位置（文件指针）会自动移动
    • 每次第一个byte（0~255）
  5. 在基本读写方法之上，扩展了基本类型的读写
    • readInt writeInt 每次读写4个byte
    • readLong writeLong 每次读写8个byte
    • …
  6. String 的读写
    • 内存中的字符串是char数据，不是byte类型
    • 写出字符串：
      • 需要将字符串进行编码（UTF-8）编码为byte数据
      • 然后在写到文件中！！！
    • 读取字符串
      • 读取byte数据
      • 将byte数据解码（UTF-8）为字符串！

随机读写文件

RAF 可以从文件的任何位置开始读写文件，其核心方法是seek(位置)：

案例：

    /**
     * 随机文件读写 
     *
     */
    public class Demo01 {
        public static void main(String[] args) 
            throws Exception{
            String file = "abc/myfile.dat";
            RandomAccessFile raf=
                new RandomAccessFile(file, "rw");
            //将0~255写入到文件 myfile.dat
            for(int i=0; i<=255; i++){
                raf.write(i);
            }
            //移动读写位置指针到0
            raf.seek(0);//可以在任意位置开始读写
            int b;
            //经典的模式写法：
            while((b=raf.read())!=-1){
                System.out.println(b);
            }
            raf.close();
        }
    }

注意： 文件读写完毕以后才能raf.close()关闭文件！！

基本类型读写

RAF 提供了基本类型的读写方法，基本类型的读写方法的底层是 read() write() 方法。

  • int 拆分为 4个byte读写
  • long 拆分为 8个byte读写
  • byte 1个byte读写
  • short 拆分为 2个byte读写
  • float 拆分为 4个byte读写
  • doubel 拆分为 8个byte读写
  • boolean 1个byte读写
  • char 拆分为 2个byte读写

int 的读写原理:

这里写图片描述

案例：

    /**
     * RAF 整数数据读写，其他类型 略
     */
    public class Demo02 {
        public static void main(String[] args) 
            throws Exception{
            String file = "abc/integer.dat";
            RandomAccessFile raf = 
                new RandomAccessFile(file, "rw");
            //将int数据126712 拆分为4个byte写到
            //文件中，文件指针连续移动4次
            raf.writeInt(126712); 
            long p = raf.getFilePointer();
            System.out.println(p);
            raf.seek(0);
            //读取一个整数: 连续读取4个byte，拼接
            // 为一个int数据, 文件指针连续移动4次
            int n = raf.readInt();
            p = raf.getFilePointer();
            System.out.println(p);//4
            System.out.println(n);//126712
            raf.close();
        }
    }

字符串IO

字符串中存储的是char数据，不能直接IO，需要先进行编码，编码为byte数据在进行读写。常见的编码方案是 UTF-8.

在UTF-8 编码中：英文字符1个byte，中文字符3个byte

案例：

    /**
     * 字符串类型的写出和读取 
     */
    public class Demo03 {
        public static void main(String[] args) 
            throws Exception{
            String file="abc/str.txt";
            RandomAccessFile raf = 
                new RandomAccessFile(file, "rw");
            String str = "你好ABC";
            //对字符串进行UTF-8编码
            byte[] bytes=str.getBytes("UTF-8");
            System.out.println(bytes.length);//9
            //将文字的编码写入到文件中
            raf.write(bytes);//将数组中全部的byte
            //数据写入到文件中。
            long p = raf.getFilePointer();
            System.out.println(p);//9
            //从头读取
            raf.seek(0);
            byte[] buf=new byte[(int)raf.length()];
            //read(bytes) 从文件中连续读取byte数据
            //将读取结果填充到 byte数组中
            raf.read(buf);
            //buf 中是按照UTF-8编码的字符数据,解码：
            String s = new String(buf, "UTF-8");
            System.out.println(s); 
            raf.close();
        }
    }

注意：文字信息必须经过编码才能写到文件中。读取文件时候需要进行解码处理。 如果编码和解码的规则不一致就会出现乱码问题！！

综合案例

将员工信息写到文件中，并且在读取回来：

原理：

这里写图片描述

写数据案例：

    /**
     * 写员工信息 
     */
    public class Demo04 {
        public static void main(String[] args) 
            throws IOException{
            String file="abc/emp.dat";
            RandomAccessFile raf=
                new RandomAccessFile(file, "rw");
            write(raf, 0,"Tom", 10, "男", 100, new Date());
            write(raf, 1,"范传奇",30,"男",200,new Date());
            raf.close();
        }   
        public static void write(
                RandomAccessFile raf, //已经打开的文件
                int n, //n = 0 1 2 ... 行号
                String name, 
                int age,
                String sex,
                int salary,
                Date hiredate)throws IOException{
            int start=n*80;//n=0,0  n=1,80  n=2,160
            raf.seek(start);//将文件指针移动到每行起始位置
            //将name编码，然后写到文件中
            byte[] bytes=name.getBytes("UTF-8");
            raf.write(bytes); //3 9 10
            //写出age
            raf.seek(start+32);//跳到age位置
            raf.writeInt(age);//写出年龄
            //写出性别
            bytes = sex.getBytes("UTF-8");
            raf.write(bytes);
            //写出薪水
            raf.seek(start+46);
            raf.writeInt(salary); 
            //写出日期
            SimpleDateFormat fmt = 
                    new SimpleDateFormat("yyyy-MM-dd");
            String d = fmt.format(hiredate);
            bytes = d.getBytes("UTF-8");
            raf.write(bytes);
        }
    }

读取员工信息：

    /**
     * 读取员工信息文件 
     *
     */
    public class Demo05 {
        public static void main(String[] args) 
            throws  Exception {
            String file="abc/emp.dat";
            //打开文件 emp.dat
            RandomAccessFile raf=
                new RandomAccessFile(file, "r");
            //读取第一行 （Tom）
            Emp e1 = read(raf, 0);
            //读取第二行 （范传奇）
            Emp e2 = read(raf, 1);
            //显示读取结果
            System.out.println(e1);
            System.out.println(e2);
            //关闭文件
            raf.close();
        }
        public static Emp read(
            RandomAccessFile raf, int n) 
            throws Exception {  
            int start = n*80;//读取的起始位置
            raf.seek(start);//找到name的起始位置
            byte[] bytes = new byte[32];
            raf.read(bytes);//读取32个byte
            //bytes=[T,o,m,0,0,0,0,0,...0]
            String name=
                new String(bytes,"UTF-8").trim();
            //读取年龄
            int age = raf.readInt();
            //读取性别...
            bytes = new byte[10];
            raf.read(bytes);
            String sex=new String(bytes,"UTF-8").trim();
            //读取薪水
            int salary = raf.readInt();
            //读取日期
            bytes = new byte[30];
            raf.read(bytes);
            String str = new String(bytes, "UTF-8").trim();
            //解析日期
            SimpleDateFormat fmt = 
                new SimpleDateFormat("yyyy-MM-dd");
            Date hiredate=fmt.parse(str);
            return new Emp(
                name,age,sex,salary,hiredate);
        }
    }
    class Emp{
        String name;
        int age;
        String sex;
        int salary;
        Date hiredate;
        public Emp(String name, int age, String sex, int salary, Date hiredate) {
            super();
            this.name = name;
            this.age = age;
            this.sex = sex;
            this.salary = salary;
            this.hiredate = hiredate;
        }
        public String toString() {
            return "Emp [name=" + name + ", age=" + age + ", sex=" + sex + ", salary=" + salary + ", hiredate=" + hiredate
                    + "]";
        }

    }

IO流

RAF 提供了文件随机读写功能，但是没有提供复杂数据的读写功能。 Java 提供了另外一套可以灵活扩展的API： IO流。

IO流在节点流基础之上提供了丰富的的扩展功能，利用这些扩展流可以大大简化IO程序的开发。

这里写图片描述

IO流按照功能可以分为两大类： 节点流和处理流

节点流

节点流是流最原始的数据源，提供流最基本的功能。

处理流

也称为高级流，过滤流，处理流是在其他流的基础之上扩展出更高级的功能。处理流的核心特点是必须依赖于另外一个流，自己不能独立功能，处理流是对另外的流进行扩展。

　输入流与输出流

流按照数据流向分为输入流和输入流：

这里写图片描述

  • InputStream 代表输入流 经常缩写为in
    • 包含核心方法 read()
    • 关闭方法 close()
  • OutputStream 输出流流 经常缩写为out
    • 包含核心方法 write()
    • 关闭方法 close()

这两个流是抽象类，不能直接使用。在实际工作中使用其实现类

文件输出流 FileOutputStream

文件输出流节点流，是以文件为目标数据源的节点流，是基本的流，只提供了基本的输出方法write()

案例：

    /**
     * 使用文件输出节点流写文件 
     */
    public class Demo06 {
        public static void main(String[] args) 
            throws Exception {
            String file="abc/fos.dat";
            //利用文件节点流打开一个文件
            //当文件不存在时候，会自动创建文件
            //文件存在时候将文件替换为新文件
            //当文件不能写时候，出现异常
            FileOutputStream out = 
                new FileOutputStream(file);
            //测试基本的 byte 数据写出方法
            //将byte写到文件中有效范围（0~255）
            out.write(65);
            out.write(66);
            //关闭文件
            out.close();
        }
    }

文件输入流

文件输入节点流，是文件作为数据来源的节点流，也是基础节点流，提供了基本的文件读取功能。

案例：

    /**
     * 测试 文件输入节点流 的读取文件
     */
    public class Demo07 {
        public static void main(String[] args) 
            throws Exception {
            String file="abc/fos.dat";
            //用文件节点输入流打开文件
            //如果文件不能打开或者文件不存在
            //就抛出异常！
            FileInputStream in = 
                new FileInputStream(file);
            //测试基本的节点流读取方法
            //每次从文件中读取一个byte(0~255)
            int b1 = in.read();
            int b2 = in.read();
            System.out.println(b1);
            System.out.println(b2);
            in.close();
        }
    }

复制一个文件

将文件输入流与文件输出流连接起来，就可以实现文件的复制功能：

    /**
     * 利用文件流实现文件的复制功能 
     * 
     * 在不使用缓冲流的情况下，读写性能很差！
     * 
     */
    public class Demo08 {
        public static void main(String[] args) 
            throws Exception{
            //打开原始输入文件
            FileInputStream in =
                new FileInputStream(
                "d:/TETRIS.zip");

            //打开目标的输出文件
            FileOutputStream out = 
                new FileOutputStream(
                "d:/TETRIS_new.zip");

            //从in里读取每个byte写到out流中
            int b;
            while((b=in.read())!=-1){
                //b代表原始文件中的每个byte
                out.write(b); 
            }
            //关闭in，out即可
            in.close(); 
            out.close();
            System.out.println("成功！");
        }
    }

这个程序性能有瑕疵。

利用缓存读写方法可以提供 文件复制性能：

    /**
     * 自定义缓存读写 
     */
    public class Demo09 {
        public static void main(String[] args) 
            throws Exception{
            //打开原始输入文件
            FileInputStream in =
                new FileInputStream(
                "d:/TETRIS.zip");
            //打开目标的输出文件
            FileOutputStream out = 
                new FileOutputStream(
                "d:/TETRIS_new.zip");
            byte[] buf=new byte[1024*8];//1K byte
            //从输入流in中读取尽可能多的byte填充
            //到缓存 buf 中，返回读取个数 1024
            //int n = in.read(buf);//1024
            //int n = in.read(buf);//1024
            //...
            //n = in.read(buf); // 1 ~ 1024
            //n = in.read(buf); // -1
            int n;
            while((n = in.read(buf))!=-1){
                //将buf中从0开始的连续n个byte
                //写到 文件流out中
                out.write(buf, 0, n);
            }

            in.close();
            out.close();
            System.out.println("OK!");
        }
    }

为了避免最后一次复制多余的byte必须使用 out.write(buf, 0, n) 方法。

缓冲流

Java提供了使用简便的高级扩展流： 缓冲流

  1. 缓冲流必须依赖一个基础流，如：节点流
  2. 缓冲流可以在不改变原有算法逻辑情况下，为流提供缓冲区，可以加快系统IO性能。

如：

    /**
     * 利用文件流实现文件的复制功能 
     * 
     * 在不使用缓冲流的情况下，读写性能很差！
     * 
     */
    public class Demo08 {
        public static void main(String[] args) 
            throws Exception{
            //打开原始输入文件
            FileInputStream fis =
                new FileInputStream(
                "d:/TETRIS.zip");

            BufferedInputStream in =
                new BufferedInputStream(fis);

            //打开目标的输出文件
            FileOutputStream fos = 
                new FileOutputStream(
                "d:/TETRIS_new.zip");

            BufferedOutputStream out=
                new BufferedOutputStream(fos); 


            //从in里读取每个byte写到out流中
            int b;
            while((b=in.read())!=-1){
                //b代表原始文件中的每个byte
                out.write(b); 
            }
            //关闭in，out即可
            in.close(); 
            out.close();
            System.out.println("成功！");
        }
    }

可以看到，复制文件的算法没有改变，只是在原有文件流的外部”套上”缓冲流，软件的IO性能就大大加快了。

KopWelkin
关注
专栏目录
NGS数据格式梳理02-SAM/BAM格式最详细解读
qq_21478261的博客
05-08 4963
全网最全介绍SAM|BAM文件文章。
LLM大模型部署实战指南：Ollama简化流程，OpenLLM灵活部署，LocalAI本地优化，Dify赋能应用开发
最新发布
丨汀、的博客
08-13 467
LLM大模型部署实战指南：Ollama简化流程，OpenLLM灵活部署，LocalAI本地优化，Dify赋能应用开发
数据结构单链表的应用_职工信息的综合运算
cfy2401926342的博客
10-16 3598
数据结构基础实验
JAVA中randomfile_java中的RandomAccessFile的用法
weixin_31221157的博客
02-28 466
Java的RandomAccessFile提供对文件的读写功能，与普通的输入输出流不一样的是RamdomAccessFile可以任意的访问文件的任何地方。这就是“Random”的意义所在。RandomAccessFile的对象包含一个记录指针，用于标识当前流的读写位置，这个位置可以向前移动，也可以向后移动。RandomAccessFile包含两个方法来操作文件记录指针。long getFilePo...
Java读写基本数据类型，以及RAF指针的操作
颜文宇的博客
05-10 753
Java读写基本数据类型，以及RAF指针的操作 public static void main(String[] args) throws IOException { RandomAccessFile raf=new RandomAccessFile("note.txt","rw"); //获取指针位置 long pos=raf.getFilePointer(); System.o...
基本IO操作--字节流
weixin_30657999的博客
05-13 204
一、InputStream与OutputStream1. 输入与输出 我们编写的程序除了自身会定义一些数据信息外，经常还会引用外界的数据，或是将自身的数据发送到外界。比如，我们编写的程序想读取一个文本文件，又或者我们想将程序中的某些数据写入到一个文件中。这时我们就要使用输入与输出。 输入： 读输出： 写流： 单向 什么是输入:输入是一个从外界进入到程序的方向，通常我们需要“读取”外界的数据...
RDD操作详解（三）Action操作
Running_Tiger的博客
03-07 1733
RDD操作详解（三）Action操作 启动spark-shell spark-shell --master spark://node-1:7077 1. first def first(): T first返回RDD中的第一个元素，不排序。 scala&gt; var rdd1 = sc.makeRDD(Array(("A","1"),("B","2"),("C",&quot
Nexus3.xx私服搭建
红嘴奎利亚雀 的专栏
08-08 4857
本文已迁移到我的新博客地址：blog.favorstack.io 欢迎访问~ Nexus的介绍参见之前的博文：http://blog.csdn.net/cloud_xy/article/details/46767645 本文是其最新版本3.xx的安装配置教程。 本文基于： Ubuntu 16.04 LTS(x64) nexus-3.0.1-01 OSS Oracle JDK-8u65 nex...
"时间序列特征提取库（TSFEL）: 用Python包实现快速数据分析和特征提取的计算成本评估
软件X 11（2020）100456原始软件出版物时间序列特征提取库Marília Barandasa，Mr.，1，Duarte Folgadoa，1，Letícia Fernandesa，SaraSantosa，Mariana Abreua，Patrícia Botaa，Hui Liub，Tanja Schultzb，Hugo ...
链表综合算法设计
12-17
数据结构综合实验题，设一个职工文件emp.dat，每个职工记录包含职工编号
Emp.java 员工表实体类
12-05
Oracle数据库员工表实体类
算法与数据课设参考题目
12-09
算法与数据课设参考题目,一、职工信息的综合运算 有一个职工文件emp.txt,职工记录包含职工编号、姓名、部门号和工资数，设计一个程序实现以下功能 1）从emp.txt文件中读出职工记录，建立一个带头节点的单链表L 2）输入一个或多个职工记录 3）显示所有职工记录 4）按职工编号对所有职工记录递增有序排列 5）按工资数对所有职工记录递增有序排列 5）删除指定职工号的职工记录 6）删除职工文件中的所有记录
数据结构：职工信息的综合运算
热门推荐
Rivival_S 的博客
10-22 1万+
目的：深入掌握单链表应用的算法设计。 内容：设有一个职工文件emp.dat，每个职工记录包含职工编号（no），姓名（name），部门号（depno），和工资数（salary）信息。这几一个程序完成以下功能 （1）从emp.dat文件中读取出职工记录，并建立一个带头结点链表。（这点不作要求，从键盘录入即可） （2）输入一个职工记录。 （3）显示所有职工记录。 （4）按编号no对所有职工记录
java修改文件内容
09-02 429
文件的读和写，大家都不陌生，但是修改呢？按照普通的读写流去修改的话，只能全部读取出来，在内存中修改好后，全部写进去，这样对于文件内容过多的时，性能很低。 最近在遇到这个问题的时候，发现RandomAccessFile这个类正好能解决我的问题，废话不多说，下面直接贴代码，分享给大家，有不对的地方欢迎指教，谢谢 /** * 修改文件内容 * @...
Java 实现文件随机读写-RandomAccessFile
AAA821的专栏
10-22 632
RandomAccessFile的作用在于，我们不需要把整个文件加载进内存，它是像类似于指针一样的东西，实现读写 这是我的目标文件 public class RandomAccessFileTest { public static void main(String[] args) throws Exception { RandomAccessFile raf = new Rando...
按照字节数读取文件
荒的博客
12-24 2825
/** * 将emp.dat文件中所有员工解析出来，并创建为若干Emp实例存入一个 * 集合，然后输出该集合中每个员工信息。 * 该文件800字节，每80个字节为一个员工的信息。 * 其中: * name为字符串，长度为32个字节，编码为:UTF-8 * age为int,长度为4个字节 * gender为字符串，长度为10个字节，编码为:UTF-8 * salary
什么是RandomAccessFile
qq_36877577的博客
03-22 323
特点： 1：该对象即可读取，又可写入。 2：该对象中的定义了一个大型的byte数组，通过定义指针来操作这个数组。 3：可以通过该对象的getFilePointer()获取指针的位置，通过seek()方法设置指针的位置。 4：该对象操作的源和目的必须是文件。  5：其实该对象内部封装了字节读取流和字节写入流。 注意：实现随机访问，最好是数据有规律。 class RandomAc
raf部分API
Dreamer丶的博客
08-30 578
package raf; import java.io.FileNotFoundException; import java.io.IOException; import java.io.RandomAccessFile; /** java.io.RandomAccessFile RAF是专门用来读写文件数据的类,其基于指针对文件数据随机读写 @author ChenYi @date 2019....
"操作系统硬件环境概述：必要基础与重要资源
操作系统课件02操作系统的硬件环境概述了任何系统软件都是硬件功能的延伸，操作系统直接依赖于硬件条件。OS的硬件环境以较分散的形式同各种管理相结合，实现操作系统时必须理解的计算机基本结构以及操作系统管理的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值