Hola.
Muevo tu mensaje a otra sección más acorde. Donde publicaste inicialemente es para presentaciones y sugerencias.
Esto que preguntas, me ha recordado un práctica que hice algún tiempo (que no llegué a terminar, como casi todo lo que hago xD) donde simulaba una cartelera de cine, y guardaba información de películas, incluida una imagen con la portada de la película.
Estos objetos los
serializaba para guardarlos en disco y recuperarlos al iniciar el programa.
No se si podría ser aplicable en tu caso, es cuestión de probralo.
La imagen, la guardaba en un array de bytes.
Mira, estos eran los atributos de la clase. Marco en negrita donde se guardaba la imagen.
public final class Pelicula implements Serializable{
private String titulo;
private String director;
private String anio;
private String sinopsis;
private String genero;
private Integer entradasVendidas;
private Double recaudacion;
private byte[] portada;
Para
convertir la imagen en un array de bytes, usaba el siguiente método, que recibe un objeto File que apunta al fichero de la imagen.
public void setPortada(File imagen) {
portada = new byte[(int)imagen.length()];
try {
FileInputStream fis = new FileInputStream(imagen);
fis.read(portada);
fis.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
Para el proceso inverso, es decir, ese array de bytes volver a construir una imagen, usaba este otro método que devolvía un objeto
Image.
En este método la devuelvo reescalada a un determinado tamaño para que me coincida con un JPanel que usaré para mostrarla, pero no es necesario, eso ya depende de tu caso.
public Image getPortada() {
Image imagen = null;
ByteArrayInputStream bis = new ByteArrayInputStream(portada); //portada es el array de bytes
try {
imagen = ImageIO.read(bis);
} catch (IOException e) {
JOptionPane.showMessageDialog(null, "Error recuperando portada desde el array de bytes",
"Pelicula.getPortada()", JOptionPane.ERROR_MESSAGE);
e.printStackTrace();
}
return imagen.getScaledInstance(250, 382, Image.SCALE_SMOOTH);
}
De este modo, con
ObjectOutputStream lo guardaba en disco, y con
ObjectInputStream lo recuperaba al iniciar el programa.
Este objeto
Image que devuelve este último método, yo luego lo "pintaba" en una clase que hereda de Jpanel, y así se mostraba la imagen en pantalla.
private class PanelImagen extends JPanel {
private Image imagen;
public PanelImagen() {
setBackground(Color.DARK_GRAY);
setPreferredSize(new Dimension(250, 382));
setMaximumSize(new Dimension(250, 382));
}
public void setImagen(Image img) {
imagen = img;
repaint();
}
public void reset() {
imagen = null;
repaint();
}
@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);
g.drawImage(imagen, 0, 0, 250, 382, this);
}
}
No se darte más detalles al respecto, porque es algo que hice hace mucho tiempo, algo que de hecho no sabía hacer y tras investigar por la red di con esta solución.
Ya te digo que ni recordaba que había empezado esta práctica, la tenía olvidada y tu consulta me la ha hecho recordar.
Mira a ver si puedes implementarlo en tu código y nos cuentas.
Un saludo.
Tema: Java convertir imagen en array de bytes serializable ObjectOutputStream InputStr (Leído 2099 veces)
RSS -
WAP2