Usuario:
Lectura Archivo
Definición 
La lectura se realiza mediante un objeto de la clase BufferedReader. El objeto se crea empleando el nombre del archivo (incluida la localización en el disco):
```
BufferedReader br = new BufferedReader(new FileReader(file.getName());
```
Para evitar que la rutina no responda si hay problemas en la lectura del archivo se incluye un try catch. La lectura se realiza linea por linea:
```
try{
String line = br.readLine();
while(line != null){
line = br.readLine();
}
} finally {
br.close();
}
```
Para mayor seguridad el proceso se realiza dentro de un try-catch. Primero se crea el objeto archivo basado en la clase File
```
File file = new File("example.txt");
```
La escritura se realiza mediante un objeto de la clase BufferedWriter. El objeto se crea empleando el nombre del archivo (incluida la localización en el disco):
```
BufferedWriter output = new BufferedWriter(new FileWriter(file));
```
El texto que se quiera exportar, incluyendo los separadores y caracteres de final de linea (""
"") se escriben al buffer mediante
```
output.write(text);
```
Finalmente se cierra el archivo con el método close:
```
output.close();
```
con lo que se almacena la información.
ID:(1272, 0)
JFileChooser
Nota
Para trabajar con la clase JFileChosser se puede consultar el API:
Dos ejemplos de JFileChjooser en acción:
- obtener path
```
JFileChooser fc=new JFileChooser();
int returnVal=fc.showOpenDialog(this);
if (returnVal == JFileChooser.APPROVE_OPTION) {
String spath fc.getSelectedFile().getAbsolutePath();
}
```
- obtener archivo
```
JFileChooser fc=new JFileChooser();
int returnVal=fc.showOpenDialog(this);
if (returnVal == JFileChooser.APPROVE_OPTION) {
file=fc.getSelectedFile();
}
```
ID:(1275, 0)
Apertura de Archivo
Cita
Si el entero val es igual a
```
JFileChooser.APPROVE_OPTION
```
se ha seleccionado un archivo. Este se puede acceder como objeto de la clase File mediante
```
File file = fc.getSelectedFile();
```
El nombre, incluido su localización en el disco (path) se obtiene de método
```
file.getName()
```
ID:(1257, 0)
Interpretar la Línea
Ejercicio
Si la linea es de campos de largo fijo se puede usar el método
```
line.substring(int start,int end)
```
para leer cada uno de los elementos. Si los campos están separados por un carácter especial se les puede separar y asignar a un arreglo de textos con el comando split. Si se separar por coma seria
```
String[] temp = line.split(",");
```
ID:(1258, 0)
Ejemplo de uso de JFileChooser
Ecuación
Un ejemplo que emplea JFileChooser para seleccionar un archivo es
```
package chooser;
import java.io.File;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
public class SampleJFileChooser {
public SampleJFileChooser(){
JFileChooser jFileChooser = new JFileChooser();
jFileChooser.setCurrentDirectory(new File("/User/alvinreyes"));
int result = jFileChooser.showOpenDialog(new JFrame());
if (result == JFileChooser.APPROVE_OPTION) {
File selectedFile = jFileChooser.getSelectedFile();
System.out.println("Selected file: " + selectedFile.getAbsolutePath());
}
}
public static void main(String[] args) {
new SampleJFileChooser();
}
}
```
ID:(8863, 0)
Ejemplo de Lectura y Escritura
Script
La siguiente rutina lee un archivo y graba su contenido en un segundo archivo:
```
import java.io.*;
public class CopyFile {
public static void main(String args[]) throws IOException {
FileInputStream in = null;
FileOutputStream out = null;
try {
in = new FileInputStream("input.txt");
out = new FileOutputStream("output.txt");
int c;
while ((c = in.read()) != -1) {
out.write(c);
}
}finally {
if (in != null) {
in.close();
}
if (out != null) {
out.close();
}
}
}
}
```
ID:(8864, 0)
DOM XML
Variable
En el caso de parser DOM XML se debe consultar el paquete org.w3c.dom en
Para interpretar el texto se debe primero cargarlo y analizarlo:
```
File fXmlFile = new File("/Users/mkyong/staff.xml");
DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
Document doc = dBuilder.parse(fXmlFile);
doc.getDocumentElement().normalize();
```
Una vez analizado se procede a leer los nodos. Si el xml es de la forma:
```
```
Para la lectura se va leyendo primero la lista de nodos y luego cada nodo y sus atributos:
```
NodeList nList = doc.getElementsByTagName("element");
for (int n = 0; n < nList.getLength(); n++) {
Node nNode = nList.item(n);
if (nNode.getNodeType() == Node.ELEMENT_NODE) {
Element eElement = (Element) nNode;
}
}
```
ID:(1273, 0)