file-io enviar email - Archivo a byte [] en Java





10 Answers

Desde JDK 7 puedes usar Files.readAllBytes(Path) .

Ejemplo:

import java.io.File;
import java.nio.file.Files;

File file;
// ...(file is initialised)...
byte[] fileContent = Files.readAllBytes(file.toPath());
spring javamail tutorial

¿Cómo convierto un java.io.File a un byte[] ?




Desde JDK 7 - un trazador de líneas:

byte[] array = Files.readAllBytes(new File("/path/to/file").toPath());

No se necesitan dependencias externas.




Como dijo alguien, Apache Commons File Utils puede tener lo que buscas

public static byte[] readFileToByteArray(File file) throws IOException

Ejemplo de uso ( Program.java ):

import org.apache.commons.io.FileUtils;
public class Program {
    public static void main(String[] args) throws IOException {
        File file = new File(args[0]);  // assume args[0] is the path to file
        byte[] data = FileUtils.readFileToByteArray(file);
        ...
    }
}



// Returns the contents of the file in a byte array.
    public static byte[] getBytesFromFile(File file) throws IOException {        
        // Get the size of the file
        long length = file.length();

        // You cannot create an array using a long type.
        // It needs to be an int type.
        // Before converting to an int type, check
        // to ensure that file is not larger than Integer.MAX_VALUE.
        if (length > Integer.MAX_VALUE) {
            // File is too large
            throw new IOException("File is too large!");
        }

        // Create the byte array to hold the data
        byte[] bytes = new byte[(int)length];

        // Read in the bytes
        int offset = 0;
        int numRead = 0;

        InputStream is = new FileInputStream(file);
        try {
            while (offset < bytes.length
                   && (numRead=is.read(bytes, offset, bytes.length-offset)) >= 0) {
                offset += numRead;
            }
        } finally {
            is.close();
        }

        // Ensure all the bytes have been read in
        if (offset < bytes.length) {
            throw new IOException("Could not completely read file "+file.getName());
        }
        return bytes;
    }



Una forma sencilla de hacerlo:

File fff = new File("/path/to/file");
FileInputStream fileInputStream = new FileInputStream(fff);

// int byteLength = fff.length(); 

// In android the result of file.length() is long
long byteLength = fff.length(); // byte count of the file-content

byte[] filecontent = new byte[(int) byteLength];
fileInputStream.read(filecontent, 0, (int) byteLength);



Guava tiene Files.toByteArray() para ofrecerle. Tiene varias ventajas:

  1. Cubre el caso de la esquina donde los archivos reportan una longitud de 0 pero aún tienen contenido
  2. Está altamente optimizado, obtienes una excepción OutOfMemoryException si intentas leer un archivo grande antes de intentar cargar el archivo. (A través del uso inteligente de file.length ())
  3. No tienes que reinventar la rueda.



import java.io.File;
import java.nio.file.Files;
import java.nio.file.Path;

File file = getYourFile();
Path path = file.toPath();
byte[] data = Files.readAllBytes(path);



ReadFully lee los bytes de b.length de este archivo en la matriz de bytes, comenzando en el puntero del archivo actual. Este método lee repetidamente desde el archivo hasta que se lee el número de bytes solicitado. Este método se bloquea hasta que se lee el número solicitado de bytes, se detecta el final de la secuencia o se lanza una excepción.

RandomAccessFile f = new RandomAccessFile(fileName, "r");
byte[] b = new byte[(int)f.length()];
f.readFully(b);



Si desea leer bytes en un búfer de bytes asignado previamente, esta respuesta puede ayudar.

Su primera suposición probablemente sería utilizar la InputStream read(byte[]) . Sin embargo, este método tiene una falla que lo hace irrazonablemente difícil de usar: no hay garantía de que la matriz esté completamente llena, incluso si no se encuentra ningún EOF.

En su lugar, eche un vistazo a DataInputStream readFully(byte[]) . Este es un contenedor para flujos de entrada y no tiene el problema mencionado anteriormente. Además, este método arroja cuando se encuentra EOF. Mucho más bonito.




Otra forma de leer bytes del archivo.

Reader reader = null;
    try {
        reader = new FileReader(file);
        char buf[] = new char[8192];
        int len;
        StringBuilder s = new StringBuilder();
        while ((len = reader.read(buf)) >= 0) {
            s.append(buf, 0, len);
            byte[] byteArray = s.toString().getBytes();
        }
    } catch(FileNotFoundException ex) {
    } catch(IOException e) {
    }
    finally {
        if (reader != null) {
            reader.close();
        }
    }





Related


Tags

java   file-io