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