Bueno. Esto se empieza a complicar. A ver si te lo explico mas o menos bien. En java existe el objeto File que es …. un objeto file digo esto porque en el acceso a ficheros se han superpuesto tal cantidad de clases e interfaces que al final el objeto file puede contener o bien un archivo, como era de esperar o bien un directorio o un arbol de directorios.
Para hacer boca…
//ControlDirectorios.java
// control y manipulacion de directorios.
import java.io.*;
public class ControlDirectorios{
private final static String uso = "Uso: \n" +
"ControlDirectorios directorio\n" +
"Crea un directorio\n-----------------\n" +
"ControlDirectorios -d ruta1 ...\n" +
"borra un directorio\n-----------------\n" +
"ControlDirectorios -r ruta1 ruta 2\n" +
"renombra ruta1 por ruta 2\n-----------------\n";
private static void uso(){
System.err.println(uso);
System.exit(1);
}
private static void datosArchivo(File f){
System.out.println(
"\nRuta absoluta: " + f.getAbsolutePath()+
"\nPuedes Leer? " + f.canRead()+
"\nPuedes Escribir? " + f.canWrite()+
"\nEl nombre es: " + f.getName()+
"\nSu padre es: " + f.getParent()+
"\nRuta : " + f.getPath()+
"\nTamaño : " + f.length()+
"\nUltima modificacion: " + f.lastModified()
);
if(f.isFile()){
System.out.println("Es un archivo");
}else if(f.isDirectory()){
System.out.println("Es un directorio");
}
}
public static void main(String[] args){
if(args.length < 1) { uso(); }
if(args[0].equals("-r")){
if(args.length != 3) uso();
File viejo = new File(args[1]);
File nuevo = new File(args[2]);
viejo.renameTo(nuevo);
datosArchivo(viejo);
datosArchivo(nuevo);
return; // salida de main.
}
int contador = 0;
boolean borrar = false;
if(args[0].equals("-d")){
contador++;
borrar = true;
}
for (; contador<args.length; contador++){
File f = new File(args[contador]);
if(f.exists()){
System.out.println(f+" existe");
if(borrar){
System.out.println("borrando...." + f);
f.delete();
}
}else{ // no hay archivo
if(!borrar){
f.mkdirs();
System.out.println("creando " + f);
}
}
datosArchivo(f);
}
}
}
…
// ListadoDirectorio.java
// ejemplo de la clase File
import java.io.*;
import java.util.*;
public class ListadoDirectorio{
public static void main(String[] args){
// variables
File ruta;
String[] lista;
if(args.length== 0){
ruta = new File(".");
}else{
ruta = new File(args[0]);
}
lista = ruta.list();
for( int i =0; i< lista.length; i++){
System.out.println(lista[i]);
}
}
}
Por otro lado, el acceso a datos tambien se maneja por medio de una superposicion de clases e interfaces una encima de otra que nos permite la fácil y rápida transformación de los datos. Aunque a simple vista no nos parezca. A ver… en el caso de la lectura desde un archivo. Tenemos la clase FileInputStream a la que se le pasa o bien el nombre del archivo o bien un objeto file (osea, el archivo). Para que el acceso sea mas rápido se usa el intermediario BufferedReader. El caso es que si no usasemos este intermediario, cada vez que pidiesemos datos del archivo tendríamos que leer el archivo en si. En cambio este BufferedReader nos va leyendo y almacenando los datos de modo que cuando los pedimos el ya los tiene. ¡Por fin un intermediario bueno! ¿Cuanto debe cobrar? Como que el BufferedReader tambien tiene un metodo readLine() lo podemos usar igual que el readLine() del FileInputStream y nos dará un null cuando ya no haya mas.
¡Recuerda que cuando abres un archivo debes cerrarlo! Le pasa como a las botellas de cerveza. ¡Si no se escapa el gas!
Se puede leer datos con formato. Pero entonces debes usar la clase InputStream y el método adecuado para leer cada tipo de datos. El Reader lee carácteres y el InputStream puede leer carácteres, bytes, numeros, cualqueir tipo de datos.
Bueno… para que veeas como va todo esto… aqui tienes tu ejemplo.
// DemoFlujoES.java
// configuraciones tipicas del flujos E/S
import java.io.*;
public class DemoFlujoES{
public static void main(String[] args) throws IOException{
// 1.leyendo de la entrada de fichero linea a linea
BufferedReader entrada = new BufferedReader( new FileReader("DemoFlujoES.java") );
String s, s2 = new String();
while( (s = entrada.readLine() ) != null){
s2 += s + "\n";
}
// cierro el fichero
entrada.close();
// 2. Entrada desde memoria
StringReader entrada2 = new StringReader(s2);
int c;
while( (c=entrada2.read() ) != -1) // nemos 1 es el valor de null
System.out.print( (char) c); // hay que convertirlo porque de memoria lee bytes...
// 3. Entrada con formatio desde memoria
try{
DataInputStream entrada3 = new DataInputStream( new ByteArrayInputStream(s2.getBytes() ) );
while(true){
System.out.print((char)entrada3.readByte() );
}
} catch (EOFException e){
System.err.println("fin del flujo");
}
// 4. Salida a archivo
try{
BufferedReader entrada4 = new BufferedReader(new StringReader(s2));
PrintWriter salida1 = new PrintWriter( new BufferedWriter( new FileWriter("Demo.out") ) );
int contadorLinea = 1;
while ( (s = entrada4.readLine() ) != null){
salida1.println(contadorLinea++ + ": " + s) ;
}
salida1.close();
}catch(EOFException e){
System.err.println("fin del flujo");
}
// 5. almacenamiento y recuperacion de datos
try{
DataOutputStream salida2 = new DataOutputStream(
new BufferedOutputStream(
new FileOutputStream("salida.txt") ) );
salida2.writeDouble(3.1415928);
salida2.writeChars("esto es un char\n");
salida2.writeBytes("esto son bytes\n");
salida2.close();
DataInputStream entrada5 = new DataInputStream(
new BufferedInputStream(
new FileInputStream("salida.txt") ) );
BufferedReader entrada5br = new BufferedReader(new InputStreamReader(entrada5));
// hay que usar data input stream para datos
System.out.println(entrada5.readDouble());
// y bufferedReader para texto ahora podemos usar el apropiado readline
System.out.println(entrada5br.readLine());
// pero pasa algo divertido
System.out.println(entrada5br.readLine());
// en cambio los bytes son correctos
}catch(EOFException e){
System.err.println("fin de flujo");
}
// y para terminar .... acceso directo al fichero
RandomAccessFile rf = new RandomAccessFile("prueba.txt","rw");
for(int i=0; i<10; i++)
rf.writeDouble(i*1.414);
rf.close();
rf = new RandomAccessFile("prueba.txt","rw");
rf.seek(5*8);
rf.writeDouble(47.0001);
rf.close();
rf = new RandomAccessFile("prueba.txt","r");
for(int i=0; i<10; i++)
System.out.println("valor" + i + ": "+ rf.readDouble());
rf.close();
}
}