[Java] Jar-Datei splitten

[.Resistance]

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:

 Spoiler

public void combineFiles ( String file1, String file2, String output, String split )
{
        
    try
    {
        RandomAccessFile data1 = new RandomAccessFile ( file1, "r" ) ;
        RandomAccessFile data2 = new RandomAccessFile ( file2, "r" ) ;
        
        byte [ ] byte1 = new byte [ ( int ) data1.length ( ) ] ;
        byte [ ] byte2 = new byte [ ( int ) data2.length ( ) ] ;
        byte [ ] splitBytes = new byte [ split . length ( ) ] ;
        byte [ ] both = new byte [ split . length ( ) + byte1 . length + byte2 . length ] ;
        
        splitBytes = split . getBytes ( ) ;
        
        data1.read ( byte1 ) ;
        data2.read ( byte2 ) ;
        data1.close ( ) ;
        data2.close ( ) ;
        
        both = concat ( byte1, splitBytes, byte2 ) ;
        
        RandomAccessFile newFile = new RandomAccessFile ( output, "rw" ) ;
        newFile . write ( both ) ;
        newFile . close ( ) ;
    }
    catch ( Exception e ) { }
    
}
    
public byte [ ] concat ( byte [ ] A, byte [ ] B, byte [ ] C ) 
{
    
    byte [ ] D = new byte [ A . length + B . length + C . length ] ;
    System . arraycopy ( A, 0, D, 0, A . length ) ;
    System . arraycopy ( B, 0, D, A . length, B . length ) ;
    System . arraycopy ( C, 0, D, A . length + B . length, C . length ) ;
    return D ;
    
}

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:

 Spoiler

public String [ ] getOldFile ( String file, String splitStr )
{
    
    try
    {
        StringBuffer fileData = new StringBuffer ( 1000 ) ;
        BufferedReader reader = new BufferedReader ( new FileReader ( file ) ) ;
        char [ ] buf = new char [ 1024 ] ;
        int numRead = 0 ;
        while ( ( numRead = reader . read ( buf ) ) != -1 )
        {
            String readData = String . valueOf ( buf, 0, numRead ) ;
            fileData . append ( readData ) ;
            buf = new char [ 1024 ] ;
        }
        reader.close();
        
        String data = fileData . toString ( ) ;
        String [ ] splited ;
        splited = data . split ( splitStr ) ;
        return splited ;
        
    }
    catch ( Exception e ) { return null ; }
    
}

Und die beiden Felder des String Arrays wieder in 2 neue Dateien schreiben:

 Spoiler

public void writeFile ( String fi, String data )
{
    
    try
    {
        File file = new File ( fi ) ;
        FileWriter fw = new FileWriter ( file ) ;
        fw . write ( data ) ;
        fw . flush ( ) ;
        fw . close ( ) ;
    }
    catch ( Exception e ) { }
    
}

Die beiden neuen Dateien sind aber größer als die beiden ursprünglichen Dateien und lassen sich nicht mehr ausführen:

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?

[DaKku0815]

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

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;
		}
	}

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) {
		}
	}

[.Resistance]

Nice. Funktioniert
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?

[DaKku0815]

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".

[.Resistance]

Ich glaub ich versteh was du meinst ^^
Das versuche ich demnächst mal umzusetzen.
Danke für deine Hilfe