Problem mit Bitsets

[HansWM]

Es sollen zwei Dateien verglichen und die Anzahl der Einzelbitfehler, Doppelbitfehler usw. gezählt werden. Leider ist das Ergebnis abhängig von der Grösse der BLOCKSIZE und offensichtlich falsch. Aber wo liegt der Fehler ?

public class BiterrorMain
{
	public static void main (String[] args) throws Exception
	{
		Biterror Compare = new Biterror ();
		Compare.compareFiles ();
	}
}

import java.io.FileInputStream;
import java.io.IOException;
import java.io.FileNotFoundException;
import java.util.BitSet;
import java.lang.String;

public class Biterror
{
	private final static int MASK = 128;
	private final static int EOF = -1;
        // Für BLOCKSIZE = 32 ist das Ergebnis in Ordnung
        // Testdatei wurde mit einem Hexeditor erstellt
        // Blockgrösse in Byte
	private final static int BLOCKSIZE = 16;
	private final static int ORDER = 5;
        // Die Dateien liegen nicht bei
        // Datei mit 1024 Null Bits
	private final static String File1 = "TxFileNull1024Bit.txt";
        // Datei mit Einzel- und Doppelbitfehlern
	private final static String File2 = "RxFileNull1024Bit.txt";
	
	int[] BlockVector = new int[ORDER+1];
	int[] SumVector = new int[ORDER+1];;
    

	private BitSet readBlock (FileInputStream File, BitSet BitSet) throws Exception
	{
		int b;
		int index = 0;
		
		try
		{
			// Lese ein Byte als int
			while ((b=File.read()) != EOF && (index < (BLOCKSIZE*8)))
			{
				// Konvertierung von int in BitSet
				for (int i = 0; i < 8; ++i)
				{
					// Prüfe ob das höchstwertige Bit gesetzt ist
					if ((b&MASK) == MASK) BitSet.set (index);
									 else BitSet.clear (index);
					// Inkrementiere den Bitindex	
					index++;
					// Bitshift um 1 Bit nach links
					b <<= 1;
				}
			
			}
		} // try
		catch (IOException e)
		{
			System.out.println (e);
		}
		return BitSet;
	}
	
	private int[] countBiterrors (BitSet NewBitSet)
	{
		int index = 0;
		int length;
		
		while (index < NewBitSet.length())
		{
			// Überlese führende Null-Bits
			while (NewBitSet.get(index) == false) ++index;
			length = 0;
				// Lese Einser-Bits und bestimme die Länge
				while (NewBitSet.get(index) == true)
				{
					++index;
					++length;
				}
				// Verwende die Länge als Index
				// Einzelbitfehler in BlockVektor[0] usw.
				if (length <= ORDER)
			  		++BlockVector[length-1];
				// Die "restlichen" Bitfehler werden addiert	
				else 
			  		++BlockVector[ORDER];
	
			System.out.println(); 	
		}
		return BlockVector;
	}
	
	private void printBitSet (BitSet b)
	{
		for (int i = 0; i < b.length(); ++i)
		{
			if (b.get (i))
				System.out.print ("1");
			else
				System.out.print ("0");
			if ((i+1)%8 == 0) System.out.print("'");
		}
		System.out.println();
	}
	
	private void printBiterrors (int[] Biterrors)
	{
		for (int i = 0; i < Biterrors.length; ++i)
		{
			System.out.print (""+(i+1)+"-Bitfehler = ");
			System.out.println (Biterrors[i]);
		}
	}
		
	public void compareFiles () throws Exception
	{
		int BlockCounter = 0;
		FileInputStream Original;
		FileInputStream Copy;
		BitSet OriginalBitSet = new BitSet (BLOCKSIZE*8);
		BitSet CopyBitSet = new BitSet (BLOCKSIZE*8);
		BitSet NewBitSet = new BitSet(BLOCKSIZE*8);
		int[] BlockVector = new int[ORDER+1];
		
		try
		{
			Original = new FileInputStream (File1);
			Copy = new FileInputStream (File2);
                        // Lese die ersten 8 Blöcke
                        // Eigentlich lesen bis Dateiende
			while (BlockCounter < 8)
			{
				System.out.println();
				System.out.print ("Block ");
				System.out.println (BlockCounter);
				OriginalBitSet = readBlock (Original,OriginalBitSet);	
				CopyBitSet = readBlock (Copy,CopyBitSet);
				System.out.println ("The First Bitset");
			    printBitSet (OriginalBitSet);
			    System.out.println ("The Second Bitset");
			    printBitSet (CopyBitSet);
				NewBitSet = (BitSet) OriginalBitSet.clone ();
				NewBitSet.xor (CopyBitSet);
				System.out.println ("The XORed Bitsets");
				printBitSet (NewBitSet);
				// Falls das "Ergebnis" Einsen enthält
				if (!NewBitSet.isEmpty())
				{	
					BlockVector = countBiterrors (NewBitSet);
					printBiterrors (BlockVector);
				}
				else
					System.out.println ("Blocks are equal");
				BlockCounter++;
				for (int i = 0; i <= ORDER; ++i)
				{
			   		SumVector[i] += BlockVector[i];
			   		// Reset für den nächsten Block
			   		BlockVector[i] = 0;
				}   
			} // while
			System.out.println();
			printBiterrors (SumVector);
		} // try
		catch (FileNotFoundException e)
		{
			System.out.println (e);
		}
	}
	

}