关于一个用JAVA进行文件分割的问题

Question

可能是inputstream的read()方法读取的时候不能定位到正确的位置。
n=bufferedinputstream.read(buff,??,buff.length))!=-1
其实，这种情况用RandomAccessFile类很容易解决。
下面是我以前的一个测试程序：没有判断文件大小等问题
import java.io.*;public class  SFile{
public static void main(String[] args){
String fileName="FontTest.java";
int num=4;
int size=128;
try{
RandomAccessFile raf=new RandomAccessFile(fileName,"r");
byte[] buff=new byte[size];
for(int i=0;i<num;i++){
FileOutputStream fos=new FileOutputStream(fileName+i);
raf.seek(size*i);
raf.readFully(buff);
fos.write(buff);
fos.flush();
fos.close();
}
raf.close();
}
catch(IOException e){e.printStackTrace();}
}
}

Answer 1

to  yoyoxo(czm) :
您的意思是read(buff,disksize*i,……)中第二个参数不是offset?但是我查了JDK的API帮助，应该就是这样。看看哪位高手能帮帮我，谢谢！

Answer 2

可能出错了，在catch里输出看看

Answer 3

程序报出的是java.lang.IndexOutOfBoundsException异常
但是我怎么也找不到数组越界的地方，还要各位大侠帮帮忙，谢谢！

Answer 4

拜托，用e.printStackTrace()
把详细的错误信息贴上来。

Answer 5

用 StreamTokenizer 来做。
看看这个Think in java 中的例子吧。
---------------------------------------
StreamTokenizer
尽管StreamTokenizer并不是从InputStream或OutputStream衍生的，但它只随同InputStream工作，所以十分恰当地包括在库的IO部分中。
StreamTokenizer类用于将任何InputStream分割为一系列“记号”（Token）。这些记号实际是一些断续的文本块，中间用我们选择的任何东西分隔。例如，我们的记号可以是单词，中间用空白（空格）以及标点符号分隔。
下面是一个简单的程序，用于计算各个单词在文本文件中重复出现的次数：//: SortedWordCount.java
// Counts words in a file, outputs
// results in sorted form.
import java.io.*;
import java.util.*;
import c08.*; // Contains StrSortVectorclass Counter {
  private int i = 1;
  int read() { return i; }
  void increment() { i++; }
}public class SortedWordCount {
  private FileInputStream file;
  private StreamTokenizer st;
  private Hashtable counts = new Hashtable();
  SortedWordCount(String filename)
    throws FileNotFoundException {
    try {
      file = new FileInputStream(filename);
      st = new StreamTokenizer(file);
      st.ordinaryChar('.');
      st.ordinaryChar('-');
    } catch(FileNotFoundException e) {
      System.out.println(
        "Could not open " + filename);
      throw e;
    }
  }
  void cleanup() {
    try {
      file.close();
    } catch(IOException e) {
      System.out.println(
        "file.close() unsuccessful");
    }
  }
  void countWords() {
    try {
      while(st.nextToken() !=
        StreamTokenizer.TT_EOF) {
        String s;
        switch(st.ttype) {
          case StreamTokenizer.TT_EOL:
            s = new String("EOL");
            break;
          case StreamTokenizer.TT_NUMBER:
            s = Double.toString(st.nval);
            break;
          case StreamTokenizer.TT_WORD:
            s = st.sval; // Already a String
            break;
          default: // single character in ttype
            s = String.valueOf((char)st.ttype);
        }
        if(counts.containsKey(s))
          ((Counter)counts.get(s)).increment();
        else
          counts.put(s, new Counter());
      }
    } catch(IOException e) {
      System.out.println(
        "st.nextToken() unsuccessful");
    }
  }
  Enumeration values() {
    return counts.elements();
  }
  Enumeration keys() { return counts.keys(); }
  Counter getCounter(String s) {
    return (Counter)counts.get(s);
  }
  Enumeration sortedKeys() {
    Enumeration e = counts.keys();
    StrSortVector sv = new StrSortVector();
    while(e.hasMoreElements())
      sv.addElement((String)e.nextElement());
    // This call forces a sort:
    return sv.elements();
  }
  public static void main(String[] args) {
    try {
      SortedWordCount wc =
        new SortedWordCount(args[0]);
      wc.countWords();
      Enumeration keys = wc.sortedKeys();
      while(keys.hasMoreElements()) {
        String key = (String)keys.nextElement();
        System.out.println(key + ": "
                 + wc.getCounter(key).read());
      }
      wc.cleanup();
    } catch(Exception e) {
      e.printStackTrace();
    }
  }
} ///:~最好将结果按排序格式输出，但由于Java 1.0和Java 1.1都没有提供任何排序方法，所以必须由自己动手。这个目标可用一个StrSortVector方便地达成（创建于第8章，属于那一章创建的软件包的一部分。记住本书所有子目录的起始目录都必须位于类路径中，否则程序将不能正确地编译）。
为打开文件，使用了一个FileInputStream。而且为了将文件转换成单词，从FileInputStream中创建了一个StreamTokenizer。在StreamTokenizer中，存在一个默认的分隔符列表，我们可用一系列方法加入更多的分隔符。在这里，我们用ordinaryChar()指出“该字符没有特别重要的意义”，所以解析器不会把它当作自己创建的任何单词的一部分。例如，st.ordinaryChar('.')表示小数点不会成为解析出来的单词的一部分。在与Java配套提供的联机文档中，可以找到更多的相关信息。
在countWords()中，每次从数据流中取出一个记号，而ttype信息的作用是判断对每个记号采取什么操作——因为记号可能代表一个行尾、一个数字、一个字串或者一个字符。
找到一个记号后，会查询Hashtable counts，核实其中是否已经以“键”（Key）的形式包含了一个记号。若答案是肯定的，对应的Counter（计数器）对象就会增值，指出已找到该单词的另一个实例。若答案为否，则新建一个Counter——因为Counter构建器会将它的值初始化为1，正是我们计算单词数量时的要求。
SortedWordCount并不属于Hashtable（散列表）的一种类型，所以它不会继承。它执行的一种特定类型的操作，所以尽管keys()和values()方法都必须重新揭示出来，但仍不表示应使用那个继承，因为大量Hashtable方法在这里都是不适当的。除此以外，对于另一些方法来说（比如getCounter()——用于获得一个特定字串的计数器；又如sortedKeys()——用于产生一个枚举），它们最终都改变了SortedWordCount接口的形式。

Answer 6

在catch(Exception e)后加入printStackTrace后，程序输出：
java.lang.IndexOutOfBoundsException
at java.io.BufferedInputStream.read(BufferedInputStream.java:275)
at testui.MainForm.StartSplit_actionPerformed(MainForm.java:199)
at testui.MainForm$4.actionPerformed(MainForm.java:94)
at java.awt.Button.processActionEvent(Button.java:329)
at java.awt.Button.processEvent(Button.java:302)
at java.awt.Component.dispatchEventImpl(Component.java:2595)
at java.awt.Component.dispatchEvent(Component.java:2499)
at java.awt.EventQueue.dispatchEvent(EventQueue.java:319)
at java.awt.EventDispatchThread.pumpOneEvent(EventDispatchThread.java:103)
at java.awt.EventDispatchThread.pumpEvents(EventDispatchThread.java:93)
at java.awt.EventDispatchThread.run(EventDispatchThread.java:84)不知道怎么去分析这个错误输出？

Answer 7

byte[] buff=new byte[disksize];
  与(n=bufferedinputstream.read(buff,disksize*i,buff.length))这儿错了
你的buff只有disksize,而offset却disksize*i，循环一次就出错根本就不需要disksize*i,你用0就ok了，文件偏移是文件输入流自动记录的。

Answer 8

to  hello_10000(闲时看花) :
该函数的原型是
read(byte[] b, int off, int len) 
          Reads bytes from this byte-input stream into the specified byte array, starting at the given offset.
不会溢出的，每次从off处读取len个byte到b数组中，我每次读的是buff.length也就是disksize个字节到buff数组中，buff数组也是disksize大小的。另外“根本就不需要disksize*i,你用0就ok了”？不会吧，不然这里off拿来什么用？还望指教！可能我哪里弄错了。

Answer 9

"starting at the given offset."
offset应该是在stream中的偏移量，而不是在数组中的偏移量。

Answer 10

off确实是byte数组的位置
你另外写代码看一下

Answer 11

当被读文件所剩的字节数小于 disksize的时候，就会抛出异常，所剩下的文件就要在catch块中来处理。
你可以在进入循环时来检测已经读了多少个字节，再和文件比较，如果差小于disksize时就跳出循环，来处理最后剩下的字节数。