java 输入输出流问题

请帮我编写一个Java程序,要求程序能够对文本文件进行带缓存的读写操作，可以读取文件不同位置的信息，可以进行对象序列化和对象反序列化。本人是java初学者，请尽量用基础的知识，谢谢了。
本人想法：如果要读取文件不同位置信息，是不是要用RandomAccessFile类;要进行对象序列化和反序列化，是不是要使用ObjectOutputStream与ObjectInputStream类;若要带上缓存,是不是要用BufferedOutputStream类,但是我不知道如何把它们结合起来，自己也进行了实验，但是报错了。

import java.io.*;  
import java.util.*;

public class FileReaderWriterWithCache {

    private static final int BUFFER_SIZE = 1024;  
    private static final String CACHE_FILE = "cache.txt";

    private Map<Integer, Long> cache;  
    private PrintWriter writer;  
    private BufferedReader reader;

    public FileReaderWriterWithCache() {  
        cache = new HashMap<>();  
        try {  
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(new FileOutputStream(CACHE_FILE), "utf-8")));  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
        try {  
            reader = new BufferedReader(new FileReader(CACHE_FILE));  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }

    public void read(String filename, int position) {  
        long cacheKey = position * 1024;  
        long timestamp = System.currentTimeMillis();  
        cache.put(cacheKey, timestamp);

        try {  
            BufferedReader reader = new BufferedReader(new FileReader(filename));  
            String line;  
            while ((line = reader.readLine()) != null) {  
                writer.println(line);  
            }  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }

    public void write(String filename, String content) throws IOException {  
        long cacheKey = filename.hashCode() * 1024;  
        long timestamp = System.currentTimeMillis();  
        cache.put(cacheKey, timestamp);

        try {  
            PrintWriter writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(new FileOutputStream(filename), "utf-8")));  
            writer.println(content);  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }

    public static void main(String[] args) throws IOException {  
        FileReaderWriterWithCache cache = new FileReaderWriterWithCache();

        Scanner scanner = new Scanner(System.in);  
        while (true) {  
            System.out.println("请输入要读取的文件名和位置 (以千字节为单位，例如:1000):");  
            String filename = scanner.next();  
            int position = scanner.nextInt();

            System.out.println("正在读取文件:" + filename + ",位置为:" + position + "......");

            read(filename, position);

            System.out.println("已完成读取!");

            System.out.println("请输入要写入的文件名和内容:");  
            String content = scanner.next();

            System.out.println("正在写入文件:" + filename + ",内容为:" + content + "......");

            write(filename, content);

            System.out.println("已完成写入!");

            scanner.close();  
        }  
    }  
}

import java.io.*;

public class FileIOExample {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 读取文件中的文本信息
        BufferedReader bufferedReader = new BufferedReader(new FileReader("input.txt"));
        String line;
        while ((line = bufferedReader.readLine()) != null) {
            System.out.println(line);
        }
        bufferedReader.close();

        // 在文件中指定位置写入数据
        RandomAccessFile randomAccessFile = new RandomAccessFile("output.dat", "rw");
        randomAccessFile.seek(10); // 将文件指针设置到第10个字节的位置
        randomAccessFile.writeBytes("Hello World!");
        randomAccessFile.close();

        // 对象序列化
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("data.dat"));
        Person person = new Person("张三", 25);
        objectOutputStream.writeObject(person);
        objectOutputStream.close();

        // 对象反序列化
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("data.dat"));
        Person personRead = (Person) objectInputStream.readObject();
        objectInputStream.close();
        System.out.println("姓名：" + personRead.getName() + "，年龄：" + personRead.getAge());
    }

    private static class Person implements Serializable {
        private String name;
        private int age;

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

        public String getName() {
            return name;
        }

        public int getAge() {
            return age;
        }
    }
}

首先使用BufferedReader读取了一个文件中的文本信息，并将其打印出来；然后使用RandomAccessFile在文件中指定位置写入了一些数据；最后使用ObjectOutputStream和ObjectInputStream对一个自定义对象进行了序列化和反序列化，并将其输出到控制台上。注意，Person类需要实现Serializable接口才可以被序列化。