1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 | /* Ejercicio: 2x2x01 Fecha: 27/09/2012 Enunciado: 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.File; public class _2x2x01 { public static void metodo(String[] args) { File file = new File(args[0]); if( file.isDirectory() ) { File[] ficheros = file.listFiles(); for( File f : ficheros ) System.out.println(f.getName()); } } public static void main(String[] args) { String[] argumentos = { "C:\\" }; metodo(argumentos); } } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 | /* Ejercicio: 2x2x02 Fecha: 27/09/2012 Enunciado: 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.File; public class _2x2x02 { public static void metodo(String[] args) { File file = new File(args[0]); if( file.isDirectory() ) { String[] ficheros = file.list(); for( String f : ficheros ) if( f.endsWith(args[1]) ) System.out.println(f); } } public static void main(String[] args) { String[] argumentos = { "C:\\Windows", ".exe" }; metodo(argumentos); } } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 | /* Ejercicio: 2x2x03 Fecha: 27/09/2012 Enunciado: 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. */ import java.io.File; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; public class _2x2x03 { public static void CopyFile(File in, File out, Boolean sobreescribir) { // Precondicion: La bandera indica la sobreescritura del fichero con un TRUE: try { FileReader fr = new FileReader(in); FileWriter fw = new FileWriter(out, !sobreescribir); int i = fr.read(); while( ( i = fr.read() ) != -1 ) fw.write(i); fr.close(); fw.close(); } catch( Exception e ) { e.printStackTrace(); } } public static void CopyFile(String[] args) { File fo = new File(args[0]); File fd = new File(args[1]); // Condicion: La ruta de origen NO es un fichero. // Implica: Que el programa finaliza pues no hay nada que copiar. if( !fo.isFile() ) { System.out.println("El origen no es un fichero."); } else if( fo.isDirectory() && fd.isDirectory() ) { System.out.println("Ambos son directorios"); } // Condicion: La ruta de destino es un directorio, y NO existe ningun fichero con el mismo nombre que el de origen. // Implica: Que puede copiarse el original al destino sin mas. else if( fd.isDirectory() && !( new File(fd.toString() + fo.getName()).exists() ) ) { CopyFile(fo, new File(fd.toString() + File.separator + fo.getName()), false); } // Condicion: La ruta de destino es un directorio, y SI existe un fichero con el mismo nombre que el de origen, ademas la bandera de sobreescritura marca TRUE: // Implica: Que para copiar el fichero original hay que "machacar" el fichero de destino para cambiar sus datos. else if( fd.isDirectory() && ( new File(fd.toString() + File.pathSeparatorChar + fo.getName()).exists() ) && Boolean.parseBoolean(args[2]) ) { CopyFile(fo, new File(fd.toString() + File.separator + fo.getName()), true); } // Condicion: La ruta de destino es un fichero y NO existe: // Implica: Que se ha de copiar el fichero de destino en la ruta de destiono pero con el nuevo nombre else if( !fd.isDirectory() && !fd.exists() ) { CopyFile(fo, fd, false); } // Condicion: La ruta de destino es un fichero y SI existe y la bandera de sobreescritura marca TRUE: // Implica: Que para copiar el fichero original con el nuevo nombre se ha de "machacar" el fichero existente en el destino. else if( !fd.isDirectory() && fd.exists() && Boolean.parseBoolean(args[2]) ) { CopyFile(fo, fd, true); } // El fichero no se ha copiado. Salta una excepcion: else { throw new IllegalAccessError("Exception"); } } public static void main(String[] args) throws IOException { String[] argumentos = { "C:\\pruebas\\1\\ficheroA.txt", "C:\\pruebas\\2\\ficheroB.txt", "true" }; CopyFile(argumentos); } } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 | /* Ejercicio: 2x2x04 Fecha: 27/09/2012 Enunciado: 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. Info: http://lineadecodigo.com/java/copiar-directorio-con-java/ */ import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.util.Calendar; import java.util.GregorianCalendar; public class _2x2x04 { public static void copyFile(String[] args) { try { BufferedInputStream bfis = new BufferedInputStream(new FileInputStream(new File(args[0]))); BufferedOutputStream bfos = new BufferedOutputStream(new FileOutputStream(new File(args[1]))); byte[] buffer = new byte[1024]; int numBytesBuffer; while( ( numBytesBuffer = bfis.read(buffer, 0, buffer.length) ) != -1 ) bfos.write(buffer, 0, numBytesBuffer); bfis.close(); bfos.close(); } catch( Exception e ) { e.printStackTrace(); } } public static void copyDirectory(String[] args) { File fo = new File(args[0]); File fd = new File(args[1]); if( fo != null && fd != null ) { if( !fo.isDirectory() ) { copyFile(args); } else { if( !fd.exists() ) fd.mkdir(); String[] ficheros = fo.list(); for( String f : ficheros ) { String[] argumentos = { new File(fo, f).toString(), new File(fd, f).toString() }; copyDirectory(argumentos); } } } } public static void main(String[] args) { long oldTime = ( (Calendar)new GregorianCalendar() ).getTimeInMillis(); String[] argumentos = { "C:\\pruebas\\origen", "C:\\pruebas\\destino" }; copyDirectory(argumentos); System.out.println("Se tardo " + ( (double)( ( (Calendar)new GregorianCalendar() ).getTimeInMillis() - oldTime ) / 1000 ) + " seg."); } } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 | /* Ejercicio: 2x2x05 Fecha: 27/09/2012 Enunciado: 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. (Con RandomAccessFile) */ import java.io.File; import java.io.RandomAccessFile; public class _2x2x05 { public static void metodo(int[] ref, double[] precio, String ruta) { try { RandomAccessFile raf = new RandomAccessFile(new File(ruta), "rw"); for( int i = 0 ; i < ref.length ; i++ ) { raf.writeInt(ref[i]); raf.writeByte('\t'); raf.writeDouble(precio[i]); raf.writeByte('\n'); } raf.close(); } catch( Exception e ) { e.printStackTrace(); } } public static void main(String[] args) { int[] ref = { 1001, 1002, 1003, 1004 }; double[] precio = { 10.3, 15.2, 5.02, 151.99 }; String ruta = "tienda.txt"; metodo(ref, precio, ruta); } } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 | /* Ejercicio: 2x2x06 Fecha: 28/09/2012 Enunciado: 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. (Con RandomAccessFile) */ import java.io.EOFException; import java.io.File; import java.io.FileNotFoundException; import java.io.IOException; import java.io.RandomAccessFile; public class _2x2x06 { public static void metodo(String[] args) { RandomAccessFile raf = null; boolean finFichero = false; try { raf = new RandomAccessFile(new File(args[0]), "r"); do { try { System.out.print(raf.readInt() + " "); raf.seek(raf.getFilePointer() + 1); System.out.println(raf.readDouble()); raf.seek(raf.getFilePointer() + 1); } catch( EOFException e ) { finFichero = true; raf.close(); } } while( !finFichero ); } catch( FileNotFoundException e ) { System.out.println("El archivo no existe"); } catch( IOException e ) { System.out.println("Se produjo un error con el archivo"); } } public static void main(String[] args) { String[] argumentos = { "tienda.txt" }; metodo(argumentos); } } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 | /* Ejercicio: 2x1x01 Fecha: 20/09/2012 Enunciado: Escribe un programa que escriba los 100 primeros números naturales en un archivo numNaturales.txt */ import java.io.*; public class _2x1x01 { public static void main(String[] args) { try { FileWriter fw = new FileWriter("numNaturales.txt"); for( int i = 0 ; i < 100 ; i++ ) fw.write(i + "\r\n"); fw.close(); } catch( IOException ex ) { ex.printStackTrace(); } } } |