RandomAccessFile中提到对指针的操作，我理解不够，还希望大家多给我讲讲啊，先谢谢了！

这是我对这个类的理解：自成一派的工具类RandomAccessFile
（1）这哥们帮派没混下去，直接继承的Object，它不属于IO体系，但是它归属与IO包。
         它既能读，又能写。它内部封装了数组，并且通过指针对数组元素进行操作！
（2）RandomAccessFile可以通过getFilePointer()方法获取指针位置，还可以通过seek()方法改变
         指针位置。skipBytes(int n)跳过多少个字节读取。不能往回跳。       
（3）其实完成读写的原理就是内部封装了输入字节流和输出字节流！
（4）通过构造函数，可以看出RandomAccessFile有个很大的局限性:只能操作文件！设备只有磁盘上的文件。
         内存，键盘，控制台等等设备一律不能操作。
         RandomAccessFile(String fileName,String mode);
         RandomAccessFile(File file,String mode);
         模式 r:只读 rw:读写
（5）方法包含了InputStream和OutputStream的所有方法，还添加了读写基本数据类型的方法。
         以及比较特殊的seek()方法，getFilepointer()方法等等。
         方法结束时候需要关闭流close()方法。
（6）可以在文件中的任何地方写入数据(seek()方法)，原位置的数据被覆盖。
         RandomAccessFile对象在创建的时候如果模式为rw：若关联文件不存在，会自动创建，若已存在，不会覆盖原有文件！
         RandomAccessFile对象在创建的时候如果模式为r： 若关联文件不存在，不会自动创建文件，会爆异常！
（7）可以利用与线程结合的方法，一个线程负责一段的方式，分段式的录入数据，相互不冲突。(下载文件的原理)
         数据要分段，希望数据有规律，便于操作。
然后我结合多线程的知识写了个小程序，就是在一个文件中拼诗歌，希望对你有帮助^^

1.   /**
   
2.          * RandomAccessFile与多线程结合完成诗歌的拼写
   
3.          * @author lt
   
4.          */
   
5.         import java.io.FileNotFoundException;
   
6.         import java.io.IOException;
   
7.         import java.io.RandomAccessFile;
   
8. 
   
9.         public class RandomAccessFileDemo2 {
   
10.                
    
11.                 public static void main(String[] args) {
    
12.                         RandomAccessFile raf = null;
    
13.                         try {
    
14.                                 raf = new RandomAccessFile("d:\\test.txt","rw");
    
15.                         } catch (FileNotFoundException e) {
    
16.                                 e.printStackTrace();
    
17.                         }
    
18.                         WriteThread1 wt1 = new RandomAccessFileDemo2().new WriteThread1(raf);
    
19.                         WriteThread2 wt2 = new RandomAccessFileDemo2().new WriteThread2(raf);
    
20.                         WriteThread3 wt3 = new RandomAccessFileDemo2().new WriteThread3(raf);
    
21.                         new Thread(wt1).start();
    
22.                         new Thread(wt2).start();
    
23.                         new Thread(wt3).start();
    
24.                 }
    
25.                
    
26.                 public class WriteThread1 implements Runnable{
    
27.                         RandomAccessFile raf = null;
    
28.                         public WriteThread1(RandomAccessFile raf){
    
29.                                 this.raf = raf;
    
30.                         }
    
31.                         @Override
    
32.                         public void run() {
    
33.                                 System.out.println("线程1已经启动！");
    
34.                                 //窗前明月光,疑是地上霜。一共22位
    
35.                                 try {
    
36.                                         String s = "床前明月光,疑是地上霜.";
    
37.                                         raf.seek(22*0);
    
38.                                         raf.write(s.getBytes());
    
39.                                 } catch (IOException e) {
    
40.                                         e.printStackTrace();
    
41.                                 }
    
42.                         }
    
43.                 }
    
44.                 public class WriteThread2 implements Runnable{
    
45.                         RandomAccessFile raf = null;
    
46.                         public WriteThread2(RandomAccessFile raf){
    
47.                                 this.raf = raf;
    
48.                         }
    
49.                         @Override
    
50.                         public void run() {
    
51.                                 System.out.println("线程2已经启动！");
    
52.                                 try {
    
53.                                         String s = "举头望明月,低头思故乡.";
    
54.                                         raf.seek(22*1);
    
55.                                         raf.write(s.getBytes());
    
56.                                 } catch (IOException e) {
    
57.                                         e.printStackTrace();
    
58.                                 }
    
59.                         }
    
60.                 }
    
61.                 public class WriteThread3 implements Runnable{
    
62.                         RandomAccessFile raf = null;
    
63.                         public WriteThread3(RandomAccessFile raf){
    
64.                                 this.raf = raf;
    
65.                         }
    
66.                         @Override
    
67.                         public void run() {
    
68.                                 System.out.println("线程3已经启动！");
    
69.                                 try {
    
70.                                         String s = "好诗好诗~";
    
71.                                         raf.seek(22*2);
    
72.                                         raf.write(s.getBytes());
    
73.                                 } catch (IOException e) {
    
74.                                         e.printStackTrace();
    
75.                                 }
    
76.                         }
    
77.                 }
    
78.         }

复制代码

楼主你好，如果问题已解决请将帖子状态修改为提问结束，如果未解决请继续提问，谢谢合作
如果不会修改请看解释帖：http://bbs.itheima.com/thread-89313-1-1.html