Linea de Codigo

La clase File nos permite en Java instanciar cualquier elemento del sistema de ficheros y trabajar con él de una forma genérica. A la hora de instanciar el elemento podremos pasar al constructor bien un directorio o bien un fichero.

La instanciación de un objeto File sería de la siguiente forma:

File fRuta = new File("c:\\prueba");

Solo tendremos que apoyarnos en el método .isDirectory() para saber si una ruta es un directorio con Java :

if (fRuta.isDirectory())
  System.out.println("Es un directorio");
else
  System.out.println(" NO es un directorio");

Una de las operaciones que podemos hacer cuando estemos trabajando con un fichero será lde borrado. Borrar un fichero con ASP será tan sencillo como invocar al método DeleteFile.

El método DeleteFile depende del objeto FileSystemObjet. Es por ello que lo primero que tendremos que hacer será instanciar el fichero FileSystemObjet.

Set fso = Server.CreateObject("Scripting.FileSystemObject")

El método DeleteFile lleva dos argumentos. El primero es el nombre del fichero que queremos borrar y el segundo es una condición booleana que indica que hacer en caso de que el fichero sea de solo lectura. Indicando un valor true el fichero se eliminará independientemente de si es de lectura o no. Si bien, por defecto, el valor de este campo es false.

DeleteFile(fichero, obligatorio)

Además debemos de tener en cuenta que en el caso de que intentemos borrar un fichero que no existe nos dará fallo. Es por ello que deberemos de comprobar la existencia del mismo mediante el método FileExists al cual le pasamos la ruta con el nombre del fichero.

El código nos quedará de la siguiente forma:

if (fso.FileExists(sFichero)) then
  fso.DeleteFile sFichero,true
  Response.Write "Borrado el fichero " & sFichero
else
  Response.Write "No existe el fichero " & sFichero
end if

Ya están lejos los tiempos dónde un site de Internet estaba compuesto solo por páginas estáticas HTML. Ahora la mayoría se componen en los servidores, mezclando información, ficheros, datos almacenados,... Si bien podemos tener la necesidad de tener dinamismo en la carga de datos de la parte cliente. Para ello, jQuery nos dará la capacidad de cargar un fichero de forma dinámica.

Lo primero que tenemos que hacer es crear un fichero HTML de test. Este lo llamaremos test.html. Ahora pasamos a crear la página que nos permite cargar un fichero con jQuery. En esta, lo primero que vamos a hacer es cargar la librería jQuery.

<script type="text/javascript" src="jquery.js"></script>

Como en la mayoría de las ocasiones utilizamos la función ready para esperar que se cargue la página. Dentro de la función ready será donde insertemos nuestro código jQuery.

$(document).ready(function(){
 $("#carga").click(function() {
	// Código
   });
});

Vemos que el código que nos va a permitir cargar un fichero con jQuery se lo asociaremos al evento click de un elemento que llevará el ID carga. Por ejemplo, pondremos un botón...

<button id="carga">Cargar fichero</button>

Además añadiremos una capa, a la cual daremos el ID texto, sobre la cual cargaremos el fichero HTML.

 
<div id="texto"></div>
 

Ya solo nos quedará cargar el fichero. Para ello utilizamos la función .load(), a la cual pasamos el nombre del fichero a cargar. En nuestro caso el fichero test.html

 $("#carga").click(function() {
	 $("div#texto").load("test.html");
   });

Mediante la clase File podremos listar de forma sencilla el contenido de un directorio. Lo primero que tendremos que hacer es crear un objeto de tipo File con el nombre del directorio a a listar.

 
String sDirectorio = "c:\\datos";
File f = new File(sDirectorio);
 

Utilizaremos el método .exists() para comprobar que el directorio existe.

 
if (f.exists()){ // Directorio existe }
else { //Directorio no existe }
 

Una vez pasada esta validación utilizamos el método .listFiles. Este método devuelve todos los ficheros asociados al directorio en un array de Files. Es por ello que solo nos quedará recorrer el array e ir mostrando el nombre de lo ficheros y directorios que componen nuestro directorio.

 
File[] ficheros = f.listFiles();
for (int x=0;x<ficheros.length;x++){
  System.out.println(ficheros[x].getName());
}

Para obtenerel nombre del fichero o directorio utilizamos el método .getName().

Borrar un fichero con Java es una actividad bastante sencilla, ya que mediante la clase File, la cual nos abstrae de la manipulación de ficheros, se nos ofrece un método para llevar a cabo tal cometido.

Lo primero que deberemos de hacer es instanciar una clase File. Para instanciar esta clase deberemos de pasar al constructor el nombre del fichero sobre el que queremos trabajar.

File fichero = new File("fichero.txt");

Para borrar el fichero deberemos de invocar el método .delete() de la clase File. En caso de que se pueda realizar el borrado del fichero, dicho método devolverá true. En caso contrario devolverá false. Es por ello que deberemos de controlar su respuesta.

if (fichero.delete())
   System.out.println("El fichero ha sido borrado satisfactoriamente");
else
   System.out.println("El fichero no puede ser borrado");

Los ficheros de propiedades nos sirven para guardar pares clave/valor que normalmente contienen información variable utilizada por nuestro programa. Estaríamos hablando de ficheros de configuración.

Así, a bote pronto, se me ocurren cosas como URLs a las que acudir por información, datos sobre el usuario/password, números que representen límites de nuestras ejecuciones,...

Continue reading Modificar valores de un fichero Properties...

Si queremos crear un fichero con Java nos tenemos que apoyar en la clase File de Java IO la cual nos proporciona un método creteNewFile que generará el fichero en el path que le indiquemos.

Si bien debemos de tener en cuenta que el "directorio base" donde creemos el fichero debe de existir. Por ejemplo, en el caso de que creemos un fichero indicando el path "c:\temp\lineadecodigo\ficheroTexto", los directorios temporal y lineadecodigo deben de existir.

Así instanciaremos el objeto File de la siguiente forma:

File fichero = new File ("c:\\temp\\lineadecodigo\\fichero.txt");

o bien indicando el directorio y el fichero por separado:

File fichero = new File ("c:\\temp\\victor","fichero.txt");

Debemos de tener cuidado en utilizar la doble barra para indicar el directorio ya que cuando utilizamos la barra sola se asume que es una secuencia de escape del estilo \n \b \t...

Una vez creado el fichero simplemente bastará invocar el método createNewFile teniendo cuidado de que puede ser lanzada la excepción IOException a si que debemos de capturarla.

try {
  // A partir del objeto File creamos el fichero físicamente
  if (fichero.createNewFile())
    System.out.println("El fichero se ha creado correctamente");
  else
    System.out.println("No ha podido ser creado el fichero");
} catch (IOException ioe) {
  ioe.printStackTrace();
}

El método devolverá true si ha podido crear el fichero y false si no ha podido llevarlo a cabo.

Visualizar el ejemplo | Descargar el código

Entre las muchas operativas que se pueden hacer sobre un fichero tenemos el renombrado de un fichero. Para ello la librería de Java, Java IO, nos ofrece un método sobre la clase File.

Si recordamos un poco la filosofía de la clase Java IO veremos que la clase File representa la abstracción de un fichero o directorio independientemente del sistema de ficheros que tengamos por debajo.

Lo primero que tenemos que hacer es instanciar la clase File sobre el fichero que queramos realizar el renombrado. Para ello utilizamos el constructor de la clase File, como podemos ver en la siguiente línea de código:

File f1 = new File("fichero1.txt");

Lo siguiente será instanciar una nueva clase File con el nombre del fichero que queramos poner. Veámos la línea de código:

File f2 = new File("fichero2.txt");

Con las dos abstraciones de los ficheros solo nos quedará el ejecutar el método .renameTo(File) sobre el primer fichero. El método .renameTo(File) recibe como parámetro un objeto File con el nuevo nombre. El que nosotros hemos llamado f2

boolean correcto = f1.renameTo(f2);

El método .renameTo(File) devuelve un valor booleano indicando si se ha podido realizar el renombrado, o no. A si que para finalizar validaremos la variable booleana con el fin de dar información al usario.

if (correcto)
  System.out.println("El renombrado ha sido correcto");
else
  System.out.println("El renombrado no se ha podido realizar");

La idea de este ejemplo es contar el número de líneas que tiene un fichero de texto utilizando las librerias Java IO del lenguaje Java. La forma en la que lo vamos a resolver no es la más optima, si bien es la más sencilla de implementar y entender.

De inicio deberemos de tener un fichero de texto con contenido. A dicho fichero lo llamaremos fichero.txt. Para abrir este fichero utilizaremos la clase FileReader. Con dicha clase obtendremos una referencia sobre el fichero que queremos conocer su número de líneas. Veamos la línea de código:

FileReader fr = new FileReader("fichero.txt");

Lo siguiente que vamos a hacer es leer el contenido del mismo. Para ello no nos vale el FileReader y nos tendremos que apoyar en un buffer. En este caso usamos un BufferedReader, el cual espera como parámetro la referencia que tenemos sobre el. Esta será nuestra línea de código:

BufferedReader bf = new BufferedReader(fr);

Apoyandonos en el método .readLine() del buffer, podremos ir leyendo el contenido de cada una de las filas del fichero. Esta lectura la podemos hacer mediante un bucle hasta que el contenido de la lectura sea null. Esto querra decir que ya no hay más contenido en el fichero.

En cada una de las lecturas de línea iremos incrementando un contador, el cual lleva la cuenta de las líneas del fichero

long lNumeroLineas = 0;
 
while ((sCadena = bf.readLine())!=null) {
  lNumeroLineas++;
}

En este proceso tenemos que tener especial cuidado con dos excepciones. La primera es FileNotFoundException. Esta se producirá si el nombre del fichero sobre el que queremos obtener la referencia, no existe. La segunda será IOException. Esta execpión es lanzada si se tienen problemas en el acceso al propio fichero o stream de entrada. Es por ello que todo nuestro código deberá de estar en un bucle try-catch que controle dichas excepciones.

try{
  //Código
} catch (FileNotFoundException fnfe){
  fnfe.printStackTrace();
} catch (IOException ioe){
  ioe.printStackTrace();
}

Solo nos quedará el mostrar por pantalla el número de líneas que hemos acumulado. Para ello necesitaremos la siguiente línea de código:

System.out.println("El fichero tiene " + lNumeroLineas + " lineas");