Repasando AD -> Serialización de objetos

Se ha hecho un poco tarde xD
Voy a aprovechar esta entrada para dar las gracias a Inazio por su gran blog, su dedicación y paciencia.

Y que mejor modo de hacerlo que recomendado los siguientes link:

http://programandoapasitos.blogspot.com.es/2015/10/acceso-datos-persistencia.html

http://programandoapasitos.blogspot.com.es/2015/10/acceso-datos-ejercicios-iii-persistencia.html

Repasando AD -> copia-pega recursivamente

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.

Principal

package copiapegarecursivo;

import java.io.File;
import java.io.IOException;

public class CopiaPegaRecursivo {

    public static void main(String[] args) {
        // Definición del directorio origen
        File origen = new File("C:\\Users\\Navis\\Desktop\\origen\\");
        // Definición del directorio destino  
        File destino = new File("C:\\Users\\Navis\\Desktop\\destino\\");
        // llamada a la clase
        Ficheros fc = new Ficheros();
        try{ // intenta
            //copiar directorio origen en destino
            fc.copiarDirectorio(origen, destino);
            //saca mensaje por pantalla
            System.out.println("Volcado finalizado");
        }
        catch(IOException e){ //control de errores
            //definción del error
            e.printStackTrace();
        }  
    }
}

Clase

package copiapegarecursivo;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Ficheros {
    // Función qe copia el directorio
     public void copiarDirectorio(File dOrigen, File dDestino) throws IOException{
        // Si es un directorio origen
        if(dOrigen.isDirectory()){
            // Si el directorio destino no existe
            if(!dDestino.exists()){
                //crea el directorio destino
                dDestino.mkdir();
            }                               
            // Se crea un listado del contenido del directorio origen
            String[] hijos = dOrigen.list();
            // recorrer la lista                                
            for(int i = 0; i < hijos.length; i++){
                // copia los directorios
                copiarDirectorio(new File(dOrigen, hijos[i]), new File(dDestino, hijos[i]));
                // saca el mensaje por pantalla
                System.out.println("Copiado " + hijos[i]);
            }
        }
        else{
            // copia los ficheros
            copiarFichero(dOrigen, dDestino);
        }
    }
    //Función que copia los ficheros
    public void copiarFichero(File fOrigen, File fDestino) throws IOException{
        // Lee el fichero
        FileInputStream origen = new FileInputStream(fOrigen);
        // Escribe el fichero
        FileOutputStream destino = new FileOutputStream(fDestino);
        byte[] buffer = new byte[1024];
        int cap;
        // mientras no llege al final la lectura del origen...
          while ((cap = origen.read(buffer)) > 0){
            // escribe en destino
            destino.write(buffer, 0, cap);
        }
        // cierra los ficheros 
        origen.close();
        destino.close();
        // saca un mensaje por pantalla 
        System.out.println("Copiado " + fOrigen.getName());
     }
}

Repasando AD -> Listado de un directorio

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]).

package listacontenidodirectorio;

import java.io.File;

public class ListaContenidoDirectorio {

    public static void main(String[] args) {
        String directorio;
        //Propiedad File
        File actual = null;
        //Directorio pasado por parametro
        if (args.length > 0)
              directorio = args[0];
        else
              directorio = ".";
        try{ // Intenta
            // Define el directorio
            actual = new File(directorio);
            // Si existeel directorio
            if(actual.isDirectory()){
                // Guarda el listado del contenido del directorio
                String[] contenido = actual.list();
                // recorre la lista
                for(int i = 0; i < contenido.length; i++){
                    //muestra la lista por pantalla
                    System.out.println(contenido[i]);
                }
            }
            else
                //muesta un mensaje por pantalla
                System.out.println("El directorio no es válido");
          }
          catch(Exception e){ // control de errores
            // Definición del error
            e.printStackTrace();
          }
     }
}

Repasando AD -> RandomAccessFile

La clase RandomAccessFile tiene todas las propiedades de las clases DataInputStream y DataOutputStream; permite abrir un archivo como lectura o como lectura y escritura simultáneamente de cualquier tipo de datos primitivo. Si se utiliza para lectura (modo “r”) dispone de métodos como: readInt(), readLong(), readDouble(), readLine()… Si se utiliza como lectura/escritura (modo “rw”) dispone de métodos como writeInt(), writeLong(), writeDouble(), writeBytes()…

import java.io.*;

public class EjemplAccesoAleatorio{
     public static void main(String[] args) {

          char c;
          boolean finArchivo = false;
          RandomAccessFile archivo = null;
         
          try{
                archivo = new RandomAccessFile("D:\\prueba.txt", "rw");
                System.out.println("El tamaño del archivo es: " + archivo.length());
                do{
                     try{
                          c = (char)archivo.readByte();
                          if (c == 'b'){
                               archivo.seek(archivo.getFilePointer()-1);
                               archivo.writeByte(Character.toUpperCase(c));
                          }
                     }
                     catch(EOFException e){
                          finArchivo = true;
                          archivo.close();
                          System.out.println("Todas las b convertidas a mayúsculas");
                     }
                }while(!finArchivo);
          }
          catch(FileNotFoundException e){
                System.out.println("El archivo no existe");
          }
          catch(IOException e){
                System.out.println("Se produjo un error con el archivo");
          }
     }
}

Repasando AD -> Clase File

permite crear o borrar archivos o directorios, cambiar el nombre de un archivo, leer el nombre del directorio, consultar si un nombre representa un fichero o directorio, listar el contenido de un directorio… independientemente de la plataforma (constante File.separator).

El parámetro path indica el camino hacia el directorio donde se encuentra el archivo, y name indica el nombre del archivo.

import java.io.File;

String sFichero = "miFichero.txt";
String sDirectorio = "miDirectorio";
String sPath = File.separator + sDirectorio + File.separator + sFichero;
System.out.println(sPath);

/*
\miDirectorio\miFichero.txt
 */

import java.io.File;

String sFichero = "miFichero.txt";
String sDirectorio = "miDirectorio";
String so = System.getProperty("os.name");
String separador = System.getProperty("file.separator");
String sPath = separador + sDirectorio + separador + sFichero;
System.out.println(sPath);
System.out.println(so);

/*
\miDirectorio\miFichero.txt
Windows 7
 */

Los métodos más importantes que describe esta clase son los siguientes: String getName() – Nombre String getPath() – Camino relativo String getAbsolutePath() – Camino absoluto boolean exists() boolean canWrite() – Si el archivo se puede escribir boolean canRead() – Si el archivo se puede leer boolean isFile() boolean isDirectory() boolean isAbsolute() – Si un Path es absoluto long lastModified() long length() – Longitud en bytes boolean mkdir() – Crea el directorio boolean mkdirs() – Crea el directorio y los superiores si no existen boolean renameTo(File destino) boolean delete() String[] list String[] list(FileFilter filter)

package ejemploclassfile;

import java.io.File;
import java.io.IOException;
import java.util.Date;

public class EjemploClassFile {

    public static void main(String[] args) {
        String directorio;
        // Se pasa el directorio como parametro
        if (args.length > 0)
            directorio = args[0];
        //Si no hay directorio, trabajara en la propia carpeta del proyecto
        else
            directorio = ".";
        //Define el directorio
        File actual = new File(directorio);
        //Saca un mensaje por pantalla
        System.out.println("El directorio es: ");
        try{ //intenta
            /*a conversión de una ruta a una ruta canónica hace que sea 
            *absoluta (por lo general virar en el directorio de trabajo actual 
            *por lo que por ejemplo ./file.txt se convierte 
            *en c:/temp/file.txt ).*/
            // saca por pantalla la ruta canonica
            System.out.println(actual.getCanonicalPath());
        }
        catch(IOException ex){ //control de errores
            // saca por pantalla un mensaje
            System.out.println("Error en directorio");
        }
        // saca por pantalla un mensaje
        System.out.println("Su contenido es:");
        // realiza un listado de los ficheros que contiene el directorio
        File[] archivos = actual.listFiles();
        // recorre la lista de archivos
        for (File archivo : archivos){
            // si es un archivo
            if(archivo.isFile()){
                System.out.println("Nombre: " + archivo.getName());
                System.out.println("Longitud en caracteres: " + archivo.length());
                System.out.println("Modificado: " + new Date(archivo.lastModified()));
                System.out.println("Camino: " + archivo.getPath());
                System.out.println("Camino absoluto: " + archivo.getAbsolutePath());
                System.out.println("Se puede escribir: " + archivo.canWrite());
                System.out.println("Se puede leer: " + archivo.canRead());
              }
              System.out.println();
        }
   }
}

package operacionesconficheros;

import java.io.File;
import java.io.IOException;

public class OperacionesconFicheros {

    public static void main(String[] args) {
        // Creación de un fichero
        try{
            // define el directorio del fichero
            File file = new File("C:\\Users\\Navis\\Desktop\\directorio\\paula.txt");
            // Se crea el directorio en el directorio indicado
            boolean resultado = file.createNewFile();
            if (resultado) //control de errores
                // saca un mensaje por pantalla
                System.out.println("Archivo creado");
            else
                // saca un mensaje por pantalla
                System.out.println("No se puede crear el archivo");
        }
        catch(IOException ex){ // control de errores
            //sacaun mensaje por pantalla
            System.out.println("Se produjo el error " + ex.getMessage());
        }
        try{ //intenta
            // define el directorio del fichero
            File file = new File("C:\\Users\\Navis\\Desktop\\directorio\\paula.txt");
            // borra el fichero
            boolean resultado = file.delete();
            if (resultado) //control de errores
                // saca un mensaje por pantalla
                System.out.println("Archivo borrado");
            else
                //saca un mensaje por pantalla
                System.out.println("No se pudo borar el archivo");
        }
        catch(Exception e){ //control de errores
            // saca un mensaje de errores
            System.out.println("Se produjo el error " + e.getMessage());
        }
    }
}

Repasando AD -> ejercicio con buffered

Escribir un método que reciba por parámetro un array de cadenas de caracteres y el nombre de un archivo. El método volcará el contenido del array de cadenas en el archivo especificado. Utilizar filtros.
Prueba del ejercicio 6 anterior: Realizar un método que reciba por parámetro el nombre de un archivo de texto y muestre su contenido por pantalla.

package ejercicioconbuffered;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class EjercicioconBuffered {
    // esta función escribe en el fichero la cadena de caracteres
    static void vuelcaCadena(String[] cadena, String nombre){
        //escribe en un fichero
        FileWriter fr = null;
        //almacena el fichero
        BufferedWriter bf = null;
        int i;
        try{ //intenta
            //define el fichero a escribir
            fr = new FileWriter(nombre);
            //define el fichero a almacenar
            bf = new BufferedWriter(fr);
            //recorre la cadena de caracteres
            for (i = 0; i < cadena.length; i++){
                //escribe la cadena de caracteres en el fichero
                bf.write(cadena[i]);
                bf.newLine();
            }
          }
          catch(FileNotFoundException ex){ //control de errores
                // define el error
                ex.printStackTrace();
          }
          catch(IOException ex){ // control de errores
                // define el error
                ex.printStackTrace();
          }
          finally{ //finalmente
                try{ //intenta
                    //cierra el almacenamiento
                    bf.close();
                    // cierra el fichero
                    fr.close();
                }
                catch(IOException ex){ //control de errores
                    // define el error
                    ex.printStackTrace();
                }
          }
     }
    // esta función lee el contenido del fichero
    static void cargaCodigo(String nombre){
        // lee de un fichero
        FileReader fr = null;
        // almacena el fichero
        BufferedReader bf = null;
        String linea;
        try{ //intenta
            // define el fichero a leer
            fr = new FileReader(nombre);
            // define el fichero a almacenar
            bf = new BufferedReader(fr); 
            // lee una linea del fichero
            linea = bf.readLine();
            //mientras haya lineas que leer
            while (linea != null){ 
                //saca por pantalla
                System.out.println(linea);
                // lee la siguiente linea
                linea = bf.readLine();
            }
        }
        catch(FileNotFoundException ex){ //control de errores
            //define el error
            ex.printStackTrace();
        }
        catch(IOException ex){ //control de errores
            //define el error
            ex.printStackTrace();
        }
        finally{ //haz siempre
              try{ //intenta
                // cierra el almacenamiento
                bf.close();
                // cierra el fichero
                fr.close();
              }
              catch(IOException ex){ // control de errores
                   //define el error
                   ex.printStackTrace();
              }
        }
     }
    //fnción principal
     public static void main(String[] args) {
          String[] cadena = {"hola", "¿que tal?", "y vos?"};
          vuelcaCadena(cadena, "hola.txt");
          cargaCodigo("hola.txt");
     }
}

Repasando AD -> saca por pantalla el contenido del fichero

Escribir un método que reciba por parámetro el nombre de un archivo e imprima las cadenas que dicho archivo almacena (una cadena por línea). Se tendrá en cuenta que las distintas cadenas se separan en el archivo por un asterisco (que no se imprimirá).

package sacaporpantalladelfichero;

import java.io.FileReader;
import java.io.IOException;

public class Sacaporpantalladelfichero {
    // función que saca por pantalla el contenido del fichero, evitando los '*'
    public static void leerCadenas(String nombre){
          // lee un fichero
          FileReader fr = null;
          int letra;
          try{ //intenta
                // define el fichero a leer
                fr = new FileReader(nombre);
                //lee del fichero
                letra = fr.read();
                //mientras no llegues al final del contenido del fichero...
                while(letra != -1) { 
                     //si el caracter es '*'
                     if(letra == '*')
                         //se sustituye el '*' por 'intro'
                         letra = '\n';
                     //se saca por pantalla el contenido en forma de caracter
                     System.out.print((char)letra);
                     //lee el siguiente caracter
                     letra = fr.read();
                }
          }
          catch(IOException ex){ //control de errores
                //definición del error
                ex.printStackTrace();
          }
          finally{ //haz siempre
                try{ //intenta
                    //cierra el fichero
                     fr.close();
                }
                catch(IOException e){ //control de errores
                    //definición del error
                     e.printStackTrace();
                }
          }
    }
    //función principal
     public static void main(String[] args) {
          leerCadenas("guarda.txt");
     }
}

Repasando AD -> Guarda una cadena de caracteres

Escribir un método que reciba un array de cadenas de caracteres y vuelque su contenido a un archivo cuyo nombre también se recibirá por parámetro. Las cadenas quedarán separadas en el archivo por un asterisco.

package guardacadenadecaractees;

import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;

public class GuardaCadenadeCaractees {
    /**
    *Recibe una cadena de caracteres y el nombre de un fichero.
    * Guarda la cadena de caracteres en el archivo.
    */
     public static void escribeArray(String[] cadena, String fichero){
          // escribe en un fichero
          FileWriter fr = null;
          try{ //intenta
                // define sobre que fichero escribir
                fr = new FileWriter(fichero);
                //recorre la cadena de caracteres
                for(int i = 0; i < cadena.length; i++){
                     //escribe la cadena en el fichero
                     fr.write(cadena[i]);
                     // añade el '*' excepto al final
                     if (i + 1 != cadena.length)
                         //escribe '*' en el fichero
                          fr.write("*");
                }
                // saca un mensaje por pantalla
                System.out.println("Palabras insertadas correctamente");
          }
          catch(IOException ex){ //control de errores
                // define el control de errores
                ex.printStackTrace();
          }
          finally{ //haz siempre
                try{ //intenta
                    //cierra el fichero
                     fr.close();
                }
                catch(IOException ex){ //control de errores
                     ex.printStackTrace();
                }
          }
     }
    //función principal
     public static void main(String[] args) {
          String [] cadenaCaracteres = {"uno","dos","tres"};
          String nombreFichero= "guarda.txt";
          escribeArray(cadenaCaracteres, nombreFichero);
    }
}

Repasando AD -> suma e imprime los numeros

Escribe un programa que reciba el nombre de un archivo que almacena una serie de cantidades enteras positivas e imprima su suma.

a corregir

package sumaeimprime;

import java.io.*;
import java.util.Scanner;

public class SumaeImprime {
    // Suma e imprime los numeros que contiene el ficheo numeros.txt
     public static void main(String[] args) {
          // lee n fichero
          FileReader fr = null;
          //escaneado lo escrito por teclado
          Scanner sc = new Scanner(System.in);
          int total;
          int num; 
          try{ // intenta
                // se saca el total por pantalla
                System.out.println("Introduzca el nombre del archivo");
                // definicón del fichero. Fichero introducido desde teclado
                fr = new FileReader(sc.nextLine());
                total = 0;
                //lee un númeo
                num = fr.read();
                //hasta no llegar al final...
                while (num != -1){
                    //suma los numeros
                     total = total + num;
                     //lee el siguiente numero
                     num = fr.read();
                }
                // se saca el total por pantalla
                System.out.println("Suma total: " + total);
          }
          catch(IOException e){ // control de errores
              //define el error
                e.printStackTrace();
          }
          finally{ // hacer siempre
                try{ // intenta
                    //cerrar el fichero
                     fr.close();
                }
                catch(Exception e){ // control de errores
                    //define el error
                     e.printStackTrace();
                }
          }
     }
}

Repasando AD -> cien primeros números naturales

 Escribe un programa que escriba los 100 primeros números naturales en un archivo numNaturales.txt.

package cienprimerosnumerosnaturales;

import java.io.*;

public class CienPrimerosNumerosNaturales {
    // Escribe un programa que escriba los 100 primeros números naturales 
    // en un archivo numNaturales.txt.
    public static void main(String[] args) {
          //escribe en un fichero
          FileWriter fr = null;
          int i;
          try{ //intenta
               //define el fichero sobre el que escribes
                fr = new FileWriter("numNaturales.txt");
                // cuenta hasta 100
                for(i=0;i<101;i++){
                    //escribe sobre el fichero
                     fr.write(i + " ");
                }
                // saca un mensaje por pantalla
                System.out.println("Fichero escrito correctamente");
          }
          catch(Exception e){ // control de errores
                // saca un mensaje por pantalla
                System.out.println("Ocurrio un error");
                //te muestra el error
                e.printStackTrace();
          }
          finally{ // haz siepre
                try{ // intenta
                    //cierra el fichero
                    fr.close();
                    // saca un mensaje por pantalla
                    System.out.println("Fichero cerrado correctamente");
                }
                catch(Exception e){ //control de errores
                    // saca un mensaje por pantalla
                    System.out.println("Ocurrio un error");
                    //te muestra el error
                    e.printStackTrace();
                }
          }   
     }
}

Reapasando AD --> Repaso general

Entrada de teclado

import java.io.*;

public class EntradaTeclado{
    
     public static void main(String[] args) throws IOException{
    
          InputStreamReader isr;
          BufferedReader teclado;
          String linea;
          byte b;
          int i;
          double d;
          boolean leido;
         
          isr = new InputStreamReader(System.in);
          teclado = new BufferedReader(isr);
         
          System.out.print("Introduzca un byte");
          linea = teclado.readLine();
          b = Byte.parseByte(linea);
          System.out.println("Byte introducido: " + b);
         
          System.out.print("Introduzca un entero");
          linea = teclado.readLine();
          i = Integer.parseInt(linea);
          System.out.println("Entero introducido: " + i);
         
          System.out.print("Introduzca un real");
          linea = teclado.readLine();
          d = Double.parseDouble(linea);
          System.out.println("Real introducido: " + d);
         
          do{
                try{
                     System.out.print("Introduzca un entero:");
                     linea = teclado.readLine();
                     i = Integer.parseInt(linea);
                     leido = true;
                }
                catch(NumberFormatException e){
                     System.out.println("Entero no correcto, inténtelo de nuevo");
                     leido = false;
                }
          }while(!leido);
          System.out.println("Entero introducido: " + i);
     }
}

Lectura del teclado

BufferedReader teclado = new BufferedReader(new InputStreamReader(System.in));
String entrada = teclado.readLine();

Escribir un fichero

FileOutputStream fos = new FileOutputStream("fichero.txt");
PrintWriter pr = new PrintWriter(fos);
...
pr.println("Escribimos texto");

Otro método de escribir un fichero

FileWriter fw = new FileWriter("fichero.txt");
PrintWriter pr = new PrintWriter(fos);
...
pr.println("Escribimos texto");

Lectura de líneas

FileInputStream fis = new FileInputStream("fichero.txt");
InputStreamReader isr = new InputStreamReader(fis);
BufferedReader buffer = new BufferedReader(isr);
...
String linea = buffer.readLine();

Otro método de leer ficheros.
Podemos cambiar FileInputStream por FileReader en cuyo caso el buffer sería un char[].

FileReader fr = new FileReader("fichero.txt");
BufferedReader buffer = new BufferedReader(fr);
...
String linea = buffer.readLine();

Escritura en modo datos

FileOutputStream fos = new FileOutputStream("salida.dat");
DataOutputStream dos = new DataOutputStream(fos);
dos.writeInt(5);

Lectura en modo datos

FileInputStream fis = new FileInputStream("salida.dat");
DataInputStream dis = new DataInputStream(fis);
int entero = dis.readInt();

Repasando AD -> Ficheros

Ejemplo 1 Lectura de char

import java.io.*;

public class EjemploLecturaChar{
     public static void main(String[] args){
          //Lee un fichero
          FileReader fr = null;
          int aux = 0;
          try{ //intenta
                //Define el fichero a leer
                fr = new FileReader("C:\\eclipse\\readme\\readme_eclipse.html");
                //Mientras no llegues al final
                while((aux = fr.read()) != -1)
                     //saca por pabtalla
                     System.out.println((char)aux);
          }
          catch(FileNotFoundException e){ //control de errores
                e.printStackTrace();
          }
          catch(IOException e){ // control de errores
                e.printStackTrace();
          }
          finally{ //haz siempre
                try{
                     //cierra el fichero
                     fr.close();
                }
                catch(IOException e){ //control de errores
                     e.printStackTrace();
                }
          }
     }
}

Ejemplo 2 Escritura de char

import java.io.*;

public class EjemploEscrituraChar{
     public static void main(String[] args){
          //Escribe en un fichero
          FileWriter fw = null;
          try{//intenta
                // define el archivo a escribir
                fw = new FileWriter("D:\\Prueba.txt");
                //escribe el contenido en el fichero
                fw.write('A');fw.write('A');fw.write(' ');fw.write('d');fw.write('S');fw.write('1');
          }
          catch(FileNotFoundException e){ //control de errores
                e.printStackTrace();
          }
          catch(IOException e){ //control de errores
                e.printStackTrace();
          }
          finally{ //haz siempre
                try{ //intenta
                     //cierra el fichero
                     fw.close();
                }
                catch(IOException e){ //control de errores
                     e.printStackTrace();
               }
          }
     }
}

Ejemplo 3 --> BufferedReader y BufferedWriter sirven como almacenamiento temporal en un buffer, para no actuar directamente sobre el stream.

import java.io.*;

public class EjemploFiltro{
     public static void main(String[] args){
          //fichero a leer
          String nombreArchivo = "D:\\prueba.txt";
          //lee un fichero 
          FileReader fr;
          //almacena un fichero
          BufferedReader filtro;
          String linea;
          try{ //intenta
                //se define el fichero a leer
                fr = new FileReader(nombreArchivo);
                // se define el fichero a almacenar
                filtro = new BufferedReader(fr);
                //Se lee el fichero hasta un salto de linea
                linea = filtro.readLine();
                //mientas haya lineas
                while(linea != null){
                     //saca por pantalla la linea
                     System.out.println(linea);
                     // lee la siguiente linea
                     linea = filtro.readLine();
                }
                //cierra el almacen
                filtro.close();
                //cierra el fchero
                fr.close();
          }
          catch(IOException e){ //control de errores
                System.out.println("No se puede abrir el archivo para lectura");
          }
     }
}

Ejemplo 4 --> encriptar

import java.io.*;

public class EncriptadoStream extends FilterOutputStream{ //¡importante!
   
     public EncriptadorStream(OutputStream out){
          //La llamada a super dentro de un método puede ocurrir en cualquier lugar dentro del código. 
          //Equivale a la ejecución del método de la superclase y es opcional: 
          //la hacemos sólo cuando nos resulta necesaria o conveniente para poder acceder a un método sobrescrito.
          super(out);
     }
    //función para encriptar
     public void write(int b) throws IOException{
          if (b == 255)
                b = 0;
          else
                b++;
          out.write(b);
     }
    
     public static void main(String[] args){
          // lee en el fichero definido
          FileInputStream entrada = new FileInputStream("D:\\entrada.txt");
          // escribe de forma encriptada en el fichero definido
          EncriptadorStream salida = new EncriptadorStream(new FileOutputStream("D:\\salida.txt"));
          //available devuelve el numero de bytes a leer
          while (entrada.available() > 0)
                // encripta lo leido
                salida.write(entrada.read());
          //cierra los ficheros
          entrada.close();
          salida.close();
     }
}

Repasando AD -> Streams

Un stream representa un flujo de información, una secuencia ordenada de datos procedente de una fuente o dirigida a un destino.
Un stream es una secuencia ordenada de datos. Estos datos pueden ser caracteres (caracteres Unicode de 16 bits) o bytes (8 bits).

Ejemplo 1 Lectura de byte

import java.io.*;

public class EjemploLecturaByte{
     public static void main(String[] args){
          //FileInputStream lee archivos
          FileInputStream fis = null;
          int aux = 0;
          try{
                //Se define el archivo a leer
                fis = new FileInputStream("C:\\eclipse\\readme\\readme_eclipse.html");
                //read lee el siguiente flujo de bytes y cuando alcanza el final devuelve -1
                while((aux = fis.read()) != -1)
                     System.out.println(aux + " - " + (char)aux);
          }
          catch(FileNotFoundException e){ //control de errores
               //printStackTrace te dice el tipo de excepción y donde sucedio.
                e.printStackTrace();
          }
          catch(IOException e){ //control de errores
                e.printStackTrace();
          }
         // conjunto de instrucciones necesarias tanto si se produce error o excepción 
          // como si no y que por tanto se ejecuta siempre.
          finally{
                try{
                     //cerrar el archivo
                     fis.close();
                }
                catch(IOException e){ //control de errores
                     e.printStackTrace();
                }
          }
     }
}

Ejemplo 2 Escritura de byte

import java.io.*;

public class EjemploEscrituraByte{
     public static void main(String[] args){
          //FileOutputStream escribe en archivos
          FileOutputStream fos = null;
          int aux = 0;
          try{
                //Se define el archivo a escribir
                fos = new FileOutputStream("D:\\Prueba.txt");
                //Escribe su contenido en el archivo
                fos.write(67); fos.write(76); fos.write(67); fos.write(32);
          }
          catch(FileNotFoundException e){ // control de errores
                e.printStackTrace();
          }
          catch(IOException e){ // control de errores
                e.printStackTrace();
          }
          finally{ //hacer siempre
                try{
                     //cierra el archivo
                     fos.close(); 
                }
                catch(IOException e){ // control de errores
                     e.printStackTrace();
               }
          }
     }
}

Ejemplo 3 Flujo con array

import java.io.*;

public class EjemploFlujoArray{
     //se trabaja con las excepciones de forma automatica
     public static void main(String[] args) throws IOException{
          //array de bytes
          byte[] byteArr1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
          //ByteArrayInputStream lee un array de bytes
          //Se define el array de bytes a leer
          ByteArrayInputStream flujoArrByte1 = new ByteArrayInputStream(byteArr1);
          //available devuelve el numero de bytes
          while(flujoArrByte1.available() != 0){
               //lee el byte
                byte leido = (byte) flujoArrByte1.read();
                System.out.println(leido);
          }
          //cierra el array de bytes
          flujoArrByte1.close();
     }
}

Ejemplo 4 Streams sobre ficheros

import java.io.*;

public class Copia{
     public static void main(String[] args){
          FileInputStream origen = null;
          FileOutputStream destino = null;
         
          try{
                origen = FileInputStream(args[0]);
                // true escribe sobe el fichero sin borrar lo anterior.
                destino = new FileOutputStream(args[1], true);
                // lee el siguiente flujo de bytes y lo devuelve como un entero
                int i = origen.read();
                // cuando read termina el flujo de bytes devuelve -1
                while(i != -1){ 
                     //escribe el byte leido
                     destino.write(i);
                     //lee el siguiente byte
                     i = origen.read();
                }
                origen.close();
                destino.close();
          }
          catch(IOException e){ // control de errores
                System.out.println("Error de ficheros");
          }
     }
}

Repasando AD --> System

Ejemplo 1 Cuenta caracteres

import java.io.*;

class CuentaCaracteres {
     /*throw IOException es un control de errores obligado por el lenguaje Java*/
     public static void main(String args[]) throw IOException{
          int contador = 0;
          /*System.in implementa la entrada estándar
           *read permite leer un carácter
           *Lee hasta que el carácter sea 'intro'*/
          while(System.in.read() != '\n')
                /*por cada carácter leído suma uno el contador*/
                contador++;
          /*System.out implementa la salida estándar
           *println imprime el contenido por pantalla*/
          System.out.println("Tecleados: " + contador + " caracteres");
     }
}

Ejemplo 2 Cuenta carecteres 2

import java.io.*;
import java.util.Scanner;

class CuentaCaracteres2{

     public static void main(String args[]) throws IOException{
          //Scanner sirve para escanear lo introducido por teclado
          Scanner sc = new Scanner(System.in);
          System.out.println("Introduzca una cadena");
          //Se guarda en la variable teclado lo escaneado hasta el 'intro'
          String teclado = sc.nextLine();
          //lenght() cuenta los caracteres existentes en una variable string
          System.out.println("Teclados " + teclado.length() + " caracteres");
     }
}

Estación de mensajes

Elige una interfaz entre todas las desarrolladas y añade una sencilla etiqueta denominada lEstacion.

Cada vez que un elemento reciba el foco del programa (Evento GetFocus), la etiqueta mutará a texto azul e informará al usuario de lo que debe hacer o introducir en ese control.

Cada vez que se produzca un error, la etiqueta mutará a texto rojo avisando al usuario de la situación que se ha producido.

ejemplo:

/*estación de mensajes*/
    Private Sub txtCuenta_GotFocus(sender As Object, e As EventArgs) Handles txtCuenta.GotFocus
        txtExplicativo.Text = "Número de cuenta. Contiene 10 números."
    End Sub

/*mensaje final*/
        If Len(txtCuenta.Text) = 10 And contador = 5 Then
            txtExplicativo.Text = "Cuenta introducida correctamente."
            txtExplicativo.ForeColor = Color.Green
        End If

Puedes descargarte el código aquí

Control de errores en visual basic

Visual Basic admite el control estructurado de excepciones (errores), que permite al programa detectar y recuperarse posiblemente de los errores durante la ejecución. Visual Basic utiliza una versión mejorada de la sintaxis Try...Catch...Finally, que ya está admitida por otros lenguajes como C++. El control estructurado de excepciones combina una estructura de control moderna (similar a Select Case o While) con excepciones, bloques de código protegidos y filtros.

El control estructurado de excepciones, que es el método recomendado de control de errores en Visual Basic, facilita la tarea de crear y mantener programas mediante controladores de errores consistentes y exhaustivos. El método de control de excepciones no estructurado por medio de On Error puede degradar el rendimiento de la aplicación y puede dificultar la depuración y el mantenimiento del código.

Una instrucción Try…Catch consiste en un bloque Try seguido de una o más cláusulas Catch, que especifican controladores para varias excepciones. Cuando se produce una excepción en un bloque Try, Visual Basic busca la instrucción Catch que controla la excepción. Si no se encuentra una instrucción Catch coincidente, Visual Basic examina el método que llamó al método actual, y así sucesivamente hasta la pila de llamadas. Si no se encuentra ningún bloque Catch, Visual Basic muestra al usuario un mensaje de excepción no controlada y detiene la ejecución del programa.

Puede utilizar más de una instrucción Catch en una instrucción Try…Catch . Si lo hace, el orden de las cláusulas Catch es significativo debido a que se examinan en orden. Las excepciones más específicas se capturan antes que las menos específicas.

Más info aquí, aquí y aquí.

Ejemplo

Try
            If (e.KeyCode = Keys.Back) Then /*borrar se permite*/
                e.Handled = True
            ElseIf (e.KeyCode < 47 Or e.KeyCode > 57) Then /*Las letras se suprimen*/
                e.SuppressKeyPress = True
            End If
        Catch ex As Exception
            MsgBox(ex.Message)
        End Try

Puedes descargar el código aquí

Añade ayuda en la interfaz

Añade un control de tipo ToolTip

Déjalo siempre visible usando la propiedad ShowAlways.

De forma manual en cada elemento que quieras que tenga asociado un texto explicativo, o en el evento Load del formulario, establece con el método SetToolTip, el texto a cada elemento que quieras que el globo muestre al pasar el ratón por encima.

Añade un sintetizador

Create una referencia a la librería System.Speech desde el menú Proyecto e importarlo dentro de la clase de tu interfaz.

Declara un objeto de tipo "SAPI.spvoice" y, con las propiedades volume, rate y speak, tienes que conseguir que cuando el usuario pase el ratón por cualquiera de los elementos de la interfaz, el sintetizador de voz del sistema reproduzca el texto del control activo.

Añade un Casilla de Verificación o Checkbox que funcione como un mute, cuando este presionada no escucharemos el sintetizador, mientras que si no está presionada escucharemos la transcripción de los textos.

Recordad que podéis usar la propiedad Handles para añadir controles al evento que necesitáis, para que cuando el usuario pase el ratón por encima del control, no necesitéis definir uno, diez, quince o veinte eventos que llamen a una función o ejecuten el mismo código.

/*declaracion del audio ayuda*/
    Dim audioAyuda = CreateObject("sapi.spvoice")
    /*boleano para silenciar la autoayuda*/
    Private activo As Boolean
/*audio ayuda, al pasar por encima leera lo que esta escrito o para que sirve.*/
    Private Sub blablabla_MouseEnter(sender As Object, e As EventArgs) Handles blablabla.MouseEnter
        audioAyuda.speak("Al hacer click oiras aquí lo que has escrito")
    End Sub
    Private Sub BtnSilenciar_MouseEnter(sender As Object, e As EventArgs) Handles BtnSilenciar.MouseEnter
        audioAyuda.speak("Este boton silencia la voz de ayuda")
    End Sub
    Private Sub cTexto_MouseEnter(sender As Object, e As EventArgs) Handles cTexto.MouseEnter
        audioAyuda.speak("Aqui debes introducir el texto")
    End Sub
    Private Sub ltitulo_MouseEnter(sender As Object, e As EventArgs) Handles ltitulo.MouseEnter
        audioAyuda.speak("Sintetizador version 1")
    End Sub
    Private Sub lVelocidad_MouseEnter(sender As Object, e As EventArgs) Handles lVelocidad.MouseEnter
        audioAyuda.speak("Velocidad")
    End Sub
    Private Sub lVolumen_MouseEnter(sender As Object, e As EventArgs) Handles lVolumen.MouseEnter
        audioAyuda.speak("Volumen")
    End Sub
    Private Sub TrackVelocidad_MouseEnter(sender As Object, e As EventArgs) Handles TrackVelocidad.MouseEnter
        audioAyuda.speak("Puedes subir o bajar la velocidad de la voz")
    End Sub
    Private Sub TrackVolumen_MouseEnter(sender As Object, e As EventArgs) Handles TrackVolumen.MouseEnter
        audioAyuda.speak("Puedes subir o bajar el volumen de la voz")
    End Sub
    /* fin audio ayuda*/

Puedes descargar el código aquí

Idiomas en Visual Basic

Create un archivo de texto plano en el que añadirás todos los mensajes de la aplicación y cuyo nombre estará relacionado con el idioma y separa los mensajes con el carácter ":".

El fichero estará ubicado en la misma subcarpeta en la que se ejecuta la aplicación, y por tanto ésta buscará directamente en ella al inicio de la ejecución de la aplicación.

Cuando lo tengas listo, añade, dentro de la clase del formulario de uno de tus ejercicios un evento de tipo load, tratando de que cada control obtenga los textos y los tooltips directamente del fichero. También, en caso que los utilices, cualquier mensaje de error o mensaje que proporciones al usuario.

Private Sub Form1_Load(sender As Object, e As EventArgs) Handles Me.Load
        leerFichero()
    End Sub
    Private Sub leerFichero()
        Dim fichero As String = My.Computer.FileSystem.ReadAllText("es.txt")
        Dim cadena As String() = fichero.Split(":")
        Me.Text = cadena.GetValue(0)
        LblInserte.Text = cadena.GetValue(1)
        BtnCalcular.Text = cadena.GetValue(2)
        BtnLimpiar.Text = cadena.GetValue(3)
        Label1.Text = cadena.GetValue(4)
    End Sub

En este caso, leemos el archivo, los nombres de los elementos están separados por : y en getvalue se les da la posición en el que se encuentran en el documento. 

Puedes descargarte el código aquí.

Hay otros metodos de hacer lo mismo, como puedes ver aquí

Propiedad UseSystemPasswordChar

Cuando el usuario esté introduciendo su contraseña, bien en el registro bien en el acceso, la clave estará oculta por puntos o cualquier otro carácter, pero has de ingeniártelas con una manera para que el usuario pueda, en un momento dado, ver la contraseña:

Cuando pase el ratón por encima del control que utilices el usuario verá su texto en claro en la misma caja o en un tooltip.

Un botón, justo a la derecha del control que al hacer clic cambiará a visible o no visible la propiedad que permite ver los caracteres introducidos.

TextBox.UseSystemPasswordChar (Propiedad) obtiene o establece un valor que indica si el texto del control TextBox debe aparecer como el carácter de contraseña predeterminado. true si el texto del control TextBox debería aparecer como el carácter de contraseña predeterminado; de lo contrario, false.

Puedes descargarte la interfaz aqui

Método 1, crea un botón junto al textBox de la contraseña. Al dar al botón se vera o escondera el contenido.

Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
        If txtContrasena.UseSystemPasswordChar = True Then
            txtContrasena.UseSystemPasswordChar = False
        Else
            txtContrasena.UseSystemPasswordChar = True
        End If
    End Sub

Método 2 que cada vez que pase el puntero sobre el textBox se vea el contenido.

Private Sub txtContrasenaNueva_MouseEnter(sender As Object, e As EventArgs) Handles txtContrasenaNueva.MouseEnter
        If txtContrasenaNueva.UseSystemPasswordChar = True Then
            txtContrasenaNueva.UseSystemPasswordChar = False
        Else
            txtContrasenaNueva.UseSystemPasswordChar = True
        End If
    End Sub
    Private Sub txtConfirmeContrasena_MouseEnter(sender As Object, e As EventArgs) Handles txtConfirmeContrasena.MouseEnter
        If txtConfirmeContrasena.UseSystemPasswordChar = True Then
            txtConfirmeContrasena.UseSystemPasswordChar = False
        Else
            txtConfirmeContrasena.UseSystemPasswordChar = True
        End If
    End Sub

Administración Informatica

Tenemos que diseñar una interfaz de acceso a un software empresarial.

La interfaz habrá de contener, al menos, tres pantallas:

1. Acceso o login
2. Registro
3. Recordatorio de o nueva clave

El usuario necesitará su login y su clave para acceder al sistema.

El usuario necesitará especificar, para el registro, su:

1. Nombre completo
2. Login
3. Clave repetida
4. Fecha de nacimiento
5. Sexo
6. Móvil
7. Correo electrónico
8. Sucursal desde dónde se conecta; España, California, Berlín, Austin o Wellington

Genera el caso de uso de la interfaz, en papel, para la siguiente secuencia de acciones:

• El usuario accede a la aplicación
• El usuario se registra en la aplicación
• El usuario solicita su nueva clave de acceso
• El usuario se logea en la aplicación

Puedes ver el vídeo aquí y acceder a la interfaz (solo interfaz) aquí