# CRC wert berechnen ergibt 0 ?



## Strippenzieher (29. Sep 2008)

Hallo,

habe diese methode geschrieben:


```
public void calculateCheckSum(String file)
	{
		FileInputStream fis = null;
		CheckedInputStream cis = null;
		CRC32 crc = null;
		
		try
		{
			fis = new FileInputStream(file);
			crc = new CRC32();
			cis = new CheckedInputStream(fis, crc);			
			long checksum = cis.getChecksum().getValue();			
			System.out.println("Checksum: " + checksum + " Filename: " + file);
		}
		catch (Exception e)
		{
			System.out.println("File  Not found ");
		}
	}
```

Beispiel der Konsolenausgabe:


```
Checksum: 0 Filename: C:\test\test.dat
```

Warum ergibt die checksumme immer 0 ?


----------



## Murray (29. Sep 2008)

Weil aus dem Stream noch nichts gelesen worden ist; die Prüfsumme wird nur über die gelesenen Bytes gebildet.


----------



## Strippenzieher (29. Sep 2008)

Murray hat gesagt.:
			
		

> Weil aus dem Stream noch nichts gelesen worden ist; die Prüfsumme wird nur über die gelesenen Bytes gebildet.



für die es interessiert, damit funktionierte eine CRC-summenbildung für  1 Datei:


```
public void calculateCheckSum(String filename)
	{
		CheckedInputStream check;
		long checksum = 0;
		try
		{
			FileInputStream file = new FileInputStream(filename);
			check = new CheckedInputStream(file, new CRC32());
			BufferedInputStream in = new BufferedInputStream(check);			
			
				while (in.read() != -1)
				{
					 checksum = check.getChecksum().getValue();
				}
		}
		catch (FileNotFoundException e)
		{
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		catch (IOException e)
		{
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		System.out.println("Checksum is " + checksum);
	}
```


----------



## Verjigorm (29. Sep 2008)

Ich würde mal behaupten, die Ausgabe liefert nur die Checksumme für das letzte eingelesene Byte.

weil read() byteweise liest

ausserdem hat CheckedInputStream ja auch ne Methode read()

edit:
http://www.galileocomputing.de/open...13_011.htm#mj2a3e65b2e945b3afdcec65217ee368be


----------



## Strippenzieher (29. Sep 2008)

Verjigorm hat gesagt.:
			
		

> Ich würde mal behaupten, die Ausgabe liefert nur die Checksumme für das letzte eingelesene Byte.
> 
> weil read() byteweise liest
> 
> ...



was ich nicht ganz verstehe ist, ich habe ja eine Datei die z.B. 10000 Byte oder auch 10,50 oder 500 mb sein kann. Einfach mal angenommen... Ich wille EINE checksumme für EINE Datei und nicht eine Checksumme für EIN BYTE und das ganze wird dann 10000 mal durchlaufen und berechnet. Das verstehe ich net...


----------



## Strippenzieher (29. Sep 2008)

hab nochmal meinen code mit der javainsel verglichen:

mein code macht genau dasselbe... und ob ich crc.getValue() in der while oder außerhalb mache ist schnuppe, ich komme auf die gleichen werte bei gleicher datei?


```
InputStream in = CRC32Demo.class.getResourceAsStream( "/lyrics.txt" ); 
try 
{ 
  CRC32 crc = new CRC32(); 
  InputStream cis = new CheckedInputStream( in, crc ); 
 
  while ( cis.read() != –1 ) { /* Bis Ende lesen. */ } 
 
  System.out.printf( "%X", crc.getValue() );          // F9A39CFC 
} 
catch ( IOException e ) { 
  e.printStackTrace(); 
} 
finally { 
  try { in.close(); } catch ( Exception e ) { } 
}
```


----------



## Murray (29. Sep 2008)

Ich bin mir nicht sicher, ob ich Dein Frage richtig verstehe, aber tatsächlich dürfte es - zumindest was das Ergebnis angeht; die Performance steht auf einem anderen Blatt - egal sein, ob Du in der Schleife nach jedem gelesenen Byte die Prüfsumme neu ermittelst, oder ob Du das nur einmal am Ende machst; das Ergebnis im letzen Schleifendurchlauf ist identisch mit dem nach der Schleife.


----------



## Strippenzieher (30. Sep 2008)

Murray hat gesagt.:
			
		

> Ich bin mir nicht sicher, ob ich Dein Frage richtig verstehe



code ist aus google: ich frage mich z.B. warum wird hier für das byte array buf 1024 bytes reserviert? warum nicht 100 oder 128 wie man es sonst im google findet in den unzähligen Beispielen. Sollte man nicht die Länge der Datei feststellen bzw. die ganze Datei einlesen in einer schleife z.B. und danach wie untenstehend den CRC EINMAL auslesen?




```
public static long computeChecksumForFile(File file) throws IOException
{
byte[] buf = new byte[1024];
int bytesRead;
FileInputStream fis = new FileInputStream(file);
CRC32 crc = new CRC32();

while (-1 != (bytesRead = fis.read(buf))) {
crc.update(buf, 0, bytesRead);
}

fis.close();
return crc.getValue();
}
```


----------



## Strippenzieher (2. Okt 2008)

weiß denn keiner wie ich eine prüfsume für eine Datei berechne und nicht einen Byte-anteil der datei?


----------



## tuxedo (2. Okt 2008)

Du kannst den CRC AFAIK nicht "auf einmal auslesen". Zum errechnen des CRCs musst du jedes byte angesehen haben. Ob nun byte für byte, in 128byte Blöcken oder in 1024 byte Blöcken ist dabei egal (Der Hintergrund für das Blockweise lesen liegt im SPeicher: Man möchte z.B. keine 5GB Datei auf einmal in den Speicher lesen und an crc.update() füttern. Besser und Speicherschonender geht das in kleinen Blöcken zu 1024 byte, oder 128 byte oder was auch immer für "ausreichend" befunden wird). Letztendlich muss eben der ganze Inhalt der Datei über "crc.update()" geschleift werden, damit man am Ende sagen kann: "Gib mit jetzt bitte die Prüfsumme (also crc.getValue()).

- Alex

P.S. Dein letztes Codesample sollte die Prüfsumme korrekt wiedergeben können.


----------

