[Metodos] Determinar Sistema y propiedades

La Clase System de Java

Una de las mayores ventajas de java es que es multiplaforma, es decir corre sobre una maquina virtual que esta disponible para varios sistemas operativos.
Pero trabajar con varios sistemas tiene sus pequeñas diferencias, como por ejemplo las rutas especifícas de archivos:

  • en windows son "C:\user\texto.txt"
  • en linux son "\user\docs\texto.txt"
  • etc

Para determinar que sistema operativo se esta usando, podemos hacer uso del metodo:

  • public static String getProperty(String key)
  • Obtiene la propiedad del sistema indicada por el argumento especificado en el parametro.
    En primer lugar, si hay un controlador de seguridad, su método checkPropertyAccess() se llamará con el valor del parámetro como su propio argumento. Esto puede resultar en un SecurityException.
    Si no hay un conjunto actual de las propiedades del sistema, estas se crearán por primera vez y se inicializa de la misma manera que para el método getProperties().
  • Parámetros:
  • String key - Cadena de texto con el valor de una de las propiedades que queremos solicitar.
  • Devuelve:
  • String - Otra cadena de texto con el valor de la propiedad.
  • Arroja:
  • SecurityException - si existe un administrador de seguridad y su método checkPropertyAccess no permite el acceso a la propiedad del sistema especificado.
    NullPointerException - si la clave es nula.
    IllegalArgumentException - si la clave está vacía.
    NOTA: Hemos de notar que la firma por si sola no arroja excepciones, sino las llamadas en su interior las provocan, no es necesario tratarlas con un try-cath

Para mostrar por pantalla cual es la version del sistema operativo que estamos usando bastará con:

1
2
String sistemaOperativo = System.getProperty("os.name");
System.out.println(sistemaOperativo);

Para guardar por ejemplo un archivo de texto, dependiendo del sistema operativo podriamos hacer:(Solo funciona para windows y linux)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
String osName = System.getProperty("os.name");
String rutaEspecifica;

if(osName.contains("Windows")){
    rutaEspecifica = "C:/blog/texto.txt"
}else{
    rutaEspecifica = "/usr/texto.txt"
}

LeerEscribir.guardarTXT(props2String(), rutaEspecifica);

El método guardarTXT lleva como primer parámetro el texto a guardar, y su segundo es la ruta donde lo deja finalmente. El método props2String() lo defeni siguiendo las 28 de propiedades que nos brinda la documentacion oficial de Java:

java.version Version del JRE (Java Runtime Environment)
java.vendor Fabricante de la JRE
java.vendor.url Enlace web del fabricante de la JRE
java.home Direccion de instalación de Java
java.vm.specification.version Versión especifica de la JMV
java.vm.specification.vendor Nombre especifico del fabricante de la JMV
java.vm.specification.name Nombre especifico de la JMV
java.vm.version Version de implementación de la JMV
java.vm.vendor Nombre del fabricante de la implementación de la JMV
java.vm.name Nombre de la implementación de la JMV
java.specification.version Versipon específica de JRE
java.specification.vendor Nombre especifico del fabricante
java.specification.name nombre de la especificacion de java
java.class.version Numero de version del formato de clase
java.class.path ruta de la clase de java
java.library.path Lista de ruta para buscar cuando se cargan librerias
java.io.tmpdir Ruta por defecto para archivos temporales
java.compiler Version del compilador java
java.ext.dirs Ruta de extensión de directorio, o de directorios
os.name Nombre del sistema
os.arch Arquitectura del sistema
os.version Versión del sistema
file.separator Separador de archivos(Gral / o \ )
path.separator Separador de rutas(Gral . o ; )
line.separator Separador de lineas (Gral \n )
user.name Nombre de usuario
user.home Directorio raiz del usuario
user.dir Directorio de trabajo actual del usuario.

en No hay comentarios:
Etiquetas:

[Metodos] Comprimir/Descomprimir un archivo ZIP (Parte II)

Descomprimir un archivo ZIP

Para descomprimir un Fichero ZIP(Puede ser rar) vamos a hacer uso de las siguientes clases java:
  1. Empezamos creando un objeto de la clase FileInputStream:
    • public FileInputStream(String name) throws FileNotFoundException
    • Crea un FileInputStream abriendo una conexión con un archivo real, el archivo viene dado por su ruta en el sistema.
      Un nuevo objeto FileDescriptor se crea para representar a este respecto archivo. En primer lugar, si hay un controlador de seguridad, su método checkRead(String name) se llama con el argumento dado como su propio argumento.
      Si no existe el archivo llamado, es un directorio en lugar inalcanzable, o por alguna otra razón no se pueden abrir para leer a continuación, un FileNotFoundException es lanzada.
    • Parámetros:
    • String name - Cadena de texto con la ruta el archivo Zip a descomprimir(Tiene que existir)
    • Arroja:
    • FileNotFoundException - si no existe el archivo, es un directorio sin permisos para java, o por alguna otra razón no se pueden abrir para la lectura.
      SecurityException - si existe un administrador de seguridad y su método checkRead() niega el acceso de lectura al archivo.

  2. Luego crearemos el objeto ZipInputStream, pasando como parámtro el FileInputStream creado anteriormente:
    • public ZipInputStream(InputStream in)
    • Crea un nuevo ZIPinput stream.
      La codificación UTF-8 es usadad para decodificar la entrada de nombres.
    • Parámetros:
    • InputStream in - Pasamos el FileInputStream, clase hija de InputStream.

  3. Creamos el objeto ZipEntry sin instanciarlo. Lo usaremos para ir obteniendo cada archivo que contenga el ZIP existente.

  4. Creamos un ciclo While, para ir recorriendo todo el contenido del ZIP. La condicion, será que el objeto ZipInputStream a través de su método "getNextEntry()" va a ir obteniendo los archivos comprimidos hasta ser nulo.
    • public ZipEntry getNextEntry() throws IOException
    • Lee la siguiente entrada del archivo ZIP y posiciona el flujo(Stream) al comienzo de los datos de entrada.
    • Devuelve:
    • Un objeto ZipEntry que es la siguiente entrada del archivo de ZIP, o "null" si no hay más entradas.
    • Arroja:
    • ZipException - si se ha producido un error de archivo ZIP
      IOException - si se ha producido un error de E / S

  5. En este punto, obtendremos todos los archivos comprimidos que contenga el ZIP. Los descomprimiremos con FileOutputStream
    • public FileOutputStream(String name) throws FileNotFoundException
    • Crea un flujo de salida de archivo para escribir en el archivo con el nombre especificado. Un nuevo objeto FileDescriptor se crea para representar a este respecto archivo.
      En primer lugar, si hay un controlador de seguridad, su método checkWrite(String name) se denomina con el nombre como el argumento dado.
      Si el archivo existe, pero es un directorio que java no puede acceder, o no existe, pero no se puede crear, o no se puede abrir por cualquier otra razón, entonces un FileNotFoundException es lanzada.
    • Parámetros:
    • String name - Cadena de texto con la ruta específica, para lo cual le pedimos a el objeto ZipEntry su nombre: "entrada.getName()"
    • Arroja:
    • FileNotFoundException - si el archivo existe, pero es un directorio en lugar sin acceso, o no existe, pero no se puede crear, o no se puede abrir por cualquier otra razón.
      SecurityException - si existe un administrador de seguridad y su método checkWrite niega el acceso de escritura al archivo.

  6. Ahora, ZipInputStream ira descomprimiendo a través de un metodo heredado de FilterInputStream read(byte[] b), para el cual crearemos previamente un array de byte con el tamaño que deseamos que será la dimensión de la lectura, y este método devuelve un entero (int) que almacenaremos en otra variable que crearemos también:
    • public int read(byte[] b) throws IOException
    • Lee hasta la longitud del array bytes dado por parámtro de esta entrada.
      Este método se bloquea hasta que alguna entrada está disponible.
      Este método simplemente realiza la llamada a read(b, 0, b.length) y devuelve el resultado. Es importante que no hace in.read(b) en su lugar; ciertas subclases de FilterInputStream dependen de la estrategia de aplicación efectivamente a utilizarse.
    • Parámetros:
    • byte[] b - Un buffer dentro del cual la informacion es leida.
    • Devuelve:
    • int entero - Un entero que es el número total de bytes leídos en la memoria intermedia, o menos uno (-1) si no hay más datos debido a que el final de la secuencia ha sido alcanzado. Este retorno lo almacenamos en una variable del tipo intenger.
    • Arroja:
    • IOException - Si un erro de Entrada/Salida occure.

  7. Para todas las lecturas del ZipInputStream, Dentro de un ciclo While, donde la condicion sea que siga habiendo datos, es decir el resultado del método debe ser mayor a cero, El FileOutputStream ira escribiendo con su método:
    • public void write(byte[] b,
      int off,
      int len)
      throws IOException
    • Escribe el tamaño dado en "len" de bytes en el array de bytes especificado comenzando en el desplazamiento fuera de este FileOutputStream.
    • Parámetros:
    • byte[] b - los datos.
      int off - el desplazamiento inicial de los datos.
      int len - el número de bytes para escribir.
    • Arroja:
    • IOException - Si un erro de Entrada/Salida occure.

  8. Procedemos a cerrar el FileOutputStream y el ZipInputStream con sus métodos close() y closeEntry() respectivamente.

  9. Ahora estamos listos para hacer lo que fuere con el archivo descomprimido, con la ruta:
    • entrada.toString();
    • Al final del while, deberemos cerrar el stream de ZipInputStream con su método close().

Mi pseudoCodógido es:

FileInputStream fis = new FileInputStream(nombreZip);

ZipInputStream zis = new ZipInputStream(fis);



ZipEntry entrada;

while (null != (entrada = zis.getNextEntry())) {

 FileOutputStream fos = new FileOutputStream(entrada.getName());


 
 int leido;

 byte[] buffer = new byte[1024];

 while (0 < (leido = zis.read(buffer))) {

  fos.write(buffer, 0, leido);

 }

 fos.close();

 zis.closeEntry();


 
 //TODO manejar archivo

}

zis.close();

Para mi ejemplo, tenia el archivo de texto, que se maneja con las clases File, FileReader y BufferedReader, comprimido en zip para descomprimir y ese archivo de texto se muestra por pantalla con un metodo creado llamado: leerTXT(String rutaEspecifica)
Contenido en un método para ser llamado podria ser:

 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
public static void mostrarZIP(String archivo, String nombreZip) {
    try {
        FileInputStream fis = new FileInputStream(nombreZip);
        ZipInputStream zis = new ZipInputStream(fis);

        ZipEntry entrada;
        while (null != (entrada = zis.getNextEntry())) {
            System.out.println(entrada.toString());
            if (entrada.toString().contains(archivo)) {
                FileOutputStream fos = new FileOutputStream(entrada.getName());

            int leido;
            byte[] buffer = new byte[1024];
            while (0 < (leido = zis.read(buffer))) {
                fos.write(buffer, 0, leido);
            }
            fos.close();
            zis.closeEntry();
            LeerEscribir.leerTXT(entrada.toString());
            }
        }
        zis.close();
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Donde la clase LeerEscribir y el metodo leerTXT es del post [Metodos] Leer y Escribir un archivo de texto. 


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public static void leerTXT(String rutaEspecifica) {
    String cadena;
    File archivo = new File(rutaEspecifica);
    if (archivo.exists()) {
        try {
            FileReader fr = new FileReader(archivo);
            BufferedReader br = new BufferedReader(fr);

            while ((cadena = br.readLine()) != null) {
                System.out.println(cadena);
            }

            br.close();
            fr.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    } else {
        System.err.println("El sistema no pudo hallar la ruta especifica.");
    }
}

Una llamada a este método, que no tiene que ser de clase, podria ser:

mostrarZIP("C:\\blog\\archivoTexto.txt", "C:\\blog\\mizipExistente.zip");
en No hay comentarios:
Etiquetas:

[Metodos] Comprimir/Descomprimir un archivo ZIP

Comprimir un archivo ZIP

Para comprimir un Fichero ZIP(Puede ser rar) vamos a hacer uso de las siguientes clases java:
  1. Lo primero es tener nuestro objeto "File":
    • public File(String pathname)
    • Crea una nueva instancia de un objeto archivo(File) con la ruta pasada por parámetro.
    • Paramétros
    • String pathName - una cadena con la ruta donde deberia estar nuestro archivo a comprimir.
    • Arroja:
    • NullPointerException - Si el parametro del argumento es nulo

  2. Luego, clase File se encargara de comprobar realmente si existe o se puede acceder al archivo a comprimir a través del método:
    • public boolean exists()
    • Comprueba si existe el archivo o directorio indicado por esta vía de acceso abstracta.
    • Retorna:
    • verdadero si y sólo si existe el archivo o directorio indicado por esta vía de acceso abstracta; false en caso contrario
    • Arroja:
    • SecurityException - Si existe un administrador de seguridad y su método SecurityManager.checkwRite (java.lang.String) niega el acceso de lectura al archivo o directorio

  3. Pasamos a crear un objeto de FileOutputStream:
    • public FileOutputStream(String name) throws FileNotFoundException
    • Crea un flujo de salida de archivo(FileOutputStream) para escribir en el archivo con el nombre especificado por parámetros. Un nuevo objeto "FileDescriptor" se crea para representar la conección a este archivo.
      En primer lugar, si hay un controlador de seguridad, su método checkWrite() es llamado con el nombre como su argumento.
      Si el archivo existe, pero es un directorio inalcanzable para un archivo normal, o no existe, pero no se puede crear, o no se puede abrir por cualquier otra razón, entonces un FileNotFoundException es lanzada.
    • Paramétros:
    • String name - El nombre con la ruta donde deberia dejarse el archivo ZIP que vamos a crear
    • Arroja:
    • FileNotFoundException - si el archivo existe, pero es un directorio en lugar inalcanzable, o no existe, pero no se puede crear, o no se puede abrir por cualquier otra razón.
      SecurityException - si existe un administrador de seguridad y su método checkWrite() niega el acceso de escritura al archivo.

  4. Ahora crearemos el flujo de salida para el archivo ZIP, la clase ZipOutputStream:
    • public ZipOutputStream(OutputStream out)
    • Crea un nuevo ZIP output stream.
      TLa codificacion UTF-8 es usada para los nombres de las entradas y comentarios.
    • Parámetros:
    • OutPutStream out - Un objeto de la clase padre OutPutStream, o sus clases hija, como el objeto creado recientemente FileOutputStream.

  5. En este momento, procedemos a añadir los archivos, tantos como sean necesarios, al archivo ZIP mediante la clase ZipEntry:
    • public ZipEntry(String name)
    • Crea una nueva entrada al con la ruta del archivo pasado por parámetro.
    • Parámetros
    • String name - Una cadena con la ruta del archivo que queremos añadir para comprimir. Este va a ser el nombre interno dentro de la compresion, no tiene porque coincidir con el de fuera. Tambien podemos incluirlo dentro de una carpeta separando con barras.
    • Arroja:
    • NullPointerException - si el nombre de la entrada es nulo.
      IllegalArgumentException - si el nombre de la entrada es mayor que 0xFFFF bytes

  6. Ahora es el objeto ZipOutputStream quien llamara a su metodo putNextEntry con el objeto ZipEntry creado recientemente:
    • public void putNextEntry(ZipEntry e) throws IOException
    • Se pone a escribir una nueva entrada de archivo ZIP y posiciona al comienzo de la entrada. Cierra la entrada actual si todavía está activo. El método de compresión por defecto se utiliza sino se especifica ningún método de compresión para la entrada, y se utilizará la hora actual si la entrada no tiene tiempo de modificación configurada.
    • Parámetros:
    • ZipEntry e - La entrada ZIP para ser escrita.
    • Arroja:
    • ZipException - si se ha producido un error de formato ZIP
      IOException - si se ha producido un error de E / S

  7. El siguiente paso será crear un flujo de entrada de archivo: (FileInputputStream):
    • public FileInputStream(String name) throws FileNotFoundException
    • Crea un FileInputStream abriendo una conexión con un archivo real, el archivo esta denominado por el nombre de ruta de acceso en el sistema de archivos por la cadena pasada por parámetro.
      Un nuevo objeto FileDescriptor se crea para representar a este respecto archivo.
      En primer lugar, si hay un controlador de seguridad, su método checkRead() se llama con el argumento de nombre como su argumento.

      Si no existe el archivo llamado, es un directorio en lugar de un archivo normal, o por alguna otra razón no se pueden abrir para leer a continuación, un FileNotFoundException es lanzada.
    • Parámetros:
    • String name - cadena con el la ruta del archivo a comprimir.
    • Arroja:
    • FileNotFoundException - si el archivo existe, pero es un directorio en lugar inalcanzable, o no existe, pero no se puede crear, o no se puede abrir por cualquier otra razón.
      SecurityException - si existe un administrador de seguridad y su método checkWrite() niega el acceso de escritura al archivo.

  8. El objeto FileInputStream, el cual tiene seteado el archivo a comprimir, ira leyendolo a través de un método el cual recibe por parámetro un array de byte que crearemos para indicarle el tamaño a leer, 1024 bastara:
    • public int read(byte[] b) throws IOException
    • Lee hasta la longitud del array de bytes(dado por parámetro) de este flujo de entrada(objeto FileInputStream).
      Este método se bloquea hasta que alguna entrada está disponible.
    • Parámetros:
    • byte[] b - Un array de byte(que crearemos previamente) para obtener la longitud deseada.
    • Devuelve:
    • int (un entero)- Es el número total de bytes leídos en la memoria intermedia, ó (-1)menos uno si no hay más datos debido a que el final del archivo ha sido alcanzado.
    • Arroja:
    • IOException - Si ocurre algun error de entrada/Salida.

  9. El número devuelto por el metodo anteriormente utilizado (read(byte[] b )), lo almacenaremos en una variable del tipo intenger(int). Este sera usado para evaluar cuando se alcanza el final del archivo al pasar a menos uno (-1). Mientras sea un numero mayor el ZipOutputStream podra ir escribiendo el zip con el archivo deseado.

  10. Entonces ZipOutputStream ira escribiendo dentro del ciclo while con su método:

  11. Por ultimo, ir cerrando todos objetos instanciados con su metodo close().
Mi PseudoCódigo seria algo asi:
File aZipear = new File(archivo);

if (aZipear.exists()) { 

 FileOutputStream fos = new FileOutputStream(nombreZip);

 ZipOutputStream zos = new ZipOutputStream(fos);


 
 ZipEntry entradaZIP = new ZipEntry("subcarpeta/texto.txt");

 zos.putNextEntry(entradaZIP);


 
 FileInputStream fis = new FileInputStream(archivo);



 byte[] buffer = new byte[1024];

 int leido = 0;

 while (0 < (leido = fis.read(buffer))) {

  zos.write(buffer, 0, leido);

 } 



 fis.close();

 zos.closeEntry();

 zos.close();

 fos.close();


 
 System.out.println("Archivo zip creado exitosamente!");

}
Método para ser llamado(puede ser estatico o no)

 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
public static void guardarZIP(String archivo, String nombreZip) {
    File aZipear = new File(archivo);
    if (aZipear.exists()) {
    try {
        FileOutputStream fos = new FileOutputStream(nombreZip);
        ZipOutputStream zos = new ZipOutputStream(fos);
   
        ZipEntry entradaZIP = new ZipEntry("subcarpeta/texto.txt");
        zos.putNextEntry(entradaZIP);
        FileInputStream fis = new FileInputStream(archivo);
  
        byte[] buffer = new byte[1024];
        int leido = 0;
        while (0 < (leido = fis.read(buffer))) {
            zos.write(buffer, 0, leido);
        }

        fis.close();
        zos.closeEntry();
        zos.close();
        fos.close();

        System.out.println("Archivo zip creado exitosamente!");

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    } else {
        System.err.println("El archivo a comprimir no existe!");
    }
}
Una posible llamada podria ser:
guardarZIP("C:\\blog\\archivoTexto.txt", "C:\\blog\\mizip.rar");
en No hay comentarios:
Etiquetas:

[Metodos] Manejo de URLs

Manejo de una URL:

Para manejar urls hacemos uso de 5 clases java, de los paquetes "io" y "net":
  1. En primer lugar creamos el objeto de la clase URL con su constructor, pasando por parametro el enlace:

  2. En segundo lugar, creamos un objeto de la abstracta URLConnection, la cual se instancia desde el objeto URL creado anteriormente que llama al siguiente método que devuelve un objeto URLConnection:
    • public URLConnection openConnection() throws IOException
    • Devuelve una instancia de un objeto URLConnection que "representa" una conexión con el objeto remoto que hace referencia la URL. Una nueva instancia de URLConnection se creará cada vez que se invoca el método URLStreamHandler.openConnection (URL) del controlador de protocolo para esta URL. Cabe señalar que una instancia de URLConnection no establece la conexión de red real en la creación. Esto sucederá solamente al llamar URLConnection.connect () que será el paso siguiente.
    • Devuelve
    • un objeto URLConnection con el enlace de la URL.
    • Arroja
    • IOException - si una I/O exception occure.

  3. Establece la conexión de red real de la instacia de URLConnection con el método:
    • public abstract void connect() throws IOException
    • Abre un enlace de comunicaciones con el recurso al que hace referencia este URL, si no ha sido ya establecido una conexión de este tipo. Si el método de conexión se llama cuando ya se ha abierto la conexión (indicado por el campo relacionado con el valor verdadero), se ignora la llamada.
    • Arroja:
      • SocketTimeoutException - si el tiempo de espera se agota antes de poder establecer la conexión
      • IOException - si se produce un error de E / S directa al abrir la conexión.

  4. Crearemos una instancia de la clase abstracta InputStrem, para lo cual la instancia de URLConnection llamara al metodo que devuelva un InputStrem
    • public InputStream getInputStream() throws IOException
    • Devuelve un InputStream que lee de esta conexión abierta. Un SocketTimeoutException puede ser lanzado durante la lectura del documento de entrada devuelto si el tiempo de espera para leer expira antes de que se dispone de datos para lectura.
    • Devuelve
    • un flujo de entrada(instancia InputStream) que lee de esta conexión abierta.
    • Arroja

  5. Crearemos un objeto de la clase InputStreamReader con el constructor:

  6. Seguimos creando un objeto de la clase BufferedReader, con el constructor:
    • public BufferedReader(Reader in)
    • Crea un flujo de caracteres de entrada de búfer que utiliza una memoria intermedia de entrada de tamaño predeterminado.
    • Parámetros
    • Reader in - Al objeto lector de la clase Reader o algun objeto de las clases hijas como InputStreamReader.

  7. Aqui ya podremos leer linea a linea del codigo HTML de una pagina con el metodo de BufferedReader:
    • public String readLine() throws IOException
    • Lee una línea de texto. Se considera que una fila se termina cuando hay cualquier salto de línea ('\ n'), o un retorno de carro ('\ r'), o un retorno de carro seguido inmediatamente por un salto de línea.
    • Devuelve:
    • Una cadena que contiene el contenido de la línea, sin incluir los caracteres de fin de línea, o null si se ha alcanzado el final de la secuencia
    • Arroja:
    • IOException - Si un I/O error occure.
  8. Una manera comun de trabajar, es creando un objeto String que almacenara cada linea, y dentro de un ciclo while, ir iterando cada linea HTML hasta alcanzar el final:
    • String lineaSalida = "";
    • while ((lineaSalida = in.readLine()) != null) {
    •      //TODO hacer algo, ejemplo salida por consola
    • }
  9. La condicion de cierre del ciclo, le pido que el buffer me traiga la siguiente linea para almacenarla en la cadena de texto. Al llegar al final de cualquier codigo sera nulo y dejara de iterar.
  10. Por ultimo, algo muy importante será cerrar el buffer con el metodo close()
Mi pseudo codigo es: 

URL url = new URL(enlace);
URLConnection uc = url.openConnection();
uc.connect();


InputStream is = uc.getInputStream();
InputStreamReader isr = new InputStreamReader(is);
BufferedReader in = new BufferedReader(isr);


String lineaSalida = "";
while ((lineaSalida = in.readLine()) != null) { 
    System.out.println(lineaSalida);
} 
in.close();
Contenido en un metodo para ser llamado(Muestra contenido en consola): 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
public static void mostrarHTML(String enlace){
    try {
        URL url = new URL(enlace);
        URLConnection uc = url.openConnection();
        uc.connect();

        InputStream is = uc.getInputStream();
        InputStreamReader isr = new InputStreamReader(is);
        BufferedReader in = new BufferedReader(isr);

        String lineaSalida = "";
        while ((lineaSalida = in.readLine()) != null) {
            System.out.println(lineaSalida);
        }
        in.close();
    } catch (MalformedURLException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}
Contenido en un metodo para ser llamado(Almacena contenido en un string): 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public static String obtenerHTML(String enlace){
    String cadenaRetorno = "";
    try {
        URL url = new URL(enlace);
        URLConnection uc = url.openConnection();
        uc.connect();

        InputStream is = uc.getInputStream();
        InputStreamReader isr = new InputStreamReader(is);
        BufferedReader in = new BufferedReader(isr);

        String lineaSalida = "";
        while ((lineaSalida = in.readLine()) != null) {
            cadenaRetorno = cadenaRetorno.concat(lineaSalida) + "\n";
        }
        in.close();
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
    }
    return cadenaRetorno;
}

Una forma de llamar a este metodo:

String htmlGoogle = obtenerHTML("https://www.google.com.ar");
en No hay comentarios:
Etiquetas:

[Metodos] Leer y Escribir un archivo de texto. (Parte II)

Escribir archivo de Texto

Para escribir un archivo de texto vamos a hacer uso de 2 clases java:
  1. En primer lugar debemos tener "QUE" es lo que vamos a escribir, ya sea una String, array de Char/String, lista de String, etc.

  2. En segundo lugar, creamos un objeto Filewriter con su constructor:
    • public FileWriter(String fileName) throws IOException
    • Crea un objeto con la ruta especifica donde dejara el archivo de texto. Puede o no existir, si no existe lo creará.
    • Parámetros:
    • String pathname - la ruta especifica donde dejara el archivo.
    • Arroja:
    • IOException - Gralmente si el archivo esta abierto por otro programa y no puede "escribir"
    *Tambien se podria crear un objeto "File" al cual se le deberia pasar el path de salida y ser este objeto pasado como parametro del constructor del FileWriter. Pero es un paso mas.
  3. En tercer lugar crearemos el objeto PrintWriter con su constructor con el objeto creado anteriormente como parametro:
    • public PrintWriter(Writer out)
    • Crea un objeto PrintWriter sin vaciar la linea automaticamente.
    • Parámtro:
    • Un objeto Writer, Calse padre de PrintWriter por lo cual es viable usuarlo.

  4. El objeto PrintWriter llama a su método:
    • public void print(String s)
    • Imprime una cadena. Si el argumento es nulo, la cadena "nula" se imprime. De lo contrario, los caracteres de la cadena se convierten en bytes según la codificación de caracteres por defecto de la plataforma, y estos bytes se escriben exactamente de la forma del método de escritura public void write(int c).
    • Parámetros:
    • String s - La cadena que será guardada en el archivo de texto.
  5. Cerramos los objetos PrintWriter y FileWriter con el método close().
FileWriter fw = new FileWriter(rutaEspecifica);

PrintWriter pw = new PrintWriter(fw);

pw.println(texto);

pw.close();

fw.close();
  • Contendio en un metodo al cual llamar...

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
public static void guardarTXT(String texto, String rutaEspecifica){
    FileWriter fw = null;
    PrintWriter pw = null;
    try {
        fw = new FileWriter(rutaEspecifica);
        pw = new PrintWriter(fw);

        pw.println(texto);
        pw.close();
        fw.close();
        System.out.println("Archivo guardado exitosamente!");
    } catch (Exception e) {
        e.printStackTrace();
    } 
}

Una llamada a estos metodos podria ser:


leerTXT("C:\\blog\\archivoTexto.txt");
String manejoTexto = TXT2String("C:\\blog\\archivoTexto.txt");
guardarTXT(manejoTexto, "C:\\blog\\copia.txt");

De seguir siendo estaticos seria asi, sino un objeto tendra que invocarlos. Aca mezclamos ambos metodos de lectura y escritura.

en No hay comentarios:
Etiquetas:

[Metodos] Leer y Escribir un archivo de texto.

Leer archivo de Texto

Para leer un archivo de texto vamos a hacer uso de 3 clases java:
  1. En primer lugar deberemos tener la ruta especifica del archivo a leer, y creamos un objeto de clase File, con su constructor:
    • Crea una nueva instancia del un objeto File convirtiendo el parámetro pathName en una vía de acceso abstracta.
    • Parámetros:
    • String pathname - la ruta especifica donde se encuentra el archivo.
    • Arroja:
    • NullPointerException - Si la cadena del parámetro es nula (null)

  2. Creamos un objeto de la clase FileReader, pasandole como parametro el objeto File creado anteriormente en su constructor:
    • Crea un objeto de la clase FileReader con el objeto File pasado por paramétro.
    • Paramétros:
    • File fileName - el nombre del objeto File para ser leido.
    • Aroja:
    • FileNotFoundException - Si no existe el archivo, se encuentra en un directorio inalcanzable (Permisos), o por alguna otra razón no se pueden abrir para la lectura (Ejemplo esta en usándose por otro programa).

  3. Creamos un buffer de la clase BufferefReader, pasandole como parametro el objeto FileReader creado anteriormente en su constructor:
    • public BufferedReader(Reader in)
    • Crea un búfer par un flujo de caracteres de entrada que utiliza una memoria intermedia de entrada de tamaño predeterminado.
    • Parametros:
    • Reader in - Un objeto de la clase Reader, de la cual hereda (haciendo posible usar) la clase FileReader.

  4. Por ultimo (Crear un objeto String) e ir iterando mediante un while, usando como condición distinta de nula un método de la clase BufferedReader:
    • public String readLine() throws IOException
    • Lee una línea de texto. Se considera que una linea terminada cuando hay un salto de línea ('\ n'), un retorno de carro ('\ r'), o un retorno de carro seguido inmediatamente por un salto de línea.
    • Retorna:
    • Una cadena que contiene el contenido de la línea, sin incluir los caracteres de fin de línea, o null si se ha alcanzado el final de la secuencia
    • Arroja:
    • IOException - SI ocurre un error I/O (Input/Output - Entrada/Salida)
  5. De aqui en mas, se puede ir imprimiendo cada linea en la consola, guardar el contenido en un String, Array, Lista, etc

File archivo = new File(rutaEspecifica);

FileReader fr = new FileReader(archivo);

BufferedReader br = new BufferedReader(fr);

String cadena;

while ((cadena = br.readLine()) != null) {
//TODO

}
Metodo para mostrar en consola el contenido de un archivo de texto:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public static void leerTXT(String rutaEspecifica) {
    String cadena;
    File archivo = new File(rutaEspecifica);
    if (archivo.exists()) {
        try {
            FileReader fr = new FileReader(archivo);
            BufferedReader br = new BufferedReader(fr);

            while ((cadena = br.readLine()) != null) {
                System.out.println(cadena);
            }

            br.close();
            fr.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    } else {
        System.err.println("El sistema no pudo hallar la ruta especifica.");
    }
}
  • Metodo para devolver como String el contendio de un archivo de texto./li>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public static String TXT2String(String rutaEspecifica) {
    String cadena;
    String cadenaRetorno = "";
    File archivo = new File(rutaEspecifica);
    if (archivo.exists()) {

       try {
           FileReader fr = new FileReader(archivo);
           BufferedReader br = new BufferedReader(fr);
           while ((cadena = br.readLine()) != null) {
              cadenaRetorno = cadenaRetorno.concat(cadena) + "\n";
           }
           br.close();
           fr.close();
       } catch (FileNotFoundException e) {
            e.printStackTrace();
       } catch (IOException e) {
            e.printStackTrace();
       }
    } else {
          System.err.println("El sistema no pudo hallar la ruta especifica.");
    }
    return cadenaRetorno;
}
La llamada a estos metodos podrian ser:

leerTXT("C:\\blog\\archivoTexto.txt");

De seguir siendo estaticos seria asi, sino un objeto que creemos tendra que invocarlos.

en No hay comentarios:
Etiquetas:

[MYSQL] DDL y DML - Consultas Basicas

SQL: El lenguaje de consulta estructurado (Structured Query Language) es un lenguaje declarativo de acceso a bases de datos relacionales y permite especificar diferentes tipos de operaciones en estas.

  • Una de las caracteristicas es el uso del calculo y el algebra para realizar consultas y recuperar la informacion que nos interese
  • Existen 2 tipos de lenguajes en su manejo DDL y DML:
  1. DDL (Data Definition Language) Lenguaje de Definicion de Datos
  2. DML (Data Manipulation Language) Lenguaje de Manipulacion de Datos
QUE ES DDL?
Es el lenguaje que se usa para crear bases de datos y tablas, modificar sus estructuras y sus permisos y privilegios.

Los comando mas comunes son:

CREATE TABLE - ALTER TABLE - DROP TABLE - CREATE INDEX - DROP INDEX

QUE ES DML?
Es el lenguaje que se usa para modificar y obtener datos de una base de datos.

Los comando mas conocidos son:

SELECT - UPDATE - DELETE - INSERT INTO

Comandos DDL


CREATE TABLE
  1. CREATE TABLE gente{
  2. nombre VARCHAR(20),
  3. fecha DATE
  4. }

ALTER TABLE
  1. ALTER TABLE autos RENAME coches;

Se utiliza para modificar los atributos de la tabla, como su nombre, el tipo de variables de sus columnas, eliminar columnas, agregarlas, etc
Mas info en: http://dev.mysql.com/doc/refman/5.7/en/alter-table-examples.html


DROP TABLE
  1. DROP TABLE gente;
  2.  
  3. -- para eliminar el error en caso de no existir
  4.  
  5. DROP TABLE IF EXITS gente;

Comandos DLL


SELECT
  1. SELECT * FROM hibernate.personas;

"Select" nos permite seleccionar para ver las columnas y sus registros
El * es un comodin que indica que quiero ver todas las columnas de la tabla.
De lo contrario para ver una especifica lo escribo: "nombreDeLaTabla.nombreDeLaColumna"
Se separan con comas si quiero utilizar mas de una tabla a mostrar.
"hibernate.personas" es "laBasedeDatos.nombreDeLaTabla" de la cual quiero ver los resultados.
Del mismo modo, se separan con comas si quiero ver resultados de mas de una tabla.


INSERT INTO
  1. INSERT INTO nombre_de_la_tabla ( Columna1, columna 2, …. ) VALUES ( Valor1, valor2, ….) ;

UPDATE
  1. UPDATE nombre_de_la_tabla SET nombre_de_la_columna = 'nuevo_valor' ;

    Tiene mas sentido utilizar un UPDATE junto con la clausula WHERE indicandole que modifique el campo de una columna donde exista cirta condicion o el valor exacto.

    UPDATE auto SET precio = 990099 WHERE id = 5 ;

DELETE
  1. DELETE FROM nombre_de_la_tabla WHERE nombre_de_la_columna = > 1 ;

    idem anterior, tiene sentido junto con la clausula WHERE indicandole que elimine el campo de una columna donde se cumpla un valor exacto o una condicion, ej ,ayor a 1.

en No hay comentarios:
Etiquetas:
Suscribirse a: Entradas (Atom)