Seguidores

MIS WEBS



Mostrando entradas con la etiqueta catch. Mostrar todas las entradas
Mostrando entradas con la etiqueta catch. Mostrar todas las entradas

martes, 17 de abril de 2018

Leer archivos de texto con java


SECUENCIAS O FLUJO DE DATOS (Streams)



¿Para que se utilizan las secuencias o Streams?


Lo utilizaremos para realizar transferencias de datos, leer o escribir archivos externos o internos. Con los conocimientos adquiridos hasta el momento tan solo podíamos guardar nuestros datos en un array (matriz) o en una variable, pero cuando nuestro programa finaliza esta información desaparece.
Lo que deseamos hacer ahora es almacenar o leer información en archivos que no sean temporales. Si lo que deseamos es almacenar la información tendremos que acceder a un dispositivo físico (disco duro, memoria externa, USB, CD, dispositivo móvil, tarjeta SD…) Para realizar esto vamos a necesitar las frecuencias o flujo de datos.





FORMAS DE ABORDAR LOS STREAMS


Existen dos tipos de flujos de datos Flujo de bytes y Flujo de caracteres. Todas las clases que hacen referencia al flujo de datos pertenecen al paquete Java.IO.

Flujo de bytes:

Utilizaremos bytes para almacenar los datos. Si deseamos crear un comprimido y mandarlo para luego decodificarlo.
Utilizaremos las clases abstractas, por lo que tendremos que sobrees cribir sus métodos.
·         InputStream (para leer)
·         OutputStream(trasmitir)

Flujo de caracteres:


Utilizaremos caracteres o letras para guardar los datos. Lo utilizaremos cunado el archivo puede ser leído por el usuario.
Utilizaremos las clases abstractas, por lo que tendremos que sobreescribir sus métodos.
·         Reader (leer)
·         Writer (escribir).

Leer archivos de texto



En primer lugar decir que para leer un archivo tenemos que seguir siempre tres paso básicos:
1.       Abrir el archivo
2.       Leerlo
3.       Cerrarlo




Para leer archivos de texto necesitaremos utilizar instancias de la clase FileReader y como desciende de la clase abstracta Reader que a su vez desciende de IOException nos obligará a realizar un try/catch
class leeme{
       public void leenos() {
try {
FileReader entrada = new FileReader("C:\\Users\\x\\Desktop\\z/Prueba lectura.txt");
             } catch (FileNotFoundException e) {
                   
System.out.println("Mira si el archivo se encuentra en su sitio, no veo nada");
                    e.printStackTrace();
             }     
       }     
}



Una vez localizado el fichero utilizaremos el método read() para leer dentro de él. Este método también nos exige un try/catch. El método read() nos regresa número enteros que son los caracteres unicodes de cada unas de las letras y cuando llega al final del fichero nos regresa       -1.

Por lo que si le decimos que hasta que read()= -1 siga recorriendo iremos desde principio al fin del texto. Esto hará que se imprima en consola los caracteres unicodes que pertenecena cada una de las letras.

class leeme{
       public void leenos() {
             FileReader texto;
             try {//abrimos comunicación (Stream)
                    texto = new FileReader("C:\\Users\\dagip\\Desktop\\ddddddddddd/Prueba lectura.txt");
                   
                    while (texto.read()!= -1) {//leemos
                    System.out.println (texto.read());
                    }
             } catch (IOException e) {
System.out.println("Mira si el archivo se encuentra en su sitio porque yo no lo veo");
                    e.printStackTrace();
             }
       }




Ahora lo que aremos es transformar esos numero que corresponden al carácter Unicode a letras (char). Para ello realizaremos un casting a esos caracteres
class leeme{
       public void leenos() {
             FileReader texto;
             try {//abrimos comunicación (Stream)
                    texto = new FileReader("C:\\Users\\dagip\\Desktop\\ddddddddddd/Prueba lectura.txt");
                    int c = texto.read();
                    while (c!= -1) {//leemos archivo 
                           char letraActual = (char)c;
                    System.out.print (letraActual);
                    c=texto.read();
                    }
             } catch (IOException e) { 
System.out.println("Mira si el archivo se encuentra en su sitio porque yo no lo veo");
                    e.printStackTrace();
             }
       }     
}

Ahora cerraremos el archivo .
       public void leenos() {
             FileReader texto;
             try {//abrimos comunicación (Stream)
       texto = new FileReader("C:\\Users\\t\\Desktop\\v/Prueba lectura.txt");
                    int c = texto.read();
                    while (c!= -1) {//leemos archivo 
                           char letraActual = (char)c;
                    System.out.print (letraActual);
                    c=texto.read();
                    }//cerramos archivo
                    texto.close();
             } catch (IOException e) {
System.out.println("Mira si el archivo se encuentra en su sitio porque yo no lo veo");
                    e.printStackTrace();
             }     
       }
}

Así sería nuestro código completo:


import java.io.*;
public class Lectura1 {
       public static void main(String[] args) {
             leeme lee = new leeme();
             lee.leenos();
       }
}
class leeme{
       public void leenos() {
             FileReader texto;
             try {//abrimos comunicación (Stream)
                    texto = new FileReader("C:\\Users\\v\\Desktop\\v/Prueba lectura.txt");
                    int c = texto.read();
                    while (c!= -1) {//leemos  
                           char letraActual = (char)c;
                    System.out.print (letraActual);
                    c=texto.read();
                    }//cerramos archivo
                    texto.close();
             } catch (IOException e) {
System.out.println("Mira si el archivo se encuentra en su sitio porque yo no lo veo");
                    e.printStackTrace();
             }     
       }     
}


viernes, 13 de abril de 2018

Lanzar excepciones con Java


Control Errores java

Diferencia entre throw y throws


La clausula throws la utilizaremos para crear un método que pueda tener una excepción.


Public Static Método(parametros) throws IOExceptions{
try{ 
//Código en caso de que el método funcione
}catch(IOException e){
//Código en caso de error en el método

  }
}
La clausula throw la utilizaremos para lanzar una excepción en un punto determinado del programa para controlar un determinado error que no deseamos que se cometa. Con ello conseguiremos que si el programa no cumple con lo que deseamos se caiga, podemos escoger una que exista o crearla nosotros mismos.

En el siguiente ejercicio le decimos que si el numero que introduzcamos e mayor a cien se caiga nuestro programa con un error ArrayIndexOutOfBoundsException.

public class UsoDeThrow {

       public static void main(String[] args) {

   int numero=Integer.parseInt(JOptionPane.showInputDialog("introduce número entre 0 y 100"));
            
             if(numero>100) {
                    throw new ArrayIndexOutOfBoundsException();
             }else {                   
                    System.out.println(numero);
             }
            
       }





COMO CREAR NUESTRAS EXCEPCIONES


La verdadera utilidad que puede tener el lanzar excepciones propias con throw es crear nuestro propios errores porque no siempre nos valen los creados por defecto.  A demás nos permite crear nuestro propios errores que identificaremos más fácil mente. Creariamos una clase que herede de la que mejor nos venga:
·         IOException en caso de que sean excepciones comprobadas.
·         RuntimeException en caso de que sea un error no comprobado.

public class UsoDeThrow {

         public static void main(String[] args) {

numero=Integer.parseInt(JOptionPane.showInputDialog("introduce número entre 0 y 100"));
                   if(numero>100) {
throw new ErrorExcesoNumero("el numero introducido ha de estar comprendido entre 0 y 100");
                   }else {
                            System.out.println(numero);
                   }       
         }
}

 class ErrorExcesoNumero extends RuntimeException{
        
         public ErrorExcesoNumero() {}
         public ErrorExcesoNumero(String texto_error) {
                   super(texto_error);
         }       
}



El error nos saldría así por la ventana de inmediato, tal y como podéis comprobar el texto del error es el que le hemos indicado algo que nos puede facilitar infinitamente el trabajo:
Exception in thread "main" ErrorExcesoNumero: el numero introducido ha de estar comprendido entre 0 y 100
       at UsoDeThrow.main(UsoDeThrow.java:12)






En el siguiente caso deseamos tener un texto impreso en consola y nuestro fallo, para ello crearemos un método que utilice nuestro error

import javax.swing.JOptionPane;
public class UsoDeThrow {
        public static void main(String[] args) {  numero=Integer.parseInt(JOptionPane.showInputDialog("introduce número entre 0 y 100"));
                try {
                        EsteError();
                        System.out.println(numero);
                } catch (ErrorExcesoNumero e) {
     System.out.println("Error al introducir datos en el JOptionPane\n");
                        e.printStackTrace();
                }
                       
        }
        static int numero;
        public static void EsteError() throws ErrorExcesoNumero{
                if(numero>100) {                              
throw new ErrorExcesoNumero("el numero introducido ha de estar comprendido entre 0 y 100");
        }
}
        }
        class ErrorExcesoNumero extends Exception{
               
                public ErrorExcesoNumero() {}
                public ErrorExcesoNumero(String texto_error) {
                        super(texto_error);
                }
        }


Nos aparecerá en Consola:
Error al introducir datos en el JOptionPane
ErrorExcesoNumero: el numero introducido ha de estar comprendido entre 0 y 100

       at UsoDeThrow.EsteError(UsoDeThrow.java:25)
       at UsoDeThrow.main(UsoDeThrow.java:12)










Métodos de la clase error:

getMessage(): Nos indica el dato que comete el error
getClass() . getName():  nos indica la clase que lanza el error

Por lo que esto nos permite jugar con los tipos de errores de una forma más amplia.


public static void main(String[] args) {
             int num,divid, resultado;
             num=500000000;
             divid=-2;
             resultado = num*divid;
             System.out.println(resultado);         
numero=Integer.parseInt(JOptionPane.showInputDialog("introduce número entre 0 y 100"));
             tryEsteError();
                    System.out.println(numero);
             } catch (ErrorExcesoNumero e) {
System.out.println("Error al introducir el numero  "  +numero+ " en el JOptionPane : "+ e.getMessage());

System.out.println("Es te error pertenece a la clase: "+e.getClass().getName());
                    //e.printStackTrace();
             }           

       }



El mensaje en consola sería el siguiente:

-1000000000
Error al introducir el numero  250 en el JOptionPane : el numero introducido ha de estar comprendido entre 0 y 100
Es te error pertenece a la clase: ErrorExcesoNumero




Eclipse posee su depurador de errores si quereis ver como funciona
pulsar aquí



Buscar este blog

Sandisk y Western Digital