Escribir en un fichero array de bytes y recuperarlos

[ferola]

Hola a todos, estoy realizando una aplicación en la que tengo que escribir a un fichero unos arrays de bytes. Concretamente son strings, pero los paso a arrays de bytes con byte [] a = cadena.getBytes();

Luego, escribo ese array en un fichero de texto, y desde otro programa necesito abrir dicho fichero y leer lo que tiene a otro array de bytes. Lo que pasa es q necesito leer justo los caracteres q contiene el fichero (es decir, justo lo que contenia el array inicial). ¿Cómo lo hago?

Gracias un saludo.

[elAntonie]

Wenas

el metodo length() de la clase File te devuelve el tamaño del fichero en bytes.

Saludos.

[GreenEyed]

Iniciado por ferola

Lo que pasa es q necesito leer justo los caracteres q contiene el fichero (es decir, justo lo que contenia el array inicial). ¿Cómo lo hago?

No acabo de entender el problema... si tienes que leer todos los bytes del fichero, si no paras de leer hasta llegar al final, ¿que podría pasar que no fuese leerlos todos? Por que más bytes de los que hay no vas a poder leer. .

Quizá es que no entiendo lo que quieres decir.

S!

[ferola]

Pues que yo solo sé hacerlo de la forma:
byte [] a = new byte[1000];
fileInput.read(a);

[GreenEyed]

Ah. Pero es que esa no es la forma "correcta" de leer de un Stream. Así sólo lees un trozo, el cual puede ser más grande o más pequeño dependiendo de varios factores.

Hay que usar un bucle.

Aquí puedes ver un ejemplo muy básico:
http://java.sun.com/docs/books/tutor...testreams.html

Recalcar que es un ejemplo muy básico que lee los bytes uno a uno. Lo normal es usar un BufferedInputStream por encima del InputStream, por ejemplo, para leer de más en más.

S!

[ferola]

Hola, gracias por responder.
Lo que pasa es que yo lo que leo, lo quiero almacenar en array de bytes tambien, por eso no sé de qeu tamaño definirlo.

[GreenEyed]

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!

[ferola]

lo intento...
Hago:

int leido;
byte [] vector;

FileInputStream entrada = new FileInputStream ("Fichero.txt");
BufferedInputStream buffer = new BufferedInputStream(entrada);
ByteArrayOutputStream salida = new ByteArrayOutputStream(vector);

leido = buffer.read(clave);
while (leido != -1)
{
salida.toByteArray(clave);
leido = buffer.read(clave);
}

Pero algo tengo mal pq no me tiene sentido :( Y no entcuentro ejemplos del estilo mezclando los flujos

[GreenEyed]

Código:

  byte[] copiarFicheroAMemoria(String nombreFichero)
  {
    byte[] contenidoDelFichero = null;
    File theFile = new File(nombreFichero);
    FileInputStream theFIS = null;
    BufferedInputStream theBIS = null;
    byte[] buffer = new byte[8 * 1024];
    int leido = 0;
    ByteArrayOutputStream theBOS = new ByteArrayOutputStream();

    try
    {
      theFIS = new FileInputStream(theFile);
      theBIS = new BufferedInputStream(theFIS);
      while ((leido = theBIS.read(buffer)) >= 0)
      {
        theBOS.write(buffer, 0, leido);
      }
      // Fichero leido del todo, pasamos el contenido
      // del BOS al byte[]
      contenidoDelFichero = theBOS.toByteArray();
      // Liberamos y cerramos para ser eficientes
      theBOS.reset();
      // Este close no va dentro de un try/catch por que
      // BOS es un Stream especial y close no hace nada
      theBOS.close();
    }
    catch (IOException e1)
    {
      // Error leyendo el fichero así que no tenemos
      // en memoria el fichero. 
      e1.printStackTrace();
    }
    finally
    {
      if (theBIS != null)
      {
        try
        {
          theBIS.close();
        }
        catch (IOException e)
        {
          // Error cerrando stream del fichero
          e.printStackTrace();
        }
      }
    }
    return contenidoDelFichero;
  }

Algo así, pero deberías jugar más con el tema e investigar y hacer pruebas, ya que la E/S es un tema fundamental. Tienes que ser capaz de montar tu este tipo de cosas a partir de ejemplos sueltos de otras cosas, por que muchas veces no encontraras los ejemplos exactos. En este caso he buscado y no he visto un ejemplo claro, así que por eso lo he puesto yo.

S!

[ferola]

Muchas gracias, es que nunca habia usado este tipo de flujos (solo leer y escribir líneas) y se me hace algo complicado.
Lo dicho, gracias!

[ferola]

Para escribir en el fichero un array de bytes (el que luego quiero recuperar):

FileOutputStream fileOut = new FileOutputStream ("Fichero.txt");
BufferedOutputStream buffer = new BufferedOutputStream(fileOut);

//byte arrayRes es el array de bytes que quiero guardar
buffer .write(arrayRes);
buffer.flush();
buffer.close();

Y una pregunta mas: para comparar si dos arrays de bytes son iguales, ¿puede hacerse (array1 == array2)?

Muchas gracias saludos!

[GreenEyed]

En cuanto a lo primero: si, añadiendo el control de excepciones, claro.

En cuanto a lo segundo: no. == sirve para decir que dos objetos son el mismo, no si son iguales. En el caso de Arrays tendrás que comparar elemento a elemento.

S!

[ojav22]

que tipo de flujo debo utilizar para recuperar un arreglo que se ha almacenado en un archivo? ayudaaaaaaa!!