Threads en java, un caso práctico…

Hilos en java

Normalmente estamos acostumbrados a que en un curso de programación java nos enseñan a usar threads (hilos o mejor dicho hebras) de maneras que nos dejan como a medias, el típico ejemplo de mostrar mensajes o series de números pero rara vez (al menos en mi caso) nos muestran algún ejemplo práctico.

Ok pues de eso trata esta humilde entrada, es un programa hecho en java por supuesto, que tiene como función copiar todos los archivos de una carpeta a otra mediante hilos.

En resumen
Una vez que se ejecuta el programa inicia la copia de los archivos de forma simultanea, ya que por cada hilo existente dentro de la carpeta que se le pase como parámetro origen se genera un hilo que se encarga de copiar dicho archivo.

Veamos
Se ejecuta en modo terminal, de la forma ‘java ArchivosHilos carpetaOrigen carpetaDestino’.

Una vez ejecutado veremos lo siguiente:

 

Aquí el código fuente.


import java.io.*;

class CopiaArchivo extends Thread {
	String archivoOriginal;
	String archivoCopia;

	public CopiaArchivo(){
	}

	//CONSTRUCTOR QUE PASA LOS NOMBRES DE LOS ARCHIVOS COMO PARAMETROS
	//PARA CREAR LOS NUEVOS OBJETOS HILOS CON LOS PARAMETROS NECESARIOS
	public CopiaArchivo(String archivoOriginal, String archivoCopia){
		this.archivoOriginal=archivoOriginal;
		this.archivoCopia=archivoCopia;
	}

	//El metodo Run el mas importante...
	public  void run() {
		System.out.println("hilo.." + archivoOriginal + " .. " + archivoCopia);

		try{
			// Se abre el archivo original para lectura
			FileInputStream fileInput = new FileInputStream(archivoOriginal);
			BufferedInputStream bufferedInput = new BufferedInputStream(fileInput);

			// Se abre el archivo donde se hará la copia
			FileOutputStream fileOutput = new FileOutputStream (archivoCopia);
			BufferedOutputStream bufferedOutput = new BufferedOutputStream(fileOutput);

			// Bucle para leer de un archivo y escribir en el otro.
			byte [] array = new byte[1000];
			int leidos = bufferedInput.read(array);
			while (leidos > 0)
			{
				bufferedOutput.write(array,0,leidos);
				leidos=bufferedInput.read(array);
			}

			// Cierre de los archivos
			bufferedInput.close();
			bufferedOutput.close();
		}
		catch (Exception e)
		{
			System.out.println("Error: " + e.getMessage());
			//e.printStackTrace();
		}

	}

}

public class ArchivosHilos{

	public static void modoUso(){
		System.out.println("---------------------------------------------------------------");
		System.out.println("Modo de uso\n\tjava CopiaArchivos carpetaOrigen carpetaDestino");
		System.out.println("---------------------------------------------------------------");
	}

	public static void main(String []args){

		try{
			if (args[1].equals(null)){
				modoUso();
			}
			else{
				//Obtener una listado de archivos de la carpeta archivoOriginal
				File dir = new File(args[0]);
				String[] archivos = dir.list();

				File dir2 = new File(args[1]);
				String[] archivos2 = dir2.list();

				if (archivos == null)
					System.out.println("\nNo existe el directorio origen "+ args[0] + ".......");
				else
				if (archivos2 == null)
					System.out.println("\nNo existe el directorio destino "+ args[1] + ".......");

				else {
					System.out.println("\nArchivos en el directorio "+ args[0] + ".......");

					//Mostrar los archivos existentes...
					for (int x=0;x						System.out.print(archivos[x] + "\t");
					}

					System.out.println("\nIniciando el proceso de copia...\n");

					CopiaArchivo []hilos=new CopiaArchivo[archivos.length];

					//Iniciar la copia de archivos...
					for (int x=0;x						System.out.println("Iniciando la copia de " + archivos[x]);

						//ACÁ SE CREAN LOS HILOS PARA INICIAR LA COPIA DE ARCHIVOS
						hilos[x] = new CopiaArchivo(args[0]+"/"+archivos[x] , args[1]+"/"+archivos[x]);
						//inicia el hilo
						hilos[x].start();

						System.out.println("El archivo " + archivos[x] + " ha sido copiado correctamente!");

					}

					//Esperar a q terminen todos
					for (int x=0; x						hilos[x].join();
					}
				}
				System.out.println();

			}
		}
		catch(ArrayIndexOutOfBoundsException e){
			modoUso();
		}
		catch (Exception e){
			modoUso();
		}
	}

}

Encriptar en texto plano

Programa para poder encriptar o desencriptar un texto cambiando simplemente la posición de las letras en el alfabeto.

Normal :          ‘a’,'b’,'c’,'d’,'e’,'f’,'g’,'h’,'i’,'j’,'k’,'l’,'m’,'n’,'o’,'p’,'q’,'r’,'s’,'t’,'u’,'v’,'w’,'x’,'y’,'z’

Encriptado : ‘m’,'n’,'b’,'v’,'c’,'x’,'z’,'a’,'s’,'d’,'f’,'g’,'h’,'j’,'k’,'l’,'p’,'o’,'i’,'u’,'y’,'t’,'r’,'e’,'w’,'q’

así el programa al encontrarse con una “a” la cambiará por una “m”

Por ejemplo al colocar hola,  obtendremos como resultado akgm.

public String encripta(String mensaje){
		String textoPrueba=mensaje;
		//System.out.println("Texto de prueba : " + textoPrueba);
		int i,j;
		char letra;

		String textoEncriptado="";
		int posicion=0;
		for (i=0; i<textoPrueba.length(); i++){
				letra=textoPrueba.charAt(i);

				for (j=0; j<texto.length; j++){
					if (letra==texto[j]){
						posicion=j;
					}
				}
				//System.out.println(letra);
				textoEncriptado=textoEncriptado+encriptado[posicion];
		}

		//System.out.println("Texto encriptado: " + textoEncriptado);
		return textoEncriptado;
	}


Ejemplo completo…

Interfaces y expresiones regulares java

Problema a solucionar:

Implementar la interfaz llamada Verifier, esta interfaz debe tener un solo método llamado verificar el cual sera implementado en alguna otra clase.

Este método (isValid) se encargara de evaluar una cadena y decir  si es o no válida. Para esto se hará uso de una expresión regular.

La cadena debe cumplir los siguientes requisitos:

Empezar con cualquiera de los siguientes prefijos: i,s,l,by,bo,c1,f,d,c2 o rt después de eso debe tener forsozamente una letra mayúscula y para continuar mas letras o números.

Seguido de un simbolo $ ahora debe llevar pub, pro, def o pri.

Y terminar con X o con Y.

Las cadenas válidas posibles son:

  • iTotal$pubY
  • boSuma$priY
  • c2SumaTotal$pubX
  • rtSumaTotal2$defX

Ahora cadenas inválidas serian cualquiera que no respete las reglas anteriores por ejemplo

  • isuma$proY –>Inválida ya que no respeta la mayúscula después de i
  • iTotal$pub ->Inválida… por no terminar con X o Y
  • ademas de por supuesto cualquier otra palabra

Esta es la parte del código que resuelve el problema:


   public  boolean isValid(String id){
        //EXPRESION A EVALUAR
        Pattern p = Pattern.compile("[i|s|l|by|bo|c1|f|d|c2|rt]{1,2}[A-Z]{1}[a-zA-Z]+[0-9]*[$][pub|pro|def|pri]{3}[X|Y]");
        Matcher m = p.matcher(id.trim());

        //DEVUELVE EL RESULTADO
        return m.find();

    }

La expresión seguramente se puede recortar, pero por lo mientras así funciona.

Compilado y  fuentes. (pass=lecd++)

Conectar mysql con java usando netbeans

Como se nota en la captura el programita hace casi de todo, envía datos(insert), extrae(select) elimina(delete) y  hace updates.

La tabla a la cual se conecta se llama Persona, con la siguiente estructura.

CREATE TABLE `persona` (
`curp` varchar(18) NOT NULL,
`nombre` varchar(20) DEFAULT NULL,
`apellido` varchar(20) DEFAULT NULL,
`estatura` float DEFAULT NULL,
`peso` int(11) DEFAULT NULL,
`edad` int(11) DEFAULT NULL,
PRIMARY KEY (`curp`)
);

Actualizando un registro…

Bajalo de acá , coméntame, platícame que te pareció…

Pass  = lecdmx

Extraer las palabras de un texto con java

Cosa tan simple como usar expresiones regulares y no andar matándose con cadenas como lo hice hace unos días, por tiempo, por falta de ganas de leer  mas en fin.

Aquí la gran solución.


public class E {   
        public static void main(String[] args) {
        
	String s="hola mundo esta es una pinche prueba, de la extraccion de palabras de un texto";
        String delims = "[ .,?!]+";
        String[] tokens = s.split(delims);
                                    
		System.out.println("Las palabras extraidas son:");
		for (int i=0; i<tokens.length; i++){
			System.out.println(tokens[i]);
		}
	}
}


 
Ahora les presento el problema resuelto ‘a mano’, a lo bruto es así como saqué el problema adelante…

                  
int espacio = 0;
            int largos = 0;
            int p = 0;
            int ini = 0;

            try{
            t=t.replace('\n', ' ');
            int posEnter = 0;
            do {

                espacio = t.indexOf(' ');
               
                System.out.println("Pos espacio " + espacio);
                System.out.println("P " + p);
                if (espacio != -1) {
                    palabras[p] = t.substring(0, espacio);
                } else {
                    palabras[p] = t;
                }
                System.out.println("Palabra capturada ---------------->" + palabras[p]);

                t = t.substring(espacio + 1);
                System.out.println("Ahora la cadena completa es .." + t + "...");
                System.out.println("....................................................");
                p++;
            } while (espacio != -1);
            }
            catch(Exception er){
                JOptionPane.showMessageDialog(null, "Error: Posiblemente ha excedido el número de palabras permitido.", "Resultados", JOptionPane.INFORMATION_MESSAGE);
            }

Lo segundo no lo hagan en casa, es totalmente ineficiente pero resolvió el problema de forma correcta… [Me disculpo con el Sr. método String.split]…

Otras ideas, comentarios o soluciones alternativas son por supuesto bienvenidas...

Corrector ortográfico con java y jortho

Implementación de la herramienta jortho en java.  El control usado es un JEditorPane que permite revisar el texto en todo momento.

Jortho permite usar diferentes diccionarios, agregar palabras nuevas al diccionario en turno, etc. La aplicación permite además abrir un archivo de texto para chequearlo y/o guardar un archivo de texto con los cambios realizados.

El proyecto para netbeans (con los fuentes y todo) lo tengo guardadito pero no a la mano, estara pendiente subirlo a un servidor. Aquí puedes descargar la demostración para probarlo por mientras (lecd++ es la contraseña).

Link para descarga(contraseña lecdmx.wordpress.com)  del proyecto fuente, es una versión muy anterior a la final; pero funcional.

Recuerda lecdmx.wordpress.com, y coméntame que tal…

Conexión Oracle sql con java

Lo siguiente es una demostración muy muy sencilla de la conexión entre el super gestor Oracle o ElCaro(como dicen por ahí…) que andaba por acá desde hace unos meses y ahora pues a compartirlo…

Login para entrar a la aplicación.

Una vez elegido el usuario, podemos agregar registros o hacer consultas básicas.

Registro de un empleado

Al ser una demostración comprobamos que el id a usar no esté siendo usado.

Una vez comprobado que el id a usar este disponible podemos almacenar el registro.

Y consultarlos después…

El código habla por si solo…


   private boolean pruebaConeccion() {
        //Carga el driver JDBC NECESARIO PARA CONECTAR CON ORACLE
        try {
            Class.forName("oracle.jdbc.driver.OracleDriver");
        } catch(ClassNotFoundException cnfe) {
          JOptionPane.showMessageDialog(this.jPanel1, "No se encontro el ojdbc.jar", "Error", JOptionPane.ERROR_MESSAGE);

          return false;
        }

        //DATOS NECESARIOS PARA LA CONEXION
        String host="localhost";
        String puerto="1521";
        String SID="xe";
        String user=Entrada.usuario;
        String password=Entrada.password;

        //ESTABLECEMOS LA CONEXION ENTRE ORACLE Y ESTE PROGRAM
        try {
          con = DriverManager.getConnection("jdbc:oracle:thin:@"+host+":"+puerto+":"+SID, user ,password);
          consulta =con.createStatement();

        } catch(SQLException sqle) {
          JOptionPane.showMessageDialog(this.jPanel1, "No se pudo efectuar la coneccion", "Error", JOptionPane.ERROR_MESSAGE);
          JOptionPane.showMessageDialog(this.jPanel1, sqle, "Error", JOptionPane.ERROR_MESSAGE);
          return false;
        }
        //JOptionPane.showMessageDialog(this.jPanel1, "Coneccion Establecida !!", "Correcto", JOptionPane.INFORMATION_MESSAGE);

        try{ //POR SI ALGUN ERROR

          //Veo QUE USUARIO ESTA CONECTADO, EN BASE A ESO
            //EXTRAIGO DATOS DE LA TABLA "CLIENTE" O BIEN DE SU SINONIMO "CLIENTEE"
          if (user.equals("basededatos")){
              // LA SIGUEINTE LINEA TIENE LA CONSULTA QUE EXTRAE LOS DATOS
                rs = consulta.executeQuery("select * from cliente"); //TODOS LOS REGISTROS DE LA TABLA CLIENTE
                            // rs ALMACENA TODO EL RESULTADO
                            //DE LA CONSULTA EN FORMA DE UN ARRAY
          }
          else{
                rs = consulta.executeQuery("select * from clientee"); //TODOS LOS REGISTROS DE LA TABLA CLIENTE
                            // rs ALMACENA TODO EL RESULTADO
                            //DE LA CONSULTA EN FORMA DE UN ARRAY
          }

          txtc.setText("");
          //txtc.setText("ID          NOMBRE                                  DIRECCION                                   CIUDAD                               TELEFONO\n");

          int i=1;

            //HACEMOS UN CICLIO QUE SE REPITE HASTA QUE rs ya NO TENGA MAS DATOS
            // LOS DATOS QUE TIENE SON LOS DE LA TABLA CLIENTE
            while (rs.next()){

                    //GUARDAMOS EN V1, V2 LOS VALORES OBTENIDOS
                    String v1="";
                    v1=v1+rs.getString("id");     //extrar el valor de  id y GUARDARLO EN V1
                    String v2="";
                    v2=v2+rs.getString("nombre"); // ASI SUCESIVAMENTE...
                    String v3="";
                    v3=v3+rs.getString("domicilio");
                    String v4="";
                    v4=v4+rs.getString("ciudad");
                    String v5="";
                    v5=v5+rs.getString("telefono");

                    //AGREGAMOS LOS DATOS AL TEXTAREA
                    txtc.setText(txtc.getText()
                            + "Registro....................... " + i + "\n"
                            + "id       : " + v1 + "\n"
                            + "Nombre   : " + v2 + "\n"
                            + "Domicilio: " + v3 + "\n"
                            + "Ciudad   : " + v4 + "\n"
                            + "Teléfono : " + v5 + "\n\n");
                    i++;
            }

          //CERRAR LA CONEXION
            consulta.close();

        }
       catch(SQLException e){
            e.printStackTrace();

        }

        return true;
      }

Si necesitas el proyecto completo , dale acá (password lecd++)  y no olvides comentar…. :)

Listo Sres. Briones y Xpolito

Matriz sumatoria…(o algo)

La imagen anterior corresponde a un programa de esos de semestre o (cero o menos), vaya de kinderGarden que permite obtener la sumatoria del valor digamos posicional de la columna donde se encuentre la letra o cada una de las letras que forman una palabra. Por ejemplo si escribimos la palabra “hola”, nos devolverá 21 ya que h=8, o=8, l=4 y a=1.

Como se aprecia en la captura siguiente si escribo mi nombre me da como resultado 54.

La idea es compartir, aprender; y si de paso te ayudo pues aún mejor…

No es la gran cosa, pero te puede servir para aprender a usar vectores en java.

Extracto de código:

public int buscaValores(){
 int a,b;
 a=b=0;
 int total=0;
 int i=0;

 while (i<largo){
      for (b=0; b<5; b++){
          for (a=1; a<9; a++){
              if (texto[i]==letras[b][a]){
                  total+=a;
                  System.out.println("Concidencia --->" + texto[i] + " b=   " + b);

              }
          }
      }
      i++;
 }

 return total;
 }

El proyecto completo, queda pendiente…

Bajate de acá el proyecto completo para Netbeans…

Un día que me atreví a llegar temprano al ITSH

‘Cuasi’ Paint hecho en java

Un paint creado en java por varios autores, tomado de algún sitio y modificado/adaptado por mi; lamentablemente no recuerdo el sitio del programador original.

Todas las funciones que se ven en la imagen están operativas.

Por cierto muy similar al de rDebug.

Un extracto de código aqui viene…

 private void volverADibujar(Graphics g){
        if(lista.size()>0){
            for (int i = 0; i < lista.size(); i++) {
                listadoPintura var=lista.get(i);
                g.setColor(var.color);

                //Cuando el tipo es 0 se dibujan lineas rectas
                if(var.tipo==0){
                    g.drawLine(var.xInicial, var.yInicial,var.xFinal,var.yFinal);

                }
                //Cuando el tipo es 1 se diseñar la elipse vacía
                else if(var.tipo==1){
                    if(var.xInicial>var.xFinal || var.yInicial>var.yFinal)
                        g.drawOval(var.xFinal, var.yFinal,var.xInicial-var.xFinal,var.yInicial-var.yFinal);
                    else
                        g.drawOval(var.xInicial, var.yInicial,var.xFinal-var.xInicial,var.yFinal-var.yInicial);
                }else if(var.tipo==2){
                    g.drawLine(var.xInicial, var.yInicial,var.xFinal,var.yFinal);
               //Cuando el tipo es 3 se diseñar la elipse rellena
                }else if(var.tipo==3){
                    if(var.xInicial>var.xFinal || var.yInicial>var.yFinal)
                        g.fillOval(var.xFinal, var.yFinal,var.xInicial-var.xFinal,var.yInicial-var.yFinal);
                    else
                        g.fillOval(var.xInicial, var.yInicial,var.xFinal-var.xInicial,var.yFinal-var.yInicial);
                }
                //Cuando el tipo es 4 se diseñar el rectángulo vacío
                else if(var.tipo==4){
                    if(var.xInicial>var.xFinal || var.yInicial>var.yFinal)
                        g.drawRect(var.xFinal, var.yFinal,var.xInicial- var.xFinal,var.yInicial-var.yFinal);
                    else
                        g.drawRect(var.xInicial, var.yInicial,var.xFinal-var.xInicial,var.yFinal-var.yInicial);
                }
                //Cuando el tipo es 5 se diseñar el rectángulo relleno
                else if(var.tipo==5){
                    if(var.xInicial>var.xFinal || var.yInicial>var.yFinal)
                        g.fillRect(var.xFinal, var.yFinal,var.xInicial- var.xFinal,var.yInicial-var.yFinal);
                    else
                        g.fillRect(var.xInicial, var.yInicial,var.xFinal-var.xInicial,var.yFinal-var.yInicial);
                }
                //Cuando el tipo es 6 se diseñar el rectángulo  redondeado vacío
                else if(var.tipo==6){
                    if(var.xInicial>var.xFinal || var.yInicial>var.yFinal)
                        g.drawRoundRect(var.xFinal, var.yFinal,var.xInicial- var.xFinal,var.yInicial-var.yFinal,5,5);
                    else
                        g.drawRoundRect(var.xInicial, var.yInicial,var.xFinal-var.xInicial,var.yFinal-var.yInicial,5,5);
                }
                //Cuando el tipo es 5 se diseñar el rectángulo redondeado relleno

Para descargar el programa aqui.

Seguir

Get every new post delivered to your Inbox.