How to Re-Assembling a splitted file correctly

[Yohan Weerasinghe]

Please have a look at the following code

  package normal;
    
    import java.io.*;
    import java.util.*;
    
    public class ReGenerateFiles
    {
        private File inputFolder, outputFolder;
        private String outputFormat, nameOfTheFile;
        
        private FileInputStream fis;
        private FileOutputStream fos;
        List <Byte> al;
        
        private byte[] buffer;
        
        private int blockNumber = 1;
        
        public ReGenerateFiles(File inputFile, File outputFile, String nameOfTheFile, String outputFormat)
        {
            this.inputFolder = inputFile;
            this.outputFolder = outputFile;
            this.nameOfTheFile = nameOfTheFile;
            this.outputFormat = outputFormat;
        }
        
        public void reGenerate() throws IOException
        {
            File file[] = inputFolder.listFiles();
            
            for(int i=0;i<file.length;i++)
            {
                System.out.println(file[i]);
            }
            
            for(int i=0;i<file.length;i++)
            {
                try
                {
                    buffer = new byte[30720];


                    fis = new FileInputStream(file[i]);
                    int read = fis.read(buffer, 0, buffer.length);
                    fis.close();
                    
                    writeBlock();
                    
                    
                }
                catch(IOException io)
                {
                    io.printStackTrace();
                }
                finally
                {
                    fis.close();
                    fos.close();
                }
            }
        }
        
        private void writeBlock()throws IOException
        {
            try
            {
                fos = new FileOutputStream(outputFolder+"/"+nameOfTheFile+"."+outputFormat,true);
                    fos.write(buffer, 0, buffer.length);
                    fos.flush();
                    fos.close();
            }
            catch(Exception e)
            {
                fos.close();
                e.printStackTrace();
            }
            finally
            {
                fos.close();
            }
        }
        
        
    }

In here, I am trying to re-assemble a **splited** file, back to its original file. This is how I split it

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileSplit {
    public static void main(String[] args) throws IOException {
        new FileSplit().splitFile(new File(args[0]));
    }

    private void splitFile(File file) throws IOException {
        FileInputStream fis = new FileInputStream(file);
        try {
            byte[] buffer = new byte[1024];
            // remaining is the number of bytes to read to fill the buffer
            int remaining = buffer.length; 
            // block number is incremented each time a block of 1024 bytes is read 
            //and written
            int blockNumber = 1;
            while (true) {
                int read = fis.read(buffer, buffer.length - remaining, remaining);
                if (read >= 0) { // some bytes were read
                    remaining -= read;
                    if (remaining == 0) { // the buffer is full
                        writeBlock(blockNumber, buffer, buffer.length - remaining);
                        blockNumber++;
                        remaining = buffer.length;
                    }
                }
                else { 
                    // the end of the file was reached. If some bytes are in the buffer
                    // they are written to the last output file
                    if (remaining < buffer.length) {
                        writeBlock(blockNumber, buffer, buffer.length - remaining);
                    }
                    break;
                }
            }
        }
        finally {
            fis.close();
        }
    }

    private void writeBlock(int blockNumber, byte[] buffer, int length) throws IOException {
        FileOutputStream fos = new FileOutputStream("output_" + blockNumber + ".dat");
        try {
            fos.write(buffer, 0, length);
        }
        finally {
            fos.close();
        }
    }
}

Now, after re-generating the file, it seems like some parts are missing. For an example, if I re-generated a splitted mp3, some small small portions of sounds are not there / sound is jumping etc. Why is that? Please help!

Another question, I have assigned 30720 as the byte array value. I did this because I failed to set the byte array according to the original size of the particular file which is about to process. I assigned the byte array value as

    buffer = new byte[(byte)file[i].length();

before, but it didn't work.

Please help me to solve these two issues and re-assemble the splitted file back, correctly. And please note, I have posted this in another location but didn't get any good answers, please help!

[Paul Clapham]

I just took a quick look at the code. There are probably more bugs, but I don't like this code:

fis = new FileInputStream(file[i]);  
int read = fis.read(buffer, 0, buffer.length);  
fis.close();  
                      
writeBlock();  

You read some number of bytes from the file, but then you call the writeBlock() method without telling it how many bytes you actually read. And that method simply assumes (perhaps incorrectly) that you read buffer.length bytes.

[Yohan Weerasinghe]

Paul Clapham wrote:I just took a quick look at the code. There are probably more bugs, but I don't like this code:

fis = new FileInputStream(file[i]);  
int read = fis.read(buffer, 0, buffer.length);  
fis.close();  
                      
writeBlock();  

You read some number of bytes from the file, but then you call the writeBlock() method without telling it how many bytes you actually read. And that method simply assumes (perhaps incorrectly) that you read buffer.length bytes.

OK, Thanks a lot for the reply. I really appreciate it. But, how can I do that? Please help!

[Paul Clapham]

The usual way to pass information to a method is by using parameters.

[Yohan Weerasinghe]

Yes. I did it. Thanks a lot for the reply.

And for the byte value case, I converted it using parse(xxx) methods.