No es ningún problema. Aunque parece un poco complejo al principio, la parte de IO de Java es bastante flexible.
La idea básica es que tienes "chorros de bytes" = InputStream/OutputStream (unos son de lectura y otros de escritura). Sobre esos objetos básicos tu puedes ir "montando" filtros que son otros Stream para añadir funcionalidad (para comprimir, leer/escribir de forma más eficiente, (de)serializar objetos...).
Entonces, dentro de los Stream hay unos tipos que son básicos, que són los que no se montan sobre otros y eso son los que leen/escriben realmente los bytes (File...Stream, ByteArray...Stream, Socket...Stream) y es con estos con los que tienes que empezar a montar tu "torre de streams".
Así que cuando quieres trabajar con IO en Java, tienes que pensar en tres pasos:
1.- De donde va a salir la información -> Te indica el Stream de base
2.- Donde/com quieres que acabe -> Te indica el último Stream de uso
3.- Una vez tienes uno y dos, tienes que averiguar que combinación de Streams tienes que usar para juntar uno con otro, y que pasos intermedios te conviene dar.
Ejemplos:
1)
.- Si vas a leer de un fichero, tu base es un FileInputStream
.- Si vas a leer de un array de bytes en memoria, tu base es ByteArrayInputStream
.- Si lees de un socket, tu base será un SocketInputStream
etc.
2)
.- Si lo que vas a leer son Objetos serializados, por ejemplo, pues tu ultimo Stream ha de ser un ObjectInputStream
.- Si lo que quieres leer son "lineas", entonces te buscas un stream que tenga el metodo "readLine()"
etc.
3)
.- Para aumentar el rendimiento, sobre la base casí siempre se añade un BufferedInputStream
.- Si los datos en estan comprimidos con Gzip, sobre tu torre montas un GzipInputStream
etc.
Así que en tu caso ->
Para leer el fichero:
1) Quieres leer de un fichero, asi que tu base es un FileInputStream
2) Quieres leer bytes, asi que no te hace falta nada sofisticado
3) Para no leer los bytes uno a uno, un BufferedInputStream
Para guardar la información que lees
1) Quieres guardar los bytes en memoria en un array de bytes, asi que tu base de escritura será un ByteArrayOutputStream
2) Cuando leas del fichero, leeras arrays de bytes, asi que hay que buscar un Stream que te deje escribir byte[], en este caso es muy facil ya que OutputStream directamente lo soporta
3) Como guardas los bytes en memoria, no hace falta nada aqui, en principio.
Y así ya tienes las piezas del puzzle. En codigo quiere decir que creas un FileInputStream, luego usas el constructor de BufferedInputStream (BIS) pasandole como parametro el FileInputStream. Creas un ByteArrayOutputStream (BOS) y, a medida que lees arrays de bytes del BIS, los escribes en el BOS. Cuando acabes de leer todo el fichero, tendras en memoria todo el contenido, dentro del BOS, que "casualmente" tiene un metodo llamado "toByteArray()"
.
Es una buena idea jugar con estas cosas, ya que es muy muy flexible.Yo una vez "monte" un stream para guardar objetos serializados, comprimidos con gzip, a través de un buffer, en una tabla de BDD y si montas las piezas como toca, de simple parece magia
.
Ahora te toca a ti jugar.
S!