No es un bug, es una característica no documentada

miércoles, 7 de octubre de 2015

Acceso a datos. Ejercicios (II). Clases File y RandomAccessFile

16:39 Posted by Inazio , No comments
1. Escribir un programa que muestre los nombres de los archivos y directorios que se encuentren en el directorio que se pase como argumento (args[0]).

import java.io.*;
public class Main {

     public static void main(String[] args) {
         
          // Propiedades
          String directorio;
          File actual = null;
         
          // Métodos
          if (args.length > 0)
                directorio = args[0];
          else
                directorio = ".";
         
          try{
                actual = new File(directorio);
                if(actual.isDirectory()){
                     String[] contenido = actual.list();
                     for(int i = 0; i < contenido.length; i++){
                          System.out.println(contenido[i]);
                     }
                } // fin del if
                else
                     System.out.println("El directorio no es válido");
          }
          catch(Exception e){
                e.printStackTrace();
          }
     }
}

2. Escribir un programa que muestre los nombres de los archivos  de un directorio, que se pasará como argumento cuya extensión coincida con la que se pase como segundo argumento.

import java.io.*;

public class Main {

     public static void main(String[] args) {
         
          // Propiedades
          String directorio;
          File actual = null;
         
          if (args.length > 0)
                directorio = args[0];
          else
                directorio = ".";
         
          actual = new File(directorio);
         
          if (actual.isDirectory()){
                String[] archivos = actual.list(new FiltradoArchivos(".exe"));
              
                // Puede no devolver archivos con esa extensión
                if (archivos.length > 0){
                     for(int i = 0; i < archivos.length; i++){
                          // Imprimo el PATH primero y luego los archivos que finalicen en .exe
                          System.out.println("Archivos en " + actual.getAbsolutePath() + ":");
                          System.out.println(archivos[i]);
                     }
                }
                else{
                     System.out.println("No hay archivos para mostrar");
                }
                    
          }
          else
                System.out.println("Directorio no válido");

     }

}

3. Escribir un método que reciba por parámetro dos rutas correspondientes a un archivo de origen y otro de destino y que copie el archivo origen en la ubicación destino. La ruta destino puede consistir en un directorio o un archivo. En el primer caso, el archivo se copiará al directorio especificado manteniendo su nombre. En el segundo, se tomará como nombre del archivo copia el que especifique su ruta. Además el  método recibirá un tercer parámetro que actuará de bandera en caso que la ruta destino especifique un archivo y éste exista. Si la bandera es cierta, el archivo destino será reemplazado por el que se copie. En caso contrario, la operación de copia terminará. El método generará una excepción  si la bandera de reemplazo vale false y el archivo destino existe.

ARCHIVO OPCIONES.JAVA

import java.io.*;

public class Opciones {

     // Propiedades
     private File origen = null;
     private File destino = null;
     private InputStream in = null;
     private OutputStream out = null;
     private String ruta = "";
     private boolean controlOrigen = true; // Si TRUE el archivo de origen es correcto, si FALSE archivo de origen no existe
    
    
     // Métodos
     public void copiarArchivo(File o, File d, boolean bandera){
          indicarArchivo(o, d, bandera);
         
          // Si se ha validado las rutas de origen
          if (controlOrigen){
                try{
                     in = new FileInputStream(origen);
                     out = new FileOutputStream(destino);
                    
                     byte[] lector = new byte[1024]; // Buffer de bytes
                     int i;
                    
                     while ((i = in.read(lector)) > 0){
                          out.write(lector, 0, i);
                     }
                     System.out.println("Copia realizada correctamente");
                }
                catch(FileNotFoundException e){
                     e.printStackTrace();
                }
                catch(IOException e){
                     e.printStackTrace();
                }
                finally{
                     try{
                          in.close();
                          out.close();
                     }
                     catch(FileNotFoundException e){
                          e.printStackTrace();
                     }
                     catch(IOException e){
                          e.printStackTrace();
                     }
                }
          } // Fin del if
          else{
                System.out.println("El archivo de origen indicado no existe. No se puede realizar la copia");
          }
         
     }
    
     public void indicarArchivo(File o, File d, boolean bandera){
         
          // Controlo si la ruta de origen es un archivo. Si no no hay nada que hacer
          if(o.isFile())
                origen = o;
          else
                controlOrigen = false;
         
          // Si la bandera es TRUE el archivo ya existe, con lo que se sobrescribirá la ruta
          if(bandera)
                destino = d;

          if (d.isDirectory()){
                ruta = ruta +  d.getAbsolutePath() + File.separator + o.getName();
                System.out.println("Path D:" + d.getAbsolutePath());
                System.out.println("Nombre origen:" + o.getName());
                System.out.println("Ruta total:" + ruta);
                destino = new File(ruta);
          }
          else
                destino = d;
     }   
}

ARCHIVO MAIN.JAVA

import java.io.*;

public class Main {

     public static void main(String[] args) {

          // Propiedades
          Opciones op = new Opciones();
          File origen = new File("C:\\Users\\usuario\\workspace\\File3\\origen.txt");
          File destino = new File("C:\\Users\\usuario\\Desktop\\");
          System.out.println(destino.getAbsolutePath());
          // Código
          op.copiarArchivo(origen, destino, origen.isFile());
     }
}

4. Escribir un método que reciba las rutas correspondientes a dos directorios y copie recursivamente  (subdirectorios y ficheros)  el contenido del directorio origen en el directorio destino.

ARCHIVO FICHEROS.JAVA

import java.io.*;

public class Ficheros {
    
     // Métodos
     public void copiarDirectorio(File dOrigen, File dDestino) throws IOException{
         
          // Si es un directorio entro a realizar la copia
          if(dOrigen.isDirectory()){
                // Si el directorio no existe lo genera
                if(!dDestino.exists()){
                     dDestino.mkdir();
                }
                                              
                // Almaceno los fichos en un array de Strings
                String[] hijos = dOrigen.list();
                                              
                for(int i = 0; i < hijos.length; i++){
                     copiarDirectorio(new File(dOrigen, hijos[i]), new File(dDestino, hijos[i]));
                     System.out.println("Copiado " + hijos[i]);
                }
          }
          else{
                copiarFichero(dOrigen, dDestino);
          }
     }
    
     public void copiarFichero(File fOrigen, File fDestino) throws IOException{
         
          InputStream in = new FileInputStream(fOrigen);
          OutputStream out = new FileOutputStream(fDestino);
          byte[] buffer = new byte[1024];
          int cap;

          while ((cap = in.read(buffer)) > 0){
                out.write(buffer, 0, cap);
          }
         
          in.close();
          out.close();
         
          System.out.println("Copiado " + fOrigen.getName());
         
     }
}

ARCHIVO MAIN.JAVA

import java.io.*;

public class Main {

     public static void main(String[] args) {

          // Propiedades
          File origen = new File("C:\\Users\\usuario\\workspace\\File4\\origen\\");
          File destino = new File("C:\\Users\\usuario\\workspace\\File4\\destino\\");
          Ficheros fc = new Ficheros();
         
          // Código
          try{
                fc.copiarDirectorio(origen, destino);
                System.out.println("Volcado finalizado");
          }
          catch(IOException e){
                e.printStackTrace();
          }
         
     }

}

5. Escribir un método que reciba por parámetro un array de valores enteros correspondientes a referencias a artículos y un array de valores reales correspondientes a los precios de los artículos anteriores. El método recibirá también el nombre de un archivo sobre el que se escribirá cada referencia de artículo seguida de su precio. No capturar ninguna excepción.

FICHERO OPCIONES.JAVA

import java.io.*;
import java.util.Vector;
public class Opciones {
    
     // Métodos
     public void escribePrecios(int[] ref, double[] precio, String nombre) throws IOException{
          FileWriter fW = new FileWriter(nombre);
          BufferedWriter bW = new BufferedWriter(fW);
         
          for(int i = 0; i < ref.length; i++){
                bW.write(String.valueOf(ref[i]) + " - " + String.valueOf(precio[i]) + "€");
                bW.newLine();
          }
         
          bW.close();
          fW.close();
     }
}

FICHERO MAIN.JAVA

import java.io.IOException;

public class Main {

     public static void main(String[] args) {
         
          // Propiedades
          String nombre = "precios.txt";
          int[] ref = {1, 5, 58, 80, 97};
          double[] precio = {51.03, 5.00, 4.99, 87.95, 3.14};
          Opciones op = new Opciones();
         
          // Código
          try{
                op.escribePrecios(ref, precio, nombre);
                System.out.println("Fichero de precios generado correctamente");
          }
          catch(IOException e){
                e.printStackTrace();
          }
         
     }

}

6. Escribir un método que reciba por parámetro el nombre de un archivo que almacena una serie de referencias y precios de artículos y muestre su contenido por pantalla.

import java.io.*;
import java.util.Random;

public class Main {

     public static void main(String[] args) {

          // Propiedades
          int i, n;
          boolean finArchivo = false;
          RandomAccessFile archivo = null;
          Random r = new Random();
         
          // Genero archivo para probar la lectura de enteros
          try{
                archivo = new RandomAccessFile("precios.dat", "rw");
                for (i = 0; i < 100; i++){
                     if (i % 2 ==0){
                          n = r.nextInt(500)+1;
                          archivo.writeInt(n);
                     }
                     else{
                          n = r.nextInt(5000)+1;
                          archivo.writeInt(n);
                     }
                }
                archivo.close();
          }
          catch(FileNotFoundException e){
                e.printStackTrace();
          }
          catch(IOException e){
                e.printStackTrace();
          }
         
          // EJERCICO
          try{
                archivo = new RandomAccessFile("precios.dat", "rw");
                System.out.println("Referencia y precios");
                do{
                     try{
                          i = archivo.readInt();
                          n = archivo.readInt();
                         
                          System.out.println("REF. " + i + ": " + n + "€");
                     }
                     catch(EOFException e){
                          finArchivo = true;
                          archivo.close();
                          System.out.println("Fin de fichero");
                     }
                }while(!finArchivo);
          }
          catch(FileNotFoundException e){
                e.printStackTrace();
          }
          catch(IOException e){
                e.printStackTrace();
          }

     }

}

7. Escribir un método que reciba por parámetro el nombre de un archivo que almacena una serie de referencias y precios de artículos y actualice los precios de forma que los superiores a 100 euros se decrementen en un 50% y los inferiores se incrementen en un 50%. El método capturará y tratará todas las excepciones que puedan producirse.

FICHERO METODOS.JAVA

import java.io.*;
import java.text.DecimalFormat;

public class Metodos {

     // Propiedades
     private double i, n;
     private boolean finArchivo = false;
     private RandomAccessFile archivo = null;
     private DecimalFormat precio = new DecimalFormat("#.##");
     private DecimalFormat ref = new DecimalFormat("#");
    
     // Métodos
     public void leerArchivoDoubles(String nombre){
          finArchivo = false;
          try{
                archivo = new RandomAccessFile(nombre, "rw");
                System.out.println("Referencia y precios");
                do{
                     try{
                          i = archivo.readDouble();
                          n = archivo.readDouble();
                         
                          System.out.println("REF. " + ref.format(i) + ": " + precio.format(n) + "€");
                     }
                     catch(EOFException e){
                          finArchivo = true;
                          archivo.close();
                     }
                }while(!finArchivo);
          }
          catch(FileNotFoundException e){
                e.printStackTrace();
          }
          catch(IOException e){
                e.printStackTrace();
          }
     }
    
     public void cambiarPrecios(String nombre){
          finArchivo = false;
          try{
                archivo = new RandomAccessFile(nombre, "rw");
               
                do{
                     try{
                          // Modifico con cada dos doubles. Uno es ref. y otro el precio
                          i = archivo.readDouble();
                          i = archivo.readDouble();
                         
                          if (i > 100){
                               archivo.seek(archivo.getFilePointer()-8);
                               archivo.writeDouble(i * 0.50);
                          }
                          if (i < 100){
                               archivo.seek(archivo.getFilePointer()-8);
                               archivo.writeDouble(i * 1.50);
                          }
                     }
                     catch(EOFException e){
                          finArchivo = true;
                          archivo.close();
                     }
                }while(!finArchivo);
          }
          catch(FileNotFoundException e){
                e.printStackTrace();
          }
          catch(IOException e){
                e.printStackTrace();
          }
     }
}

FICHERO MAIN.JAVA

public class Main {

     public static void main(String[] args) {
         
          // Propiedades
          Metodos m = new Metodos();
         
          // Código
          m.cambiarPrecios("precios.dat");
          m.leerArchivoDoubles("precios.dat");
         
     }

}

0 comentarios:

Publicar un comentario