（Java学习笔记）JavaSE IO流

最新推荐文章于 2023-07-08 14:35:46 发布
最新推荐文章于 2023-07-08 14:35:46 发布
阅读量512 收藏 5
点赞数 3
分类专栏： JavaSE笔记 文章标签： java javase
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43110389/article/details/105456554
版权

IO流

1、File 类

java.io.File类：：文件和文件目录路径的抽象表示形式，与平台无关

File类的一个对象就代表一个文件或一个文件目录（俗称文件夹）

1.1、File类的构造器

  • public File(String pathname) 以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果 pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。

    绝对路径：是一个固定的路径,从盘符开始 相对路径：是相对于某个位置开始

  • public File(String parent,String child) 以parent为父路径，child为子路径创建File对象。

  • public File(File parent,String child) 根据一个父File对象和子文件路径创建File对象

    //实例化File对象
    @Test
    public void test1(){
        //构造器一
        File file = new File("hello.txt");//相对路径：IDEA 的module下
        File file1 = new File("E:\\Workspace_idea01\\JavaSenior\\he.txt");//绝对路径：包含盘符
        //构造器二
        File file2 = new File("E:\\Workspace_idea01\\", "JavaSenior");
        System.out.println(file2);
        //构造器三
        File file3 = new File(file2, "hi.txt");
    }

1.2、路径分隔符

路径中的每级目录之间用一个路径分隔符隔开。

路径分隔符和系统有关：

  • windows和DOS系统默认使用“\”来表示
  • UNIX和URL使用“/”来表示

Java程序支持跨平台运行，因此路径分隔符要慎用。

为了解决这个隐患，File类提供了一个常量： public static final String separator。根据操作系统，动态的提供分隔符。

File file1 = new File("d:\\zck\\info.txt");
File file2 = new File("d:" + File.separator + "zck" + File.separator + "info.txt");
File file3 = new File("d:/zck");

1.3、File类常用方法

1.31、File类的获取功能

public String getAbsolutePath()：获取绝对路径
public String getPath() ：获取路径
public String getName() ：获取名称
public String getParent()：获取上层文件目录路径。若无，返回null
public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
public long lastModified() ：获取最后一次的修改时间，毫秒值

 @Test
    public void test2(){
        File file1 = new File("hello.txt");//已创建：内容为hello123
        File file2 = new File("e:\\io\\hi.txt");//未创建

        System.out.println(file1.getAbsolutePath());
        System.out.println(file1.getPath());
        System.out.println(file1.getName());
        System.out.println(file1.getParent());
        System.out.println(file1.length());
        System.out.println(new Date(file1.lastModified()));

        System.out.println();

        System.out.println(file2.getAbsolutePath());
        System.out.println(file2.getPath());
        System.out.println(file2.getName());
        System.out.println(file2.getParent());
        System.out.println(file2.length());
        System.out.println(file2.lastModified());
    }

程序执行结果

E:\Workspace_idea01\JavaSenior\hello.txt
hello.txt
hello.txt
null
8
Fri Apr 10 13:49:49 CST 2020

d:\io\hi.txt
d:\io\hi.txt
hi.txt
d:\io
0
0

如下的两个方法适用于文件目录：
public String[] list() ：获取指定目录下的所有文件或者文件目录的名称数组
public File[] listFiles() ：获取指定目录下的所有文件或者文件目录的File数组

@Test
    public void test3(){
        File file = new File("E:\\Workspace_idea01");
        String[] list = file.list();
        for (String s : list){
            System.out.println(s);
        }
        System.out.println("********************");
        File[] files = file.listFiles();
        for (File f : files){
            System.out.println(f);
        }
    }

程序执行结果

.idea
JavaSenior

E:\Workspace_idea01.idea
E:\Workspace_idea01\JavaSenior

在这里插入图片描述

1.32、File类的重命名功能

public boolean renameTo(File dest):把文件重命名为指定的文件路径

要想保证返回true,需要file1在硬盘中是存在的，且file2不能在硬盘中存在。

 @Test
    public void test4(){
        File file1 = new File("hello.txt");
        File file2 = new File("E:\\io\\hi.txt");

        boolean renameTo = file2.renameTo(file1);
        System.out.println(renameTo);//若E:\\io\\hi.txt存在，返回false
    }

1.33、File类的判断功能

public boolean isDirectory()：判断是否是文件目录
public boolean isFile() ：判断是否是文件
public boolean exists() ：判断是否存在
public boolean canRead() ：判断是否可读
public boolean canWrite() ：判断是否可写
public boolean isHidden() ：判断是否隐藏

1.34、File类的创建、删除功能

  • 创建硬盘中对应的文件或文件目录
    public boolean createNewFile() ：创建文件。若文件存在，则不创建，返回false
    public boolean mkdir() ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
    public boolean mkdirs() ：创建文件目录。如果此文件目录存在，就不创建了。如果上层文件目录不存在，一并创建

  • 删除磁盘中的文件或文件目录

    public boolean delete()：删除文件或者文件夹
    删除注意事项：Java中的删除不走回收站。

 @Test
    public void test4() throws IOException {
        File file1 = new File("hi.txt");
        if(!file1.exists()){
            //文件的创建
            file1.createNewFile();
            System.out.println("创建成功");
        }else{//文件存在
            file1.delete();
            System.out.println("删除成功");
        }
    }
    @Test
    public void test5(){
        //文件目录的创建
        File file1 = new File("e:\\io\\io1\\io3");

        boolean mkdir = file1.mkdir();
        if(mkdir){
            System.out.println("创建成功1");
        }

        File file2 = new File("e:\\io\\io1\\io4");

        boolean mkdir1 = file2.mkdirs();
        if(mkdir1){
            System.out.println("创建成功2");
        }
        //要想删除成功，io4文件目录下不能有子目录或文件
        File file3 = new File("E:\\io\\io1\\io4");
        file3 = new File("E:\\io\\io1");
        System.out.println(file3.delete());
    }
}

2、IO流原理及流的分类

2.1、IO流原理

I/O是Input/Output的缩写， I/O技术是非常实用的技术，用于 处理设备之间的数据传输。如读/写文件，网络通讯等。

  • Java程序中，对于数据的输入/输出操作以“流(stream)” 的 方式进行。
  • java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。

IO原理：

  • 输入input：读取外部数据（磁 盘、光盘等存储设备的数据）到程序（内存）中。
  • 输出output：将程序（内存） 数据输出到磁盘、光盘等存储设 备中。

2.2、流的分类

按操作数据单位不同分为：字节流(8 bit)，字符流(16 bit)

按数据流的流向不同分为：输入流，输出流

按流的角色的不同分为：节点流，处理流

抽象基类字节流字符流
输入流InputStreamReader
输出流OutputStreamWriter

注：Java的IO流共涉及40多个类，实际上非常规则，都是从如下4个 抽象基类派生的。

由这四个类派生出来的子类名称都是以其父类名作为子类名后缀。

IO 流体系：
在这里插入图片描述

3、节点流（或文件流）重点

对于文本文件(.txt,.java,.c,.cpp)，使用字符流处理

对于非文本文件(.jpg,.mp3,.mp4,.avi,.doc,.ppt,…)，使用字节流处理

3.1、读取文件（文本文件）

//1.建立一个流对象，将已存在的一个文件加载进流。
	FileReader fr = new FileReader(new File(“Test.txt”)); 
//2.创建一个临时存放数据的数组。 
    char[] ch = new char[1024]; 
//3.调用流对象的读取方法将流中的数据读入到数组中。 
    fr.read(ch); 
//4. 关闭资源。 
    fr.close();

举例：

package com.zck.iotest;

import org.junit.Test;

import java.io.File;
import java.io.FileReader;
import java.io.IOException;

/**
 * @author zck
 * @create 2020-04-11 11:00
 */
public class FileTest1 {
    /*
    读取当前module下的hello.txt文件（已创建），并输出到控制台
     */
    @Test
    public void testFileReader() {
        FileReader fr = null;
        try {
            //1.实例化File类的对象，指明要操作的文件
            File file = new File("hello.txt");
            //2.提供具体的流
            fr = new FileReader(file);
            //3.数据的读入
            int date;
            while ((date = fr.read()) != -1) {//read():返回读入的一个字符。如果达到文件末尾，返回-1
                System.out.print((char) date);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.流的关闭
            try {
                if(fr != null)
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /*
    对read()操作升级：使用read的重载方法
    read(char[] cbuf):返回每次读入cbuf数组中的字符的个数。如果达到文件末尾，返回-1
     */
    @Test
    public void testFileReader1() {
        FileReader fr = null;
        try {
            //1.实例化File类的对象，指明要操作的文件
            File file = new File("hello.txt");
            //2.提供具体的流
            fr = new FileReader(file);
            //3.数据的读入
            char[] cbuf = new char[5];
            int len;
            while ((len = fr.read(cbuf)) != -1) {
                //方式一：
//                for (int i = 0; i < len; i++) {
//                    System.out.print(cbuf[i]);
//                }
                //方式二：
                String str = new String(cbuf,0,len);
                System.out.print(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.流的关闭
            try {
                if(fr != null)
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

3.2、写出文件（文本文件）

 /*
     对当前module下的hello.txt文件（已创建）进行写出操作：从内存中写出数据到硬盘的文件里。
     说明：
    1. 写出操作，对应的File可以不存在的。并不会报异常
    2.
   File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件。
   File对应的硬盘中的文件如果存在：
       如果流使用的构造器是：FileWriter(file,false) / FileWriter(file):对原有文件的覆盖
       如果流使用的构造器是：FileWriter(file,true):不会对原有文件覆盖，而是在原有文件基础上追加内容
     */
    @Test
    public void testFileWriter(){
        FileWriter fw = null;
        try {
            //创建流并指明操作的文件对象
            fw = new FileWriter(new File("hello1.txt"), false);
            //写出操作
            fw.write("I love learning JAVA\n");
            fw.write("I can succeed");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭流资源
            try {
                if(fw != null)
                fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

3.3、读写非文本文件

package com.zck.iotest;

import org.junit.Test;

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

/**
 * @author zck
 * @create 2020-04-11 10:22
 */

/*
使用节点流（文件流）对非文本文件（视频、音频、doc、pdf...）进行一个复制操作
 */
public class FileTest {
    public void copyFile(String srcPath, String destPath) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            //1.造文件:实例化File类的对象，指明要操作的文件
            File srcFile = new File(srcPath);
            File destFile = new File(destPath);
            //2.造流:提供具体的流
            fis = new FileInputStream(srcPath);
            fos = new FileOutputStream(destPath);
            //3.复制
            byte[] buffer = new byte[1024];
            int len;//记录每次读入buffer的字节个数
            while ((len = fis.read(buffer)) != -1) {//如果达到文件末尾，返回-1
                fos.write(buffer, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭资源
            try {
                if(fis != null)
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(fos != null)
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    @Test
    public void test1() {//举例测试
        long start = System.currentTimeMillis();
        String srcPath = "C:\\Users\\hd\\Desktop\\《Effective Java中文版 第2版》.pdf";
        String destPath = "C:\\Users\\hd\\Desktop\\《Effective Java中文版 第2版》1.pdf";
        copyFile(srcPath, destPath);
        long end = System.currentTimeMillis();
        System.out.println("复制花费的时间：" + (end - start));//755
    }
}

4、缓冲流（处理流一）重点

Java API提供了带缓冲功能的流类，在使用这些流类时，会创建一个内部缓冲区数组，缺省使用8192个字节(8Kb)的缓冲区。、提高数据读写的速度

package com.zck.iotest;

import org.junit.Test;
import java.io.*;

/**
 * @author zck
 * @create 2020-04-11 11:40
 */
public class BufferedTest {
    /*
    使用缓冲流对非文本文件（视频、音频、doc、pdf...）进行一个复制操作
     */
    public void copyFile(String srcPath, String destPath) {
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            //1.造文件:实例化File类的对象，指明要操作的文件
            File srcFile = new File(srcPath);
            File destFile = new File(destPath);
            //2.造流:提供具体的流
            //2.1造节点流
            FileInputStream fis = new FileInputStream(srcPath);
            FileOutputStream fos = new FileOutputStream(destPath);
            //2.2造缓冲流
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);
            //3.复制
            byte[] buffer = new byte[1024];
            int len;//记录每次读入buffer的字节个数
            while ((len = bis.read(buffer)) != -1) {//如果达到文件末尾，返回-1
                bos.write(buffer, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭资源
            try {
                if(bis != null)
                bis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(bos != null)
                bos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    @Test
    public void test1(){
        long start = System.currentTimeMillis();
        String srcPath = "C:\\Users\\hd\\Desktop\\《Effective Java中文版 第2版》.pdf";
        String destPath = "C:\\Users\\hd\\Desktop\\《Effective Java中文版 第2版》1.pdf";
        copyFile(srcPath, destPath);
        long end = System.currentTimeMillis();
        System.out.println("复制花费的时间：" + (end - start));//755 ---》202
    }
}

	 /*
    使用BufferedReader和BufferedWriter实现文本文件的复制
     */
	@Test
    public void testBufferedReaderBufferedWriter() {
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            //创建文件和相应的流
            br = new BufferedReader(new FileReader(new File("hello.txt")));
            bw = new BufferedWriter(new FileWriter(new File("hello1.txt")));

            //读写操作
            //方式一：使用char[]数组
//            char[] cbuf = new char[1024];
//            int len;
//            while((len = br.read(cbuf)) != -1){
//                bw.write(cbuf,0,len);
//    //            bw.flush();
//            }
            //方式二：使用String
            String data;
            while ((data = br.readLine()) != null) {
                //方法一：
//                bw.write(data + "\n");//data中不包含换行符
                //方法二：
                bw.write(data);//data中不包含换行符
                bw.newLine();//提供换行的操作
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            if (bw != null) {
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

5、转换流（处理流二）

转换流提供了在字节流和字符流之间的转换（字节-----字符-----字节）：先解码，后编码

编码：字符串-----》字节数组

解码：字节数组------》字符串

  • Java API提供了两个转换流

    • InputStreamReader：将InputStream转换为Reader（将字节的输入流转换为字符的输入流）
    • OutputStreamWriter：将Writer转换为OutputStream（将字符的输出流转换成字节的输出流）

  • 字节流中的数据都是字符时，转成字符流操作更高效。

  • 很多时候我们使用转换流来处理文件乱码问题。实现编码和解码的功能。

5.1、InputStreamReader

  • 实现将字节的输入流按指定字符集转换为字符的输入流。
  • 需要和InputStream“套接”。
  • 构造器
  • public InputStreamReader(InputStream in)
  • public InputSreamReader(InputStream in,String charsetName)

5.2、OutputStreamWriter

  • 实现将字符的输出流按指定字符集（ charsetName）转换为字节的输出流。
  • 需要和OutputStream“套接”。
  • 构造器
  • public OutputStreamWriter(OutputStream out)
  • public OutputSreamWriter(OutputStream out,String charsetName)

5.3、补充：字符编码

编码表的由来：计算机只能识别二进制数据，早期由来是电信号。为了方便应用计算机，让它可以识 别各个国家的文字。就将各个国家的文字用数字来表示，并一一对应，形成一张表。 这就是编码表。

常见的编码表：

  • ASCII：美国标准信息交换码。 用一个字节的7位可以表示。

  • ISO8859-1：拉丁码表。欧洲码表 用一个字节的8位表示。

  • GB2312：中国的中文编码表。最多两个字节编码所有字符

  • GBK：中国的中文编码表升级，融合了更多的中文文字符号。最多两个字节编码

  • Unicode：国际标准码，融合了目前人类使用的所有字符。为每个字符分配唯一的字符码。所有的文字都用两个字节来表示。

  • Unicode只是定义了一个庞大的、全球通用的字符集，并为每个字符规定了唯 一确定的编号，具体存储成什么样的字节流，取决于字符编码方案。推荐的 Unicode编码是UTF-8和UTF-16。

  • UTF-8：变长的编码方式，可用1-4个字节来表示一个字符。

UTF8就是每次8个位传输数据，UTF-16就是每次16个位。这是为传输而设计的编码，并使编码无国界，这样就可以显示全世界上所有文化的字符了。

6、标准输入、输出流（处理流三）

System.in和System.out分别代表了系统标准的输入和输出设备

默认输入设备是：键盘，输出设备是：显示器

  • System.in的类型是InputStream

  • System.out的类型是PrintStream，其是OutputStream的子类 FilterOutputStream 的子类

  • 重定向：通过System类的setIn（），setOut（）对默认设备进行改变。

    • public static void setIn(InputStream in)
    • public static void setOut(PrintStream out)

7、打印流（处理流四）

实现将基本数据类型的数据格式转化为字符串输出

打印流：PrintStream和PrintWriter

  • 提供了一系列重载的print()和println()方法，用于多种数据类型的输出
  • PrintStream和PrintWriter的输出不会抛出IOException异常
  • PrintStream和PrintWriter有自动flush功能
  • PrintStream 打印的所有字符都使用平台的默认字符编码转换为字节。 在需要写入字符而不是写入字节的情况下，应该使用 PrintWriter 类。
  • System.out返回的是PrintStream的实例

8、 数据流（处理流五）

数据流有两个类：(用于读取和写出基本数据类型、String类的数据）

DataInputStream 和 DataOutputStream

分别“套接”在 InputStream 和 OutputStream 子类的流上

可以更方便地操作Java语言的基本数据类型和String的数据。

9、对象流（处理流六）序列化

用于存储和读取基本数据类型数据或对象的处理流。它的强大之处就是可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。

ObjectInputStream（进行反序列化）和OjbectOutputSteam（进行序列化）

补充：ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量

9.1、对象流的使用

序列化：使用ObjectOutputStream类实现将内存中的java对象、基本数据类型保存到磁盘中，或通过网络传输出去
反序列化：使用ObjectInputStream类实现將磁盘文件中的对象还原为内存中的一个java对象

package com.zck.iotest;

import org.junit.Test;

import java.io.*;

/**
 * 对象流的使用
 *
 * @author zck
 * @create 2020-04-11 15:13
 */
public class ObjectInputStreamTest {
    /*
    序列化：将内存中的java对象、基本数据类型保存到磁盘中，或通过网络传输出去
    使用ObjectOutputStream类实现
     */
    @Test
    public void test1() {

        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream("object.dat"));

            oos.writeObject(new String("学习使我强大！！！"));
            oos.flush();//刷新操作者
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (oos != null)
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
        }
    }
    /*
    反序列化：將磁盘文件中的对象还原为内存中的一个java对象
    使用ObjectInputStream类实现
     */
    @Test
    public void test2(){
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(new FileInputStream("object.dat"));
            Object object = ois.readObject();
            String str = (String) object;
            System.out.println(str);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }finally {
            if (ois != null)
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
        }
    }
}

9.2、对象的序列化

9.21、对象序列化机制

对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传 输到另一个网络节点。当其它程序获取了这种二进制流，就可以恢复成原来的Java对象。

序列化是 RMI（Remote Method Invoke – 远程方法调用）过程的参数和返回值都必须实现的机制，而 RMI 是 JavaEE 的基础。因此序列化机制是 JavaEE 平台的基础

Java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的 serialVersionUID与本地相应实体类的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异 常。(InvalidCastException)

9.22、可序列化要求

  1. 该类必须需要实现接口：Serializable，否则，会抛出NotSerializableException异常
  2. 该类需要提供一个全局常量：serialVersionUID （为了表示序列化版本标识符）
    • private static final long serialVersionUID;
    • serialVersionUID用来表明类的不同版本间的兼容性。简言之，其目的是以序列化对象进行版本控制，有关各版本反序列化时是否兼容。
    • 如果类没有显示定义这个静态常量，它的值是Java运行时环境根据类的内部细节自动生成的。若类的实例变量做了修改，serialVersionUID 可能发生变化。故建议， 显式声明
  3. 该类的内部所有属性必须是可序列化的（默认情况下，基本数据类型均可序列化）（static和transient修饰的成员变量不能进行序列化）

10、随机存取文件流

随机存取文件流：RandomAccessFile 类

RandomAccessFile 声明在java.io包下，但直接继承于java.lang.Object类。并 且它实现了DataInput、DataOutput这两个接口，也就意味着这个类既可以读也可以写。

/*
 * RandomAccessFile的使用
 * 1.RandomAccessFile直接继承于java.lang.Object类，实现了DataInput和DataOutput接口
 * 2.RandomAccessFile既可以作为一个输入流，又可以作为一个输出流
 *
 * 3.如果RandomAccessFile作为输出流时，写出到的文件如果不存在，则在执行过程中自动创建。
 *   如果写出到的文件存在，则会对原有文件内容进行覆盖。（默认情况下，从头覆盖）
 *
 * 4. 可以通过相关的操作，实现RandomAccessFile“插入”数据的效果
 */
    @Test
    public void test1() {

        RandomAccessFile raf1 = null;
        RandomAccessFile raf2 = null;
        try {
            //1.
            raf1 = new RandomAccessFile(new File("psycho pass.jpg"),"r");
            raf2 = new RandomAccessFile(new File("psycho pass1.jpg"),"rw");
            //2.
            byte[] buffer = new byte[1024];
            int len;
            while((len = raf1.read(buffer)) != -1){
                raf2.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //3.
            if(raf1 != null){
                try {
                    raf1.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(raf2 != null){
                try {
                    raf2.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Test
    public void test2() throws IOException {
        RandomAccessFile raf1 = new RandomAccessFile("hello.txt","rw");

        raf1.seek(3);//将指针调到角标为3的位置
        raf1.write("xyz".getBytes());/
        raf1.close();
    }
    /*
    使用RandomAccessFile实现数据的插入效果
     */
    @Test
    public void test3() throws IOException {
        RandomAccessFile raf1 = new RandomAccessFile("hello.txt","rw");

        raf1.seek(3);//将指针调到角标为3的位置
        //保存指针3后面的所有数据到StringBuilder中
        StringBuilder builder = new StringBuilder((int) new File("hello.txt").length());
        byte[] buffer = new byte[20];
        int len;
        while((len = raf1.read(buffer)) != -1){
            builder.append(new String(buffer,0,len)) ;
        }
        //调回指针，写入“xyz”
        raf1.seek(3);
        raf1.write("xyz".getBytes());

        //将StringBuilder中的数据写入到文件中
        raf1.write(builder.toString().getBytes());

        raf1.close();
    }
}

注：本文章是根据哔哩哔哩公开课 Java -Java 学习- Java 基础到高级-宋红康-零基础自学Java-尚硅谷 整理所得
大爱康师傅！！！

小张不会飞
关注
  • 3
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java学习笔记12 IO流
gyct123的博客
04-06 102
1. 流 1.1 流的概念 流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称和抽象。 数据在两个设备之间的传输称之为流。 流的本质是数据的传输。 1.2 流的分类 (1) 根据流向不同 输入流：写入到内存中的流。 输出流：从内存中读出的流。 (2) 根据数据类型不同： 字符流：操作的基本单元为unicode码元，使用缓冲区，特殊字节流。 字节流：操作的基本单元为字节，默认不使用缓冲区，所有的数据都可以使用字节流来处理。 2. 文件 File类：文件和目录路径..
非常详细javaSE学习笔记.rar
10-21
这份“非常详细JavaSE学习笔记.rar”压缩包显然是一份全面的Java SE学习资源，包含了从基础知识到高级特性的全方位讲解。下面，我们将详细探讨这份笔记可能涵盖的关键知识点。 1. **Java起源与环境搭建**：笔记可能...
Java学习笔记-JavaSE高级
最新发布
qq_60626054的博客
07-08 165
线程同步机制，如使用锁、互斥量和信号量等，用于协调和控制线程的访问，保证数据的一致性和线程的安全性。Java的集合框架还提供了其他接口和类，如Deque（双端队列）、Iterator（迭代器）、Collections（集合工具类）等，用于处理不同的集合需求。它提供了统一的接口和模型，用于读取和写入不同类型的数据。基于数组实现，在频繁的插入和删除操作时，可能会导致数组的扩容和元素的移动，从而影响性能。需要注意的是，当使用迭代器遍历集合时，应避免直接使用集合的方法来进行元素的增删操作，而是应该使用迭代器的。
Java学习笔记-JavaSE基础
qq_60626054的博客
07-06 114
除了上述异常外，还有许多其他类型的异常，如NumberFormatException（数字格式异常）、IllegalStateException（非法状态异常）、OutOfMemoryError（内存溢出错误）等，每种异常都有特定的原因和使用场景。在多态的情况下，子类特有的方法和属性无法通过父类引用访问。：在分配内存后，JVM会将分配的内存空间初始化为默认的零值，即将对象的所有成员变量初始化为其对应类型的默认值（例如，整数类型初始化为0，布尔类型初始化为false，引用类型初始化为null等）。
JAVA学习笔记—IO流
weixin_42823298的博客
01-11 96
I/O 框架笔记
java中的io流
m0_66689823的博客
07-19 9843
流是一种抽象概念，它代表了数据的无结构化传递。按照流的方式进行输入输出，数据被当成无结构的字节序或字符序列。从流中取得数据的操作称为提取操作，而向流中添加数据的操作称为插入操作。用来进行输入输出操作的流就称为IO流。换句话说，IO流就是以流的方式进行输入输出 。
osw java_Java学习笔记：IO流
weixin_39634022的博客
02-13 133
FileFile类概述和构造方法File：它是文件和目录路径名的抽象表示文件和目录是可以通过File封装成对象的对于File而言，封装的并不是一个真正存在的文件，仅仅是一个路径而已。这个路径可以存在也可以不存在，但将来是要通过具体的操作把这个路径的内容转换为具体存在的构造方法File(String pathname)通过将给定的路径名字符串转换为抽象路径名来创建新的File实例File f1= n...
JavaSE-IO流2，学习笔记
weixin_64094228的博客
05-06 110
Write的基本方法 public class WriterDemo { public static void main(String[] args) { File file = new File("a4.txt"); Writer writer = null; try { writer = new FileWriter(file,false); writer.write(99);
JavaSE学习笔记-Java IO流
HaLosec_Wei
07-24 169
计算机中表示信息的机制 计算机本身只能表示0和1两种状态1、如何表示数量呢？ 使用二进制规则 : 100 其实表示的量是十进制的4那么大 而且，计算机通常把8个二进制符号(bit)称为一个字节：byte 2、如何表示字符呢？ 比如英文字母，标点符号，阿拉伯数字符号，汉字等？ 需要先将这些信息按照某个码表（编码规则）转成"数"，然后再把“数”变成二进制 英文字母的国际通用编码规则： as...
Java学习笔记（javase）
03-03
"Java学习笔记（javase）"这份资料主要涵盖了Java Standard Edition（Java SE）的基础知识，它是Java平台的核心，为桌面应用和服务器端应用提供了运行环境。这份笔记可能是作者在深入学习Java SE的过程中，对关键...
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
JavaSE精华笔记.zip
01-06
基础扎实是进阶学习的关键，这部分笔记将帮助读者确保对Java的基本理解无遗漏。 2. **Java异常处理.pdf**： 异常处理是Java编程中的重要部分，用于处理程序运行时可能出现的问题。Java提供了try-catch-finally语句...
JAVASE学习笔记
09-03
3. **流与IO**（马士兵_J2SE第八章_流_IO_个人学习笔记.doc）：Java的流API提供了一种处理输入/输出的方式，包括字节流和字符流，分为节点流和处理流。流的方向可以是输入、输出或者双向。IO操作涉及文件、网络、...
（java学习笔记）JavaSE基础
陌然白（小白）的博客
03-31 2803
Java技术体系平台 JavaSE ：标准版 面向桌面型应用（Windows下的应用程序）的Java平台。提供完整的Java核心API，也叫J2SE. JavaEE：企业版 开发企业环境下的应用程序。该技术体系中包含的技术 Servlet Jsp。主要针对Web应用程序开发。也叫J2EE. JavaME：小型版 支持Java程序运行在移动终端（手机、PDA：掌上电脑 条码扫描器、RFID读写器、P...
（java学习笔记）JavaSE面向对象
陌然白（小白）的博客
04-04 1111
总：学习面向对象内容的三条主线 ​ 1.Java类及类的成员 ：属性 方法 构造器；代码块 内部类 ​ 2.面向对象的三大特征 ：封装 继承 多态 ​ 3.其它关键字 this super static final abstract interface package import… 文章目录总：学习面向对象内容的三条主线一、面向对象的两个要素1.类（Class）2.对象（O...
（Java学习笔记）JavaSE 网络编程基础
陌然白（小白）的博客
04-18 612
网络编程基础1、网络编程概述2、网络通信要素概述2.1、如何实现网络中的主机互相通信2.2、网络通信协议3、通信要素一：IP和端口号3.1、IP地址3.11、作用：3.12、IP地址分类方式3.13、如何获取IP地址3.2、端口号4、通信要素二：网络协议4.1、基本概念4.2、TCP/IP协议簇4.21、TCP协议4.22、UDP协议5、TCP网络编程(基于Socket)6、UDP网络编程7、UR...
（Java学习笔记）JavaSE 多线程
陌然白（小白）的博客
04-06 519
多线程 文章目录多线程1、 基本概念 程序、进程、线程2、线程的创建和使用（重点）2.1、Thread类2.2、Thread类中有关的基本方法2.3、线程调度 时间片式 抢占式等2.4、JDK5.0之前创建线程的两种方式2.41方式一：继承Thread类2.42方式二：实现Runnable接口2.43、比较创建线程的两种方式2.5、jDK5.0新增创建线程的两种方式2.51、方式一...
2022年最全的java学习笔记必看.docx
11-04
异常处理机制、文件操作、IO流等都是JavaSE中的重要组成部分，笔记也一一进行了介绍。 通过这份全面的Java学习笔记，读者可以系统地掌握Java编程语言的各个方面，从基础知识到高级应用，为成为熟练的Java开发者奠定...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值