¿Cómo descomponer un archivo en pedazos usando Java?

Question

Tengo un tipo de pregunta extraña para hacer. Necesito saber cómo puedo dividir un archivo dado en pequeños pedazos utilizando Java (cualquier tipo de archivo). Entonces puedo poner esas paces en una cantidad de CD's, pendrives y take away. Lo intenté usando this manera

Pero como la mayoría de los usuarios comentaron, lo que estoy intentando no se puede lograr de esa manera. Entonces, decidí hacer una nueva pregunta para obtener un método correcto para romper archivos.

Cuando rompo un archivo en pedazos (supongo 30 piezas), debe haber una manera de volver a montarlos y crear el archivo original de nuevo. Por favor ayuda.

Answer 1

leer partes de bytes de matriz de bytes y almacenarlos en nuevos archivos cuando el búfer está lleno o no es el final del archivo.

Por ejemplo (código no es perfecto, pero debe ayudar a la comprensión del proceso)

class FileSplit { 
    public static void splitFile(File f) throws IOException { 
     int partCounter = 1;//I like to name parts from 001, 002, 003, ... 
          //you can change it to 0 if you want 000, 001, ... 

     int sizeOfFiles = 1024 * 1024;// 1MB 
     byte[] buffer = new byte[sizeOfFiles]; 

     String fileName = f.getName(); 

     //try-with-resources to ensure closing stream 
     try (FileInputStream fis = new FileInputStream(f); 
      BufferedInputStream bis = new BufferedInputStream(fis)) { 

      int bytesAmount = 0; 
      while ((bytesAmount = bis.read(buffer)) > 0) { 
       //write each chunk of data into separate file with different number in name 
       String filePartName = String.format("%s.%03d", fileName, partCounter++); 
       File newFile = new File(f.getParent(), filePartName); 
       try (FileOutputStream out = new FileOutputStream(newFile)) { 
        out.write(buffer, 0, bytesAmount); 
       } 
      } 
     } 
    } 

    public static void main(String[] args) throws IOException { 
     splitFile(new File("D:\\destination\\myFile.mp4")); 
    } 
} 

tamaño myFile.mp4 = 12,7 MB

Después de división que tenían 13 archivos

• myFile.mp4.001-myFile.mp4.012 con el tamaño de 1 MB
• myFile.mp4.013 con el tamaño de 806 KB

---

Si desea combinar estos archivos puede utilizar

public static void mergeFiles(List<File> files, File into) 
     throws IOException { 
    try (FileOutputStream fos = new FileOutputStream(into); 
     BufferedOutputStream mergingStream = new BufferedOutputStream(fos)) { 
     for (File f : files) { 
      Files.copy(f.toPath(), mergingStream); 
     } 
    } 
} 

También puede crear algunos métodos adicionales para hacer su vida más fácil. Por ejemplo, método que creará una lista de archivos que contienen partes separadas en función del nombre (y la ubicación) de uno de estos archivos.

public static List<File> listOfFilesToMerge(File oneOfFiles) { 
    String tmpName = oneOfFiles.getName();//{name}.{number} 
    String destFileName = tmpName.substring(0, tmpName.lastIndexOf('.'));//remove .{number} 
    File[] files = oneOfFiles.getParentFile().listFiles(
      (File dir, String name) -> name.matches(destFileName + "[.]\\d+")); 
    Arrays.sort(files);//ensuring order 001, 002, ..., 010, ... 
    return Arrays.asList(files); 
} 

Con este método podemos sobrecargar mergeFiles método para utilizar solamente uno de los archivos File oneOfFiles lugar de la lista entera List<File> (vamos a generar esa lista basándose en uno de los archivos)

public static void mergeFiles(File oneOfFiles, File into) 
     throws IOException { 
    mergeFiles(listOfFilesToMerge(oneOfFiles), into); 
} 

Puede también sobrecargar estos métodos a utilizar en lugar de StringFile (vamos a envolver cada cadena en archivos cuando sea necesario)

public static List<File> listOfFilesToMerge(String oneOfFiles) { 
    return listOfFilesToMerge(new File(oneOfFiles)); 
} 

public static void mergeFiles(String oneOfFiles, String into) throws IOException{ 
    mergeFiles(new File(oneOfFiles), new File(into)); 
} 

Answer 2

Leer & escribir secuencias como primas byte[]. Evite las secuencias de texto y los lectores.

En su última pregunta aparentemente estaban dividiendo los archivos según 'línea'. Para replicar ese comportamiento, simplemente usó un tamaño fijo de byte[] para leer. Observe cuidadosamente las advertencias en los comentarios a su última pregunta, para verificar cuántos bytes se leen. A byte[2^16] no necesariamente se rellenará en una sola lectura.