[Java] Jar-Datei splitten

07/29/2012 14:04 .Resistance#1
Hi
ich spiele zZ ein bisschen mit Java rum und möchte eine Jar-Datei splitten.
Ich habe davor 2 mal das selbe hallo_welt Programm durch einen Splitstring getrennt aneinander gehängt. Dazu der Code:
Das hat super funktioniert. Ich habe dannach eine Datei, die ich immer noch ausführen kann (das erste hallo_welt Programm wird ausgeführt) und die Dateigröße stimmt auch (datei1+datei2+splitString)

Jetzt will ich mithilfe von split() die beiden ursprünglichen Dateien wieder herstellen:
Und die beiden Felder des String Arrays wieder in 2 neue Dateien schreiben:

Die beiden neuen Dateien sind aber größer als die beiden ursprünglichen Dateien und lassen sich nicht mehr ausführen:
Code:
invalid file (bad magic number): Exec format error
Dateigrößen:
hallo_welt1.jar: 17362 byte
hallo_welt2.jar: 17362 byte
splitString: 1234567890 entspricht 10 byte
hallo_welt12.jar (beide zusammen): 34734 byte <- lässt sich problemlos ausführen
Nach dem Splitten:
file0.jar: 29473 byte
file1.jar: 29473 byte

er erkennt also den SplitString und splittet auch in 2 gleich große Dateien. Diese sind aber nicht mehr die ursprünglichen Dateien.
Woran könnte das liegen?
07/29/2012 16:26 DaKku0815#2
Hi,
ich hab da mal ein bischen was geändert. Zum einen wird die Datei jetzt mit dem FileInputStream eingelesen und die zwei neuen Dateien über den FileOutputStream geschreiben. Der FileWriter ist für raw-bytes nix^^.
Dann musst du aber noch darauf achten, das der splitStr nicht irgendwie schon in den beiden Dateien vorkommt. Allgemein ist die Technik ned so ideal und muss noch optimiert werden ;P

Code:
public static byte[][] getOldFile(String file, String splitStr) {		
		try {
			FileInputStream fis = new FileInputStream(file);
			byte[] dataByte = new byte[(int) (new File(file)).length()];
			fis.read(dataByte);
			fis.close();
			
			byte[] splitByte = splitStr.getBytes();
			
			int splitPos = -1;
			
			for(int i = 0; i < dataByte.length - splitByte.length;i++){
				for (int j = 0; j < splitByte.length; j++) {
					if (dataByte[i+j] != splitByte[j]) {
						break;
					}
					if (j == splitByte.length-1) {
						splitPos = i;					
					}
				}
				if(splitPos != -1){
					break;
				}
			}
			byte[] rByte1 = new byte[splitPos];
			byte[] rByte2 = new byte[dataByte.length - splitPos - splitByte.length];
			System.arraycopy(dataByte, 0, rByte1, 0, rByte1.length);
			System.arraycopy(dataByte, splitPos + splitByte.length, rByte2, 0, rByte2.length);
			
			byte[][] returnByte = {rByte1,rByte2};
			
			return returnByte;
		} catch (Exception e) {
			return null;
		}
	}
Code:
public static void writeFile(String fi, byte[] data) {
		try {
	        FileOutputStream output = new FileOutputStream(fi);
	        output.write(data, 0, data.length);
	        output.flush();
	        output.close();			
		} catch (Exception e) {
		}
	}
07/29/2012 16:47 .Resistance#3
Nice. Funktioniert :D
Ich denk mal das das Problem die umwandlung von Byte in String und wieder zurück war?
Und wie meinst du, dass man die Technik optimieren könnte?
07/29/2012 17:52 DaKku0815#4
Also ein Ansatz wär z.B. ein "Pseudo-Filesystem". Die Dateien direkt hintereinander setzen und dann noch n bytes hinten anzuhängen die dazu dienen die Anzahl der bytes einer der Dateien abzuspeichern. Bei 10 bytes (80 bit) hat man somit die Möglichkeit 2^80 bytes (1 Yottabyte ? (villeicht etwas überdimensioniert ;P)) für eine Datei zu "markieren".
07/29/2012 18:30 .Resistance#5
Ich glaub ich versteh was du meinst ^^
Das versuche ich demnächst mal umzusetzen.
Danke für deine Hilfe