Vous êtes sur la page 1sur 7

JFileChooser

JFileChooser, este se encuentra en la categora de componentes Complejos, ya que igual que


el JColorChooser presenta una ventana con funciones ya definidas y lgica preestablecida....
A diferencia del anterior, aunque ambos nos permiten manipular ventanas definidas, el
JFileChooser encierra un poquito mas de complejidad, pues en este caso trabajamos con
archivos (no se requiere mucho conocimiento sobre archivos ya que el ejemplo es muy
diciente, sin embargo mas adelante dedicaremos un espacio a el manejo de Archivos con
Java...).
Que Es?
La Clase JFileChooser, nos presenta una ventana de herramientas, que dependiendo de
nuestra lgica, nos permitir Abrir o Guardar archivos, igual que la JColorChooser, la ventana
es una ventana de Dialogo para navegar por nuestros directorios...
El Ejemplo.
Este es otro de esos ejemplos bsicos y fciles de entender, en si el componente que estamos
trabajando habla por si solo...... usaremos una ventana JFrame con un JTextArea y dos
JButtons.

La aplicacin nos permitir Abrir o Guardar un archivo de texto dependiendo del botn que
presionemos, veamos los mtodos que nos permiten est procedimiento (Se crea el objeto en
cada mtodo por motivos del ejemplo, pero lo ideal es que el objeto sea global para trabajar
con
el
mismo...).
Abrir Archivos.
Si definimos Abrir, entonces se cargar la ventana con lo necesario para navegar por nuestros
directorios y seleccionar el archivo que queremos abrir (el trabajo con tipos de archivos lo
veremos en una prxima entrada)

La Clase JFileChooser nos permite cargar la ventana anterior usando su mtodo


showOpenDialog(this), cuando seleccionamos el archivo deseado, lo agregamos a un objeto
de tipo File por medio del mtodo getSelectedFile(), posteriormente recorremos el archivo y
lo almacenamos en un String...
private String abrirArchivo() {
String aux="";
texto="";
try
{
/**llamamos el metodo que permite cargar la ventana*/
JFileChooser file=new JFileChooser();
file.showOpenDialog(this);
/**abrimos el archivo seleccionado*/
File abre=file.getSelectedFile();

/**recorremos el archivo, lo leemos para plasmarlo


*en el area de texto*/
if(abre!=null)
{
FileReader archivos=new FileReader(abre);
BufferedReader lee=new BufferedReader(archivos);
while((aux=lee.readLine())!=null)
{
texto+= aux+ "\n";
}
lee.close();
}
}
catch(IOException ex)
{
JOptionPane.showMessageDialog(null,ex+"" +
"\nNo se ha encontrado el archivo",
"ADVERTENCIA!!!",JOptionPane.WARNING_MESSAGE);
}
return texto;//El texto se almacena en el JTextArea

Por ultimo retornamos la cadena con el contenido de nuestro archivo y luego se almacena en el
rea de texto usando su propiedad setText(texto), en caso de cualquier excepcin, usamos los
bloques
try
catch
para
manejarlo....
Guardar Archivo.

Si definimos Guardar, igual que el anterior, se cargar una ventana para navegar por nuestros
directorios y definir la ruta donde ser almacenado.

De la misma forma, la lgica para navegar por nuestro PC biene definida gracias al metodo
showSaveDialog(this) de la clase JFileChooser, que nos permite cargar la ventana de
dialogo y encontrar la ruta donde almacenaremos el archivo.....
private void guardarArchivo() {
try
{
String nombre="";
JFileChooser file=new JFileChooser();
file.showSaveDialog(this);
File guarda =file.getSelectedFile();
if(guarda !=null)
{
/*guardamos el archivo y le damos el formato directamente,
* si queremos que se guarde en formato doc lo definimos como .doc*/
FileWriter save=new FileWriter(guarda+".txt");
save.write(areaDeTexto.getText());
save.close();
JOptionPane.showMessageDialog(null,
"El archivo se a guardado Exitosamente",
"Informacin",JOptionPane.INFORMATION_MESSAGE);
}
}

catch(IOException ex)
{
JOptionPane.showMessageDialog(null,
"Su archivo no se ha guardado",
"Advertencia",JOptionPane.WARNING_MESSAGE);
}

}
}

Internamente le definimos la extensin que vamos a manejar y tan solo es cuestin de dar un
nombre y listo, el sistema guarda el contenido del rea de texto en un objeto de tipo
FileWriter y posteriormente el archivo en la ruta especificada....

UN EJEMPLO PARA UNA IMAGEN


JFileChooser es un componente JAVA, que nos permite selecionar y/o grabar cualquier archivo
basicamente dentro de nuestro ordenador, en este oportunidad fijaremos la antencion en la
funcion de Seleccion o Abrir

El ejemplo demostracion trata sobre: Selecionar un archivo imagen (.jpg, .gif, .png) y luego
tendremos q visualizar dicha imagen aqui la ventana ilustrativa.

Lo Primero q tendremos q hacer es dibujar nuestra interface grafica de usuario(GUI) en este


caso WindowDemoFile, lo unico nuevo en esta clase es el JFileChooser
public JFileChooser jfcExaminarEntrada;
jfcExaminarEntrada = new JFileChooser();

Esta demas decir q la imagen se visualizara dentro de un JDesktopPane, aqui en fuente:


import javax.swing.*;
public class WindowDemoFile extends JFrame {
public WindowDemoFile() {
initComponents(); }
private void initComponents() {
setTitle("DEMO POR INFORUX");
setResizable(false);
jfcExaminarEntrada = new JFileChooser();
jPanel1 = new JPanel();
jtfRutaEntrada = new JTextField();
jbExaminar = new JButton();
jbLoad = new JButton();

jPanel3 = new JPanel();


jDesktopPane1 = new JDesktopPane();
setDefaultCloseOperation( WindowConstants.EXIT_ON_CLOSE);
getContentPane().setLayout(null);
jPanel1.setBorder( BorderFactory.createTitledBorder("Ubica el Archivo
Imagen"));
jPanel1.setLayout(null);
jPanel1.add(jtfRutaEntrada);
jtfRutaEntrada.setBounds(20, 30, 350, 19);
jbExaminar.setText("...");
jPanel1.add(jbExaminar);
jbExaminar.setBounds(400, 30, 50, 25);
jbLoad.setText("load");
jPanel1.add(jbLoad);
jbLoad.setBounds(460, 30, 70, 25);
getContentPane().add(jPanel1);
jPanel1.setBounds(30, 30, 550, 70);
jPanel3.setBorder( BorderFactory.createTitledBorder("Imagen Cargada"));
jPanel3.setLayout(null);
jPanel3.add(jDesktopPane1);
jDesktopPane1.setBounds(20, 30, 530, 340);
getContentPane().add(jPanel3);
jPanel3.setBounds(20, 110, 570, 390);
java.awt.Dimension screenSize =
java.awt.Toolkit.getDefaultToolkit().getScreenSize();
setBounds((screenSize.width-618)/2, (screenSize.height-542)/2, 618,
542);
/*declaramos una referencia a nuestra clase control de eventos*/
ControlaEventos controlaEventos =new ControlaEventos (this);
jbExaminar.addActionListener(controlaEventos);
jbLoad.addActionListener(controlaEventos);
}
public static void main(String args[]) {
new WindowDemoFile().setVisible(true); }
public JFileChooser jfcExaminarEntrada;
public JButton jbExaminar;
public JButton jbLoad;
public JDesktopPane jDesktopPane1;
public JPanel jPanel1;
public JPanel jPanel3;
public JTextField jtfRutaEntrada;

}
La segunda clase es de nombre ControlaEventos, su mismo nombre lo dice, controla todos los
eventos producidos por el usuario. solo controlaremos los 2 botones con nombres q muestran
y load.
La novedad de esto, es q al producirse el evento en el boton q llama al JFileChoose. este
mostrara un dialogo y dentro de el, estara el componente. Para decirle cual de lo 2 tipos (open

y/o save), utilizamos los metodos showOpenDialog o showSaveDialog, segun nuestras


necesidades.
int result = d.showOpenDialog(ventana para seleccionar un archivo);
int result =d.showSaveDialog(ventana para guardar un archivo);
donde d es el frame, internalFrame, mejro dicho es la ventana donde se sobrepondra,
ademas esta llamada no entrega nada hasta que el usuario ha aceptado un archivo o
cancelado la entrada de ldialogo. El valor de retorno es:

JFileChooser.APROVE_OPTION (si haces click en entrar o gravar)


JFileChooser.CANCEL_OPTION. ( si hay evento en el boton cancelar del JFileChooser.)
Aqui el fuente:
import
import
import
import
public

java.awt.event.*;
java.io.File;
java.awt.image.BufferedImage;
javax.imageio.ImageIO;
class ControlaEventos implements ActionListener{
WindowDemoFile ventana;
File fileImagen;
public ControlaEventos(WindowDemoFile objeto){
ventana = objeto;
}
public void actionPerformed(ActionEvent evento)

if (evento.getSource()==ventana.jbExaminar){//si hay evento en el

boton examinar

int returnVal =
ventana.jfcExaminarEntrada.showOpenDialog(ventana);//mostramos el jFileChooser
if (returnVal ==
ventana.jfcExaminarEntrada.APPROVE_OPTION) {//nos aseguramos q haya selecionado
algun archivo
fileImagen =
ventana.jfcExaminarEntrada.getSelectedFile();//obtenemos el archivo selecionado
ventana.jtfRutaEntrada.setText(fileImagen.toString());
}}//mostramos la ruta del archivo en la caja de texto
if (evento.getSource()==ventana.jbLoad){//si hay evento en el
boton load
}

if ( fileImagen != null) {
cargarImagen(ventana.jDesktopPane1,fileImagen);}}

/*este metodo recibe el jdeskopPane y el archivo imagen*/


public void cargarImagen(javax.swing.JDesktopPane jDeskp,File
fileImagen)
{
try{
BufferedImage image = ImageIO.read(fileImagen);
jDeskp.setBorder(new PintaImagen(image)); }
catch (Exception e){
System.out.println("Noo imagen, sorry");
}
}
La ultima clase, es la misma a la entrada anterior, ahy se explica la clase PintaImagen
de todas formas aqui el fuente:

import
import
import
import
import

java.awt.Component;
java.awt.Graphics;
java.awt.Insets;
java.awt.image.BufferedImage;
javax.swing.border.Border;

public class PintaImagen implements Border{


private

BufferedImage image ;

public PintaImagen(BufferedImage image ) {


this.image=image;}
public void paintBorder(Component c, Graphics g, int x, int y, int
width, int height) {
int x0 = x+ (width-image.getWidth())/2;
int y0 = y+ (height-image.getHeight())/2;
g.drawImage(image,x0,y0,null); }
public Insets getBorderInsets(Component c) {
return new Insets(0,0,0,0);}
public boolean isBorderOpaque() {
return true; }
}
A travs de esta clase convertirlos el File a una imagen para pintarse en un JDesktopPane.
Aqui el pantallazo

Como ven. no es complicado mostrar un jFileChooser, solo una simple linea lo haces