Datei effizient kopieren

[Noar]

Hallo,

ich habe eine Frage zu einer Studienaufgabe:

Die Aufgabe ist, eine Datei effektiv zu kopieren.
Randbedingungen: Datei kann Byte für Byte kopiert werden. Dateiname/Pfad soll vom Nutzer auf der Konsole eingegeben werden können.
Der Name der Zieldatei ist mit der Quelldatei identisch, nur um ein .bak ergänzt.
Nutzer soll über Erfolg/Misserfolg unterrichtet werde.

Ich habe das mal umgesetzt und es funktioniert. Könnt ihr mal drüberschauen, und mir sagen, ob es da noch was zu verbessern gibt (eleganz, effizienz etc.) Bitte auch Tips geben, wenn ich Konventionen etc. verletze.

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;

public class DateiKopierer {

	/**
	 * This class copies a file byte by byte.
	 * The original filename will be reused (with a new suffix "bak").
	 * 
	 * @param args
	 * @author Thomas Wenzel
	 */
	public static void main(String[] args) {
		
		//Read filename from console
		BufferedReader buffReader=new BufferedReader(new InputStreamReader(System.in));
		String strInput;
		try {		
			System.out.print("Source file: ");
        	strInput = buffReader.readLine();
        	
        	//Copy file
        	String strDestFilename = strInput+".bak";
            File fileSrc = new File(strInput);
    		File fileDes = new File(strDestFilename);
    		System.out.println("Copy file '"+strInput+"' to '"+strDestFilename+"'");
            try {
            	byte[] streamBuffer  = new byte[1024]; // Buffer für gelesene Daten
        		InputStream in = new FileInputStream(fileSrc);
        		OutputStream out = new FileOutputStream(fileDes);
        		
        		for (int n; (n = in.read(streamBuffer)) != -1; out.write(streamBuffer, 0 , n));
        		in.close();
        		out.flush(); 
        		out.close();
        		System.out.println("Copy successfully finished.");
        			
    		} catch (IOException e) {
    			System.out.println("Error while copy file '"+strInput+"'");
    			e.printStackTrace();
    		}
    		
		}
        catch(IOException e) {
            System.out.println("Input data error!");
        } 
		
	}
}

Vielen Dank für eure Hilfe
Noar

 

[Guest]

Hallo,

ich habe eine Frage zu einer Studienaufgabe:

Die Aufgabe ist, eine Datei effektiv zu kopieren.
Randbedingungen: Datei kann Byte für Byte kopiert werden. Dateiname/Pfad soll vom Nutzer auf der Konsole eingegeben werden können.
Der Name der Zieldatei ist mit der Quelldatei identisch, nur um ein .bak ergänzt.
Nutzer soll über Erfolg/Misserfolg unterrichtet werde.

Ich habe das mal umgesetzt und es funktioniert. Könnt ihr mal drüberschauen, und mir sagen, ob es da noch was zu verbessern gibt (eleganz, effizienz etc.) Bitte auch Tips geben, wenn ich Konventionen etc. verletze.

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;

public class DateiKopierer {

	/**
	 * This class copies a file byte by byte.
	 * The original filename will be reused (with a new suffix "bak").
	 * 
	 * @param args
	 * @author Thomas Wenzel
	 */
	public static void main(String[] args) {
		
		//Read filename from console
		BufferedReader buffReader=new BufferedReader(new InputStreamReader(System.in));
		String strInput;
		try {		
			System.out.print("Source file: ");
        	strInput = buffReader.readLine();
        	
        	//Copy file
        	String strDestFilename = strInput+".bak";
            File fileSrc = new File(strInput);
    		File fileDes = new File(strDestFilename);
    		System.out.println("Copy file '"+strInput+"' to '"+strDestFilename+"'");
            try {
            	byte[] streamBuffer  = new byte[1024]; // Buffer für gelesene Daten
        		InputStream in = new FileInputStream(fileSrc);
        		OutputStream out = new FileOutputStream(fileDes);
        		
        		for (int n; (n = in.read(streamBuffer)) != -1; out.write(streamBuffer, 0 , n));
        		in.close();
        		out.flush(); 
        		out.close();
        		System.out.println("Copy successfully finished.");
        			
    		} catch (IOException e) {
    			System.out.println("Error while copy file '"+strInput+"'");
    			e.printStackTrace();
    		}
    		
		}
        catch(IOException e) {
            System.out.println("Input data error!");
        } 
		
	}
}

Vielen Dank für eure Hilfe
Noar

Also ich finde das Kopieren sieht doch schon ganz gut aus. Auch die Codeformatierung ist gut so (sind nur n paar Verschieber drin).

Was die Effizienz des Kopierens angeht ists immer schwer zu sagen. Wenn ich z. B. keine Verlaufsanzeige oder sonstiges brauche benutze ich auch oft mal den FileChannel zum Kopieren. Ich weiß einige hier im Forum sind nicht so begeistert vom FileChannel, aber ich hatte bis jetzt keine Probleme damit.

Ein Kopieren mit dem FileChannel könnte dann so aussehen:

   private void copy(final File from, final File to) {

      try {
         final FileChannel in = new FileInputStream(from).getChannel();
         final FileChannel out = new FileOutputStream(to).getChannel();

         out.transferFrom(in, 0, in.size());

         in.close();
         out.close();

         System.out.println(from.getPath() + " - erfolgreich kopiert");
      } catch (FileNotFoundException fnfe) {
         System.out.println("Datei nicht gefunden: " + from.getPath());
         fnfe.printStackTrace();
      } catch (IOException ioe) {
         System.out.println("IOException: " + from.getPath());
         ioe.printStackTrace();
      }
   }

 

[norman]

Hallo Noar,

for (int n; (n = in.read(streamBuffer)) != -1; out.write(streamBuffer, 0 , n));

finde ich ziemlich umständlich zu lesen..aber finde es immer krass, was man mit der for-schleife so alles machen kann (oft werden ja auch anweisungen weggelassen ( for (;bla;blubb)..)

ansonsten kann es evtl sinnvoll sein den dateinamen/ pfad gleich als parameter beim starten zu übergeben. (strInput = args[0])

 

[Bleiglanz]

ich würde vielleicht noch die Blockgrösse etwas grösser machen, 1024 ist wahrscheinlich nicht so optimal (viele Betriebssysteme arbeiten mit grösseren Blöcken)

und

for (int n; (n = in.read(streamBuffer)) != -1; out.write(streamBuffer, 0 , n));

ist zwar superkurz und elegant, aber nicht so toll lesbar
lieber ein paar zeilen mehr schreiben, in Punkto Geschwindigkeit macht das keinen Unterschied

und: mach lieber eine Funktion draus, so a la copy(File src, File dest)

 

[SamHotte]

Vielleicht kann man die OS-Blockgröße ja sogar auslesen, das dürfte meistens die schnellsten File-IO-Operationen erlauben, oder?

 

[Bleiglanz]

Vielleicht kann man die OS-Blockgröße ja sogar auslesen, das dürfte meistens die schnellsten File-IO-Operationen erlauben, oder?

geht wahrscheinlich mit Java nicht???

 

[SamHotte]

Keine Ahnung, aber sonstige systemspezifische Dinge kann Java ja auch, wie bspw. in java.awt.Toolkit die Bildschirmauflösung holen. Vielleicht gibt es ja auch Wrapperklassen fürs Dateisystem ...

 

[Noar]

Hallo,

vielen Dank für eure Antworten.

Ich habe die bemängelte for-Schleife mal entschärft. Ist die Variante mit while-Schleife besser?
Was spricht eigentlich gegen das for-Schleifenkonstukt?

Ich habe auch die Kopieraktion in eine Methode ausgelagert. Besser?

Was die Blockgröße angeht, da habt ihr sicher recht. Wäre natürlich sehr elegant, die an die jeweilige Umgebung anzupassen. Allerdings glaube ich, ist das für meinen momentanen Kenntnisstand noch etwas oversized.

Welchen Wert kann man denn für moderne Systeme nehmen?

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;

public class DateiKopierer {

	/**
	 * This class copies a file byte by byte.
	 * The original filename will be reused (with a new suffix "bak").
	 **/
	public static void main(String[] args) {

		//Read filename from console
		BufferedReader buffReader = new BufferedReader(new InputStreamReader(
				System.in));
		String strInput;
		try {
			System.out.print("Source file: ");
			strInput = buffReader.readLine();

			copyFile(strInput); //rufe Methode copyFile auf

		} catch (IOException e) {
			System.out.println("Input data error!");
		}

	}

	public static void copyFile(String strInput) {
		String strDestFilename = strInput + ".bak";
		File fileSrc = new File(strInput);
		File fileDes = new File(strDestFilename);
		System.out.println("Copy file '" + strInput + "' to '"
				+ strDestFilename + "'");
		try {
			byte[] streamBuffer = new byte[1024]; // Buffer für gelesene Daten
			InputStream in = new FileInputStream(fileSrc);
			OutputStream out = new FileOutputStream(fileDes);

			int n;
			while ((n = in.read(streamBuffer)) > 0) {
				out.write(streamBuffer, 0, n);
			}

			in.close();
			out.flush();
			out.close();
			System.out.println("Copy successfully finished.");

		} catch (IOException e) {
			System.out.println("Error while copy file '" + strInput
					+ "'. File not found.");
			//e.printStackTrace();
		}
	}
}

Gruß und Dank
Noar

 

[Leroy42]

Welchen Wert kann man denn für moderne Systeme nehmen?

16 KB sollten ausreichend sein aber 64 KB können auch nicht schaden.

Mehr bringt auch nicht mehr

 

[norman]

ich würde es der lesbarkeit wegen sogar so machen:

       int n=1;
        while (n > 0) {
            n = in.read(streamBuffer)
            out.write(streamBuffer, 0, n);
         }

 

[Leroy42]

Bevorzuge ich auch.

Dann müssen die Streams aber auf jeden Fall in ein BufferdInput/OutputStream gewrapped werden

 

[Bleiglanz]

wegen der for-schleife: es geht uns hier nur um die Lesbarkeit des Programmsquelltextes, für die Geschwindigkeit und alles andere ist das ziemlich wurscht

aber

bitte aufpassen, oben wars richtig:

die bedingung != -1 ist was anders als grösser 0

ist zwar jetzt sehr exotisch (bei Festplatten) aber es kann schon mal vorkommen das keine Bytes gelesen werden können obwohl man noch gar nicht fertig ist

 

[norman]

nochmal zu der blockgröße:
in InputStream bin ich gerade auf

private static final int SKIP_BUFFER_SIZE = 2048;

gestoßen. evtl ist das also ein ganz guter wert..

 

[SamHotte]

Vielleicht wird die Blockgröße ja auch von der JRE gesetzt, abhängig vom Filesystem ???:L

 

[norman]

Vielleicht wird die Blockgröße ja auch von der JRE gesetzt, abhängig vom Filesystem ???:L

dann würde es doch aber nicht so eine statische konstante geben, wie eben gepostet? ???:L

 

[SamHotte]

Und wofür wird die benutzt? Vielleicht nur dann, wenn man im jeweiligen System die "echte" nicht herausfinden kann? AFAIK sind Dateizugriffe mit anderer Größe als der im FS fest verdrahteten immer langsamer, als wenn man genau die dort benutzte nimmt. Und bei OSen != Windows kann man die Blockgröße selbst festlegen, also müsste die JRE diese herausfinden oder automatisch benutzen, oder nicht?

 

[Noar]

Hallo,
ich danke euch für die Antworten.
Ihr habt mir sehr geholfen.

Gruß und Dank
Noar

 

[norman]

keine ahnung wofür die benutzt wird, aber kannst ja nachschauen.. :wink:
vermutlich hast du aber recht. ich wusste nur gar nciht, dass man in einigen OS die blockgröße selbst festlegen kann.

 

[SamHotte]

Zumindest unter Linux ging das mal. Die Blockgröße bestimmt die durchschnittliche Platzverschwendung auf deinem Datenträger, denn im Mittel bleibt pro Datei ein halber Block leer.