Java--IO流-天翼云

一、File类的使用

File类的使用

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

File能新建、删除、重命名文件和目录，但File不能访问文件内容本身。如果需要访问文件内容本身，则需要使用输入/输出流

想要在Java程序中表示一个真实存在的文件或目录，那么必须有一个File对象，但是Java程序中的一个File对象，可能没有一个真实存在的文件或目录

File对象可以作为参数传递给流的构造器

路径分隔符

windows:\
unix:/

常用方法

package com.caq.java;

import org.junit.Test;

import java.io.File;

/**
 * File类的使用
 *
 * 1.File类的一个对象，代表一个文件或一个文件目录
 * 2.File类声明在java.io包下
 *
 *
 *
 *
 */
public class FileDemo01 {


    /**
     1.如何创建File类的实例
        File(String pathname)
        File(String parent,String child)
     2.相当路径：相较于某个路径下，指明的路径
    绝对路径：包含盘符在内的文件或者文件夹的路径
     3.路径分隔符
        windows:\\
        unix:/

     */
    @Test
    public void test1(){
        /**
         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 f1 = new File("hello.txt");//相对于当前moudle
        File f2 = new File("D:\\Code\\he.txt");//加两个杠是因为不想让它进行转义

        System.out.println(f1);
        System.out.println(f2);

        //构造器二
        File f3 = new File("\\Code", "test");
        System.out.println(f3);

        //构造器三
        File f4 = new File(f3,"hello.txt");
        System.out.println(f4);

    }


}

二、IO流原理及流的分类

JavaIO原理

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

Java程序中，对于数据的输入/输出操作以==“流(stream“==的方式进行

java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。

输入input:读取外部数据(磁盘、光盘等存储设备的数据)到程序(内存)中
输出output:将程序(内存) 数据输出到磁盘、光盘等存储设备中

强哥说Java--IO流

流的分类

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

字节就是一个byte（010101），常用来处理图片啊，视频啊之类的

一个一个的char（2个字节），常用来处理字符，比如文本之类的

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

输入：读取外部数据到内存中

输出：将内存中数据输出到磁盘，光盘等位置

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

节点流：流直接作用在节点上

处理流：流作用在已有的流上的

流的分类

抽象基类	字节流	字符流
输入流	InputStream	Reader
输出流	OutputStream	Writer

Java的IO流共涉及40多个类，实际上非常规则，都是从如下4个抽象基类派生的。
由这四个类派生出来的子类名称都是以其父类名作为子类名后缀。

强哥说Java--IO流

节点流和处理流

节点流：直接从数据源或目的地读写数据

强哥说Java--IO流

处理流：不直接连接到数据源或目的地，而是“连接”在已存在的流(节点流或处理流)之上，通过对数据的处理为程序提供更为强大的读写功能。

强哥说Java--IO流

InputStream & Reader

InputStream和Reader是所有输入流的基类

InputStream (典型实现: FileInputStream)

int read()
int read(byte[] b)
int read(byte[] b, int off, int len)

Reader (典型实现: FileReader )

int read()
int read(char [] c)
int read(char 0 C, int off, int len)

程序中打开的文件IO资源不属于内存里的资源，垃圾回收机制无法回收该资源，所以应该显式关闭文件IO资源

FileInputStream从文件系统中的某个文件中获得输入字节FileInputStream用于读取非文本数据之类的原始字节流。要读取字符流，需要使用FileReader

InputStream

int read()
从输入流中读取数据的下一个字节。返回0到255范围内的int字节值。如果因为己经到达流末尾而没有可用的字节，则返回值-1
int read(byte[] b)
从此输入流中将最多b.length 个字节的数据读入一个byte数组中。如果因为已经到达流末尾而没有可用的字节，则返回值-1。否则以整数形式返回实际读取的字节数。
int read(byte[] b, int off,int len)
将输入流中最多len 个数据字节读入byte 数组。尝试读取len个字节，但读取的字节也可能小于该值。以整数形式返回实际读取的字节数。如果因为流位于文件末尾而没有可用的字节，则返回值-1。
public void close() throws lOException
关闭此输入流并释放与该流关联的所有系统资源

Reader

int read()
读取单个字符。作为整数读取的字符，范围在0到65535之间(0x00-0ffff (2个字节的Unicode码)，如果已到达流的末尾，则返回-1
int read(char[] cbuf)
将字符读入数组。如果已到达流的末尾，则返回-1。否则返回本次读取的字符数。
int read(char[] cbuf,int off,int len)
将字符读入数组的某一部分。存到数组cbuf中，从off处开始存储，最多读len个字符。如果已到达流的末尾，则返回-1。否则返回本次读取的字符数。
public void close() throws l0Exception
关闭此输入流并释放与该流关联的所有系统资源。

OutputStream & Writer

OutputStream

强哥说Java--IO流

Writer

强哥说Java--IO流

三、节点流(或文件流)

读取文件

@Test
    public void test() {
        FileInputStream fis = null;
        try {
            //1.指明要操作的文件
            File file = new File("hello.txt");

            //2.提供具体的流
            fis = new FileInputStream(file);

            //3.读数据
            byte[] buffer = new byte[5];
            int len;//记录每次读取的字节的个数
            while ((len = fis.read(buffer)) != -1) {
                String str = new String(buffer, 0, len);
                System.out.println(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                //4.关资源
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

写入文件

@Test
public void testFileWriter() {
    FileWriter fw = null;
    try {
        //1.提供File类的对象，指明写出到的文件
        File file = new File("hello1.txt");

        //2.提供FileWriter的对象，用于数据的写出
        fw = new FileWriter(file, false);

        //3.写出的操作
        fw.write("I hava a dream\n");
        fw.write("aoligei!");
    } catch (IOException e) {
        e.printStackTrace();
    } finally {

        //4.流资源的关闭
        try {
            if (fw != null) {
                fw.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

节点流(或文件流)：注意点

强哥说Java--IO流

四、缓冲流

什么是缓冲流？

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

强哥说Java--IO流

缓冲流要“套接”在相应的节点流之上，根据数据操作单位可以把缓冲流分为：

BufferedInputStream 和 BufferedOutputStream

BufferedReader 和 BufferedWriter

怎么工作的？

当读取数据时，数据按块读入缓冲区，其后的读操作则直接访问缓冲区
当使用BufferedInputStream读取字节文件时，BufferedInputStream会一次性从文件中读取8192个(8Kb)，存在缓冲区中，直到缓冲区装满了，才重新从文件中读取下一个8192个字节数组
向流中写入字节时，不会直接写到文件，先写到缓冲区中直到缓冲区写满，BufferedOutputStream才会把缓冲区中的数据一次性写到文件里。使用方法flush()可以强制将缓冲区的内容全部写入输出流
关闭流的顺序和打开流的顺序相反。只要关闭最外层流即可，关闭最外层流也会相应关闭内层节点流
flush()方法的使用:手动将buffer中内容写入文件
如果是带缓冲区的流对象的close()方法，不但会关闭流，还会在关闭流之前刷新缓冲区，关闭后不能再写出

图解缓冲流

强哥说Java--IO流

实例

@Test
    public void BufferdStreamTest() {
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            //1.造文件
            File srcFile = new File("cxk.jpg");
            File destFile = new File("cxk3.jpg");

            //2.造流
            //2.1节点流
            FileInputStream fis = new FileInputStream(srcFile);
            FileOutputStream fos = new FileOutputStream(destFile);
            //2.2缓冲流
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);

            //3.复制的细节：读取写入
            byte[] buffer = new byte[10];
            int len;
            while ((len = bis.read(buffer)) != -1) {
                bos.write(buffer, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.资源关闭
            //要求：先关闭外层的流，在关闭内层的流

            //说明：关闭外层流的同时，内层流会自动进行关闭，关闭内层流的操作可以省略
//        fos.close();
//        fis.close();
            if (bos != null) {
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bis != null) {
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

缓冲流练习

package com.caq.exer;

import org.junit.Test;

import java.io.*;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;


/**
 * 获取文本上字符出现的次数,把数据写入文件
 *
 * 思路：
 * 1.遍历文本每一个字符
 * 2.字符出现的次数存在Map中
 *
 * Map<Character,Integer> map = new HashMap<Character,Integer>();
 * map.put('a',18);
 * map.put('你',2);
 *
 * 3.把map中的数据写入文件
 *
 */
public class WordCount {
    /*
    说明：如果使用单元测试，文件相对路径为当前module
          如果使用main()测试，文件相对路径为当前工程
     */
    @Test
    public void testWordCount() {
        FileReader fr = null;
        BufferedWriter bw = null;
        try {
            //1.创建Map集合
            Map<Character, Integer> map = new HashMap<Character, Integer>();

            //2.遍历每一个字符,每一个字符出现的次数放到map中
            fr = new FileReader("dbcp.txt");
            int c = 0;
            while ((c = fr.read()) != -1) {
                //int 还原 char
                char ch = (char) c;
                //判断char是否在map中第一次出现
                if (map.get(ch) == null) {
                    map.put(ch, 1);
                } else {
                    map.put(ch, map.get(ch) + 1);
                }
            }

            //3.把map中数据存在文件count.txt
            //3.1 创建Writer
            bw = new BufferedWriter(new FileWriter("wordcount.txt"));

            //3.2 遍历map,再写入数据
            Set<Map.Entry<Character, Integer>> entrySet = map.entrySet();
            for (Map.Entry<Character, Integer> entry : entrySet) {
                switch (entry.getKey()) {
                    case ' ':
                        bw.write("空格=" + entry.getValue());
                        break;
                    case '\t'://\t表示tab 键字符
                        bw.write("tab键=" + entry.getValue());
                        break;
                    case '\r'://
                        bw.write("回车=" + entry.getValue());
                        break;
                    case '\n'://
                        bw.write("换行=" + entry.getValue());
                        break;
                    default:
                        bw.write(entry.getKey() + "=" + entry.getValue());
                        break;
                }
                bw.newLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关流
            if (fr != null) {
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
            if (bw != null) {
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
        }

    }
}

五、转换流

什么是转换流？

转换流提供了在字节流和字符流之间的转换

Java API提供了两个转换流：

InputStreamReader：将InputStream转换为Reader

OutputStreamWriter：将Writer转换为OutputStream

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

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

图解

实现将字节的输入流按指定字符集转换为字符的输入流。

强哥说Java--IO流

实例

package com.caq.java;
import org.junit.Test;
import java.io.*;

/**
    转换流
 2.作用:提供字节流与字符流之间的转换

 3.解码:字节、字节数组--->字符数组、 字符串
   编码:字符数组、字符串--->字节、字节数组

 4.字符集


 * @Date 2021/12/1 15:37
 * @Version 1.0
 */
public class InputStreamReaderTest {

    /*
        此时处理异常的话，仍然应该使用try-catch-finally
        InputStreamReader的使用，实现字节的输入流到字符的输入流的转换
     */
    @Test
    public void test1() throws IOException {
        FileInputStream fis = new FileInputStream("dbcp.txt");
        //使用系统默认的字符集
//        InputStreamReader isr = new InputStreamReader(fis);
        InputStreamReader isr = new InputStreamReader(fis,"gbk");

        char[] cbuf = new char[20];
        int len;
        while ((len = isr.read(cbuf)) != -1){
            String str = new String(cbuf, 0, len);
            System.out.println(str);
        }
        isr.close();
    }

    @Test
    public void  test2() throws IOException {
        //指定文件，指定流，用转换流把指定流抱起来
        InputStreamReader isr = new InputStreamReader(new FileInputStream("dbcp.txt"),"utf-8");
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("dhcp_gbk.txt"),"gbk");

        char[] cbuf = new char[20];
        int len;
        while ((len = isr.read(cbuf)) != -1){
            osw.write(cbuf,0,len);
        }

        isr.close();
        osw.close();


    }
}

字符编码

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

常见的编码表
ASCII: 美国标准信息交换码。
用一个字节的7位可以表示。

IS08859-1: 拉丁码表。欧洲码表.
用一个字节的8位表示。

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

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

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

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

强哥说Java--IO流

在Unicode出现之前，所有的字符集都是和具体编码方案绑定在一起的（即字符集≈编码方式），都是直接将字符和最终字节流绑定死了。

GBK等双字节编码方式，用最高位是1或0表示两个字节和一个字节

强哥说Java--IO流

编码:字符串→字节数组
解码:字节数组→字符串
转换流的编码应用
可以将字符按指定编码格式存储
可以对文本数据按指定编码格式来解读
指定编码表的动作由构造器完成

六、标准输入、输出流

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

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

System.in的类型是InputStream

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

重定向:通过System类的setIn，setOut方法对默认设备进行改变。
public static void setln(InputStream in)
public static void setOut(PrintStream out)

七、打印流（了解）

实现将基本数据类型的数据格式转化为字符串输出
打印流:
PrintStream和PrintWriter

➢提供了一系列重载的print()和println()方法，用于多种数据类型的输出

➢PrintStream和PrintWriter的输出不会抛出IOException异常

➢PrintStream和PrintWriter有自动flush功能

➢PrintStream打印的所有字符都使用平台的默认字符编码转换为字节，在需要写入字符而不是写入字节的情况下，应该使用PrintWriter类。

➢System.out返回的是PrintStream的实例

八、数据流（了解）

强哥说Java--IO流

九、对象流

ObjectInputStream和OjbectOutputSteam

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

序列化：用ObjectOutputStream类保存基本类型数据或对象的机制

反序列化：用ObjectInputStream类读取基本类型数据或对象的机制

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

对象的序列化

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

序列化的好处在于可将任何实现了Serializable接口的对象转化为字节数据，使其在保存和传输时可被还原

Serializable

Externalizable

凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量:
➢private static final long serialVersionUID;
➢serialVersionUID用来表明类的不同版本间的兼容性。简言之，其目的是以序列化对象进行版本控制，有关各版本反序列化时是否兼容。
➢如果类没有显示定义这个静态常量，它的值是Java运行时环境根据类的内部细节自动生成的。若类的实例变量做了修改，serialVersionUID 可能发生变化。故建议，显式声明。
简单来说，Java的序列化机制是通过在运行时判断类的serialVersionUID来验
证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体类的serialVersionUID进行比较，如果相同
就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异
常。(InvalidCastException)

流程总结

若某个类实现了Serializable 接口，该类的对象就是可序列化的:
➢创建一个ObjectOutputStream
➢调用ObjectOutputStream对象的writeObject(对象)方法输出可序列化对象
➢注意写出一次,操作flush()一次
反序列化
➢创建一个ObjectInputStream
➢调用readObject()方法读取流中的对象
强调:如果某个类的属性不是基本数据类型或String类型，而是另一个引用类型，那么这个引用类型必须是可序列化的，否则拥有该类型的Field的类也不能序列化

实例

Person类

package com.caq.java;

import java.io.Serializable;

/**

 Person类需要满足如下要求方可序列化
 1.需要实现Seriallizable接口
 2.提供一个全局常量static final long serialVersionUID = 42L;
 3.除了当前Person类需要实现Serializable接口之外，还必须保证其他所有属性
 是可序列化的！
 默认情况下，基本数据类型是可序列化的
 4.对象序列化机制允许把内存中的Java对象转换成平台
 无关的二进制流，从 而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传 输到另一个网络节点。//当其它程序获取了这种二进制流，就可以恢复成原 来的Java对象


 * @Date 2021/12/2 18:14
 * @Version 1.0
 */
public class Person implements Serializable {

    public static final long serialVersionUID = 56354763763L;

    private String name;
    private int age;

    public Person() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

对象流

package com.caq.java;

import org.junit.Test;

import java.io.*;

/**
 * ObjectInputStream和ObjectOutputStream
 * 作用：用于存储和读取基本数据或对象的处理流，
 * 它的强大之处就是可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来
 *
 * @Date 2021/12/2 17:18
 * @Version 1.0
 */

public class ObjectInputOutputStreamTest {
    /**
     * 将内存中的Java对象保存到磁盘中或通过网络传输出去
     * 使用ObjectOutputStream实现
     */

    //序列化单元测试
    @Test
    public void testObjectOutputStream() {
        ObjectOutputStream oos = null;
        try {

            //1.创建序列化流
            oos = new ObjectOutputStream(new FileOutputStream("object.dat"));

            //2.
            oos.writeObject(new String("我爱你！"));
            oos.flush();//刷新操作

            oos.writeObject(new Person("朱茵",12));
            oos.flush();//刷新操作

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (oos != null) {
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }


    //反序列化测试
    @Test
    public void testObjectOutputStream2() {
        ObjectInputStream ois = null;
        try {
            //反序列化流
            ois = new ObjectInputStream(new FileInputStream("object.dat"));
            Object obj = ois.readObject();
            String str = (String) obj;

            Person p = (Person)ois.readObject();
            System.out.println(p);

            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();
                }
            }
        }
    }
}

谈谈你对java.io.Serializable接口的理解

它用于序列化，是空方法接口

试下了Serializable接口的对象可将它们转化为一系列字节，并在以后可以将它们恢复成原来的样子。这个过程我们可以通过网络进行，这也就意味着序列化机制可以解决操作系统之间的差异的，就比如我们可以windows上序列化一个对象，我们能在unix系统上重新恢复这个对象。不必关心数据在不同机器上如何表示，也不必关心字节的顺序或者其他细节

手打的好累，，，背它！！！！！！！！！！

由于大部分作为参数的类String、Integer等都实现了Serializable接口，可以利用多态的性质，作为参数使接口更灵活

十、随机存取文件流

RandomAccessFile 类

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

RandomAccessFile 类支持 “随机访问” 的方式，程序可以直接跳到文件的任意地方来读、写文件

支持只访问文件的部分内容

可以向已存在的文件后追加内容

RandomAccessFile 对象包含一个记录指针，用以标示当前读写处的位置。

RandomAccessFile 类对象可以自由移动记录指针：

long getFilePointer()：获取文件记录指针的当前位置

void seek(long pos)：将文件记录指针定位到 pos 位

构造器 public RandomAccessFile(File file, String mode)

public RandomAccessFile(String name, String mode)

创建 RandomAccessFile 类实例需要指定一个 mode 参数，该参数指定RandomAccessFile 的访问模式：

r: 以只读方式打开

rw：打开以便读取和写入

rwd:打开以便读取和写入；同步文件内容的更新

rws:打开以便读取和写入；同步文件内容和元数据的更新

如果模式为只读r。则不会创建文件，而是会去读取一个已经存在的文件，如果读取的文件不存在则会出现异常。如果模式为rw读写。如果文件不存在则会去创建文件，如果存在则不会创建。

实例

package com.caq.java;

import org.junit.Test;

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;

/**
 * RandomAccessFile 声明在java.io包下，但直接继承于java.lang.Object类。并
 * 且它实现了DataInput、DataOutput这两个接口，也就意味着这个类既可以读也
 * 可以写。
 *
 * @Date 2021/12/2 20:27
 * @Version 1.0
 */
public class RandomFile {

    @Test
    public void test1() {
        RandomAccessFile raf1 = null;
        RandomAccessFile raf2 = null;
        try {
            raf1 = new RandomAccessFile(new File("img/cxk.jpg"), "r");
            raf2 = new RandomAccessFile(new File("cxk1.jpg"), "rw");

            byte[] buffer = new byte[1024];
            int len;
            while ((len = raf1.read(buffer)) != -1) {
                raf2.write(buffer, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (raf1 != null){
                try {
                    raf1.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (raf2 !=null){
                try {
                    raf2.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }


    //如果RandomAccessFile作为输出流时，写出到的文件如果不存在，则在执行过程中自动创建
    //如果写出到的文件存在，则会对原有文件内容进行覆盖。
    //默认从头开始覆盖

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

        raf1.seek(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的位置
        byte[] buffer = new byte[20];
        int len;
        while ((len = raf1.read(buffer)) != -1){

        }


    }
}

小节

流是用来处理数据的。

处理数据时，一定要先明确数据源，与数据目的地

数据源可以是文件，可以是键盘。

数据目的地可以是文件、显示器或者其他设备。

而流只是在帮助数据进行传输,并对传输的数据进行处理，比如过滤处理、转换处理等

活动

应用商城

合作伙伴

开发者

支持与服务

了解天翼云

Java--IO流

Java--IO流

一、File类的使用

路径分隔符

常用方法

二、IO流原理及流的分类

JavaIO原理

流的分类

节点流和处理流

InputStream & Reader

InputStream

Reader

OutputStream & Writer

OutputStream

Writer

三、节点流(或文件流)

读取文件

写入文件

节点流(或文件流)：注意点

四、缓冲流

什么是缓冲流？

怎么工作的？

图解缓冲流

实例

缓冲流练习

五、转换流

什么是转换流？

图解

实例

字符编码

六、标准输入、输出流

七、打印流（了解）

八、数据流（了解）

九、对象流

对象的序列化

流程总结

实例

谈谈你对java.io.Serializable接口的理解

十、随机存取文件流

实例

小节

相关文章

java大文件下载浏览器内存溢出

深入理解Java中的类加载机制

文件系统类型详解及选择指南

单例模式详解

【Spring相关技术】spring进阶-自定义请求报文转对象HttpMessageConverter

Nginx学习笔记 - 文件描述符限制（worker_rlimit_nofile）

Python中的优雅文件操作：利用with语句自动管理资源

计算机萌新的成长历程3——整型数据类型

Python 文件及目录操作详解

【第一章：初识Python】1.4 第一个Python程序

作者介绍

最新文章

java大文件下载浏览器内存溢出

深入理解Java中的类加载机制

单例模式详解

【Spring相关技术】spring进阶-自定义请求报文转对象HttpMessageConverter

Nginx学习笔记 - 文件描述符限制（worker_rlimit_nofile）

Python中的优雅文件操作：利用with语句自动管理资源

热门文章

Python爬虫基础——06-文件的读写

Python编程：使用cachy缓存数据

Python 文件读写的问题

Python文件字节读写

Python编程：json序列化python对象

SpringMVC-表单的序列化

热门标签

相关产品

弹性云主机

天翼云电脑（公众版）

对象存储

云硬盘

随机文章