insertar nodos en el arbol

 
package arboles2;

/**
 *
 * @author cisco
 */
public class Arbol {

    private NodoArbol raiz;

    public Arbol() {
        raiz = null;
    }

    public Arbol(int equipo) {
        raiz = new NodoArbol(equipo);
    }

    public NodoArbol getRaiz() {
        return raiz;
    }

    private void addNodo(NodoArbol nodo, NodoArbol raiz) {
        if (raiz == null) {
              this.raiz=nodo;
        } else {
            if (nodo.getDatos() <= raiz.getDatos()) {
                if (raiz.getIz() == null) {
                    raiz.setIz(nodo);
                } else {
                    addNodo(nodo, raiz.getIz());
                }
            } else {
                if (raiz.getDer()== null) {
                    raiz.setDer(nodo);
                } else {
                    addNodo(nodo, raiz.getDer());
                }
            }
        }
    }

    public void addNodo(int dato) {
        NodoArbol nodo =new NodoArbol(dato);
        this.addNodo(nodo, this.raiz);
    }

    public void recorridoAnchura() {

        if (raiz != null) {
            Cola cola = new Cola();
            cola.encolar(raiz);
            Cola colaAux = new Cola();

            while (!cola.esVacia()) {
                NodoArbol aux = cola.desencolar().getDato();

                if (aux.getIz() != null) {
                    cola.encolar(aux.getIz());
                }
                if (aux.getDer() != null) {
                    cola.encolar(aux.getDer());
                }
                colaAux.encolar(aux);

            }

            colaAux.imprimir();

        }

    }

}

Búsqueda binaria en estructura de datos, data structure and binary search

 

package prylista;


public class Lista {
    private Nodo inicio;
    private Nodo fin;
    
    public Lista(){
        inicio=fin=null;
    }
    
    public boolean esVacia(){
      return inicio==fin && fin==null;
    }
    
    public void insertarInicio(int dato){
        Nodo n=new Nodo(dato, inicio);
        if(esVacia()){
           inicio=fin=n;
        }else{
          inicio=n;
        }
    }
    public void insertarFin(int dato){
        Nodo n=new Nodo(dato, null);
        if(esVacia()){
           inicio=fin=n;
        }else{
            fin.setSiguiente(n);
            fin=n;
        }
    }
    
    public int size(){
        Nodo aux=inicio;
        int cont=0;
        while(aux!=null){
           cont++;
           aux=aux.getSiguiente();
        }
        return cont;
    }
    
    public int valorIndice(int indice){
        Nodo aux=inicio;
        int cont=0;
        while(contfin.getDato())
            return -1;
        int inf=0;
        int sup=size()-1;
        
        while(sup>=inf){
            int c=(inf+sup)/2;
            if(valor==valorIndice(c)){
               return c;
            }else if(valor>valorIndice(c)){
                inf=c+1;
            }else{
                sup=c-1;
            }
        }
        return -1;
    }
    
    public void imprimir() throws Exception{
      if(esVacia())
          throw new Exception("Vacia");
      Nodo aux=inicio;
      while(aux!=null){
          System.out.println(aux.getDato());
          aux=aux.getSiguiente();
      }
      
    
    }
    
}

Ejercicios de estructura de datos colas

Para resolver un ejercicio de colas necesitamos de ciertas clases como son: Entidad (Paciente, Persona, Auto, Transacción, etc) dependiendo del tipo de ejercicio. Nodo (Nodo de Paciente) Cola (Colección de Nodos) Principal (Programa invocante) Creamos un nuevo proyecto y sobre este creamos una nueva clase en este caso vamos a generar una cola de pacientes Implementación de la clase Paciente.

package prycolas;

import java.time.LocalTime; 

public class Paciente {
    private String cedula;
    private String nombre;
    private LocalTime hora;
 public Paciente(String cedula, String nombre) {
  super();
  this.cedula = cedula;
  this.nombre = nombre;
  hora=LocalTime.now();
 }
 public String getCedula() {
  return cedula;
 }
 public void setCedula(String cedula) {
  this.cedula = cedula;
 }
 public String getNombre() {
  return nombre;
 }
 public void setNombre(String nombre) {
  this.nombre = nombre;
 }
 public String getHora() {
  return " "+hora.getHour()+":"+hora.getMinute()
  +"-"+hora.getSecond();
 }
 public void setHora(LocalTime hora) {
  this.hora = hora;
 }    
}

Implementación de la clase Nodo de Pacientes.

package prycolas;

public class Nodo {
 private Paciente dato;
 private Nodo siguiente;
 
 public Nodo(Paciente dato, Nodo siguiente) {
  super();
  this.dato = dato;
  this.siguiente = siguiente;
 }

 public Paciente getDato() {
  return dato;
 }

 public void setDato(Paciente dato) {
  this.dato = dato;
 }

 public Nodo getSiguiente() {
  return siguiente;
 }

 public void setSiguiente(Nodo siguiente) {
  this.siguiente = siguiente;
 }
}

Implementación de la clase Cola con sus métodos para insertar, extraer, listar, verificar si está vacía

package prycolas;

public class Cola {

    private Nodo inicio;
    private Nodo fin;

    public Cola() {
        super();
        inicio = fin = null;
    }

    public boolean esVacia() {
        return inicio == fin && fin == null;
    }

    public void encolar(Paciente p) {
        Nodo n = new Nodo(p, null);
        if (esVacia()) {
            inicio = fin = n;
        } else {
            fin.setSiguiente(n);
            fin = n;
        }
    }

    public Paciente desencolar() throws Exception {

        if (esVacia()) {
            throw new Exception("No hay elementos en la cola");
        }
        Nodo aux = inicio;
        inicio = inicio.getSiguiente();
        if (inicio == null) {
            fin = inicio;
        }
        return aux.getDato();
    }

    public void imprimir() throws Exception {
        if (esVacia()) {
            throw new Exception(" Cola vacia");
        }
        Nodo aux = inicio;
        while (aux != null) {
            System.out.println(aux.getDato().getNombre()
                    + " llego a las " + aux.getDato().getHora());
            aux = aux.getSiguiente();
        }
    }
}

Invocación desde el programa principal creando un objeto cola, el cual tiene un menú de opciones

package prycolas;

import java.util.Random;
import java.util.Scanner;

public class Principal {

    private static int leerEntero(String mensaje, int min, int max) {
        Scanner ingreso = new Scanner(System.in);
        int dato;
        do {
            System.out.println(mensaje + "entre " + min + " y " + max);
            dato = ingreso.nextInt();

        } while (dato < min || dato > max);
        return dato;
    }

    private static String leerString(String mensaje) {
        Scanner ingreso = new Scanner(System.in);
        String dato;
        System.out.println(mensaje);
        dato = ingreso.nextLine();

        return dato;
    }

    public static int menu() {
        System.out.println("Menú Opciones");
        System.out.println("1. Encolar cliente");
        System.out.println("2. Atender cliente");
        System.out.println("3. Imprimir cola de clientes");
        System.out.println("4. Salir");
        int opcion = leerEntero("Seleccione una opcion", 1, 4);
        return opcion;
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Cola clientes = new Cola();
        int op;
        do {
            op = menu();
            switch (op) {
                case 1:
                    String cedula=leerString("Ingrese la cédula: ");
                    String nombre=leerString("Ingrese el nombre: ");
                    clientes.encolar(new Paciente(cedula,nombre));
                    break;
                case 2:
                    try {
                        Random aleatorio = new Random();
                        Paciente sale = clientes.desencolar();
                        System.out.println("Atendiendo a "+sale.getNombre()+" espere ...");
                        int tiempo_atencion=1000+aleatorio.nextInt(10000);
                        Thread.sleep(tiempo_atencion);
                                              
                        System.out.println(sale.getNombre()+ " fue atendido en "+tiempo_atencion/1000+"seg");
                        
                    } catch (InterruptedException e) {
                        System.out.println(e.getMessage());
                    }catch (Exception e) {
                        System.out.println(e.getMessage());
                    }

                    break;
                case 3:
                    System.out.println("Pacientes en cola ");
                    try {
                        clientes.imprimir();
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 4:
                    break;

            }
        } while (op != 4);

    }

}

sumar 2 arboles binarios

 
public void sumar(Nodo a, Nodo b) {
        if (a != null || b != null) {
            if (a != null && b != null) {
                insertar(a.getDato() + b.getDato());
                sumar(a.getIz(), b.getIz());
                sumar(a.getDer(), b.getDer());
            }else if(a!=null){
                insertar(a.getDato());
               sumar(a.getIz(), null);
               sumar(a.getDer(), null);
            }
            else{
                insertar(b.getDato());
            sumar(null, b.getIz());
            sumar(null, b.getDer());}
        }

    }

    void sumar(Arbol a, Arbol b) {

        sumar(a.raiz, b.raiz);
    }

Determinar el altitud del arbol java con recursividad, niveles del arbol con recursividad.

/* * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools | Templates * and open the template in the editor. */

 
package pryarboles;

/**
 *
 * @author cisco
 */
public class Arbol {

    private Nodo raiz;

    public Arbol() {
        raiz = null;
    }

    public void insertar(int dato, Nodo actual) {
        if (actual == null) {
            raiz = new Nodo(dato);
        } else {
            if (dato < actual.getDato()) {
                if (actual.getIzquieda() == null) {
                    Nodo nuevo = new Nodo(dato);
                    actual.setIzquieda(nuevo);
                } else {
                    actual = actual.getIzquieda();
                    insertar(dato, actual);
                }

            } else {
                if (actual.getDerecha() == null) {
                    Nodo nuevo = new Nodo(dato);
                    actual.setDerecha(nuevo);
                } else {
                    insertar(dato, actual.getDerecha());
                }
            }
        }
    }

    public void insertar(int dato) {
        insertar(dato, raiz);
    }

    public int imprimirPreOrden(Nodo actual, int n, int mayor) {
        if (actual != null) {
           // System.out.println(actual.getDato() + " " + n);
           if(n>mayor)
               mayor=n;
           int a=imprimirPreOrden(actual.getIzquieda(), n + 1, mayor);
           int b=imprimirPreOrden(actual.getDerecha(), n + 1, mayor);
            if (a > b ) {
               return a;
            }
            return b;
            
           
        }
        return mayor;
    }

    public void imprimirPreOrden() {
        System.out.println(imprimirPreOrden(raiz, 1, 0));
    }

}

hilos en java, ejercicio listas circulares, insetar nodos en listas doblemente enlazadas

Se desea crear una lista circular con números perfectos utilizando hilos

package prylistascircular;

/**
 *
 * @author laboratorio
 */
public class Nodo {
    private int dato;
    private Nodo anterior;
    private Nodo siguiente;

    public Nodo(int dato, Nodo anterior, Nodo siguiente) {
        this.dato = dato;
        this.anterior = anterior;
        this.siguiente = siguiente;
    }

    public int getDato() {
        return dato;
    }

    public void setDato(int dato) {
        this.dato = dato;
    }

    public Nodo getAnterior() {
        return anterior;
    }

    public void setAnterior(Nodo anterior) {
        this.anterior = anterior;
    }

    public Nodo getSiguiente() {
        return siguiente;
    }

    public void setSiguiente(Nodo siguiente) {
        this.siguiente = siguiente;
    }
    
    
}

package prylistascircular;

/**
 *
 * @author laboratorio
 */
public class Circular {

    private Nodo inicio;
    private Nodo fin;

    public Circular() {
        inicio = fin = null;
    }

    public boolean esVacia() {
        return inicio == null && fin == null;
    }

    public void insertarInicio(int dato) {
        Nodo nuevo = new Nodo(dato, fin, inicio);
        if (esVacia()) {
            inicio = fin = nuevo;
        } else {
            inicio.setAnterior(nuevo);
            fin.setSiguiente(nuevo);
            inicio = nuevo;
        }
    }

    public void insertarFin(int dato) {
        Nodo nuevo = new Nodo(dato, fin, inicio);
        if (esVacia()) {
            inicio = fin = nuevo;
        } else {
            inicio.setAnterior(nuevo);
            fin.setSiguiente(nuevo);
            fin = nuevo;
        }
    }

    public void imprimir() {
        Nodo aux = inicio;
        do {
            System.out.println(aux.getDato());
            aux = aux.getSiguiente();
        } while (aux != inicio);

    }

}

package prylistascircular;


/**
 *
 * @author laboratorio
 */
public class Hilo implements Runnable {

    private Circular lista;
    private int min;
    private int max;

    public Hilo(Circular lista, int min, int max) {
        this.lista = lista;
        this.min = min;
        this.max = max;
    }

    @Override
    public void run() {

        for (int i = min; i < max; i++) {
            int acum = 0;
            for (int j = 1; j <= i / 2; j++) {
                if (i % j == 0) {
                    acum += j;
                }

            }
            if (acum == i) {
                lista.insertarFin(i);
                System.out.println("Inserto; " + i);
            }
        }

    }

}

package prylistascircular;

/**
 *
 * @author laboratorio
 */
public class PryListasCircular {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws InterruptedException {
        // TODO code application logic here

        Circular lista = new Circular();

        Hilo h1 = new Hilo(lista, 1, 1000);
        h1.run();
        Hilo h2 = new Hilo(lista, 8000, 9000);
        h2.run();
        Hilo h3 = new Hilo(lista, 33550030, 33551000);
        h3.run();
        h1.join();
        h2.join();
        h3.join();

        lista.imprimir();

    }

}

Casos de prueba, qué son, cómo se realizan, definición de los casos de prueba.

CASOS DE PRUEBA

Introducción

Un aspecto esencial en el control de calidad del software son las pruebas. Una prueba de software es todo proceso orientado a comprobar la calidad del software mediante la identificación de fallos en el mismo. 
Existe un tipo de pruebas denominadas funcionales, en las cuales se hace una verificación del comportamiento del sistema, para ello se debe realizar un conjunto seleccionado de ejecuciones controladas (planificadas).

Las pruebas permiten detectar en qué puntos el producto no cumple sus especificaciones, es decir, comprobar su funcionalidad, esto implica  necesariamente la ejecución del software.

Cómo ya se mencionó anteriormente se debe realizar una planificación que consiste en definir los aspectos a examinar y la forma de verificar su correcto funcionamiento, punto en el cual adquieren sentido los casos de prueba.

Definición

Según la definición del ISTQB:" Los casos de prueban son un conjunto de valores de entrada, precondiciones de ejecución, resultados esperados y postcondiciones de ejecución, desarrollados para un objetivo particular de condición de prueba, tal como para ejercer una ruta de un programa en particular o para verificar el cumplimiento de un requisito específico."

Para que sirven?

Los casos de prueba sirven para determinar que un requisito es completamente satisfactorio. Son un insumo clave en el proceso de automatización de pruebas.
Los casos de prueba se desarrollan para definir las cosas que es necesario validar a fin de asegurar que el sistema funciona correctamente y está construido con un alto nivel de calidad.

Algunas metodologías como RUP recomiendan crear por lo menos dos casos de prueba para cada requisito. Uno de ellos debe realizar la prueba positiva de los requisitos y el otro debe realizar la prueba negativa.

Mejores prácticas para un buen caso de prueba

1. Los casos de prueba deben ser simples y transparentes. Deben ser claros y concisos, ya que el creador del caso de prueba no puede realizarlos.

2. Haga un caso de prueba con el usuario final en mente. Un probador debe hacer casos de prueba con la perspectiva del usuario final en mente.

3. Evitar la repetición de casos de prueba. Si se requiere un caso de prueba para llevar a cabo otro caso de prueba, llame al caso de prueba sobre la base del ID del caso de prueba.

4. No abandone la aplicación entregada. No asuma una aplicación que funcione mientras prepara el caso de prueba. Cumpla con los requisitos y documentos de diseño.

5. Proporcionar cobertura 100%. Asegúrese de crear casos de prueba que verifiquen todos los requisitos de software que se enumeran. 

6. Los casos de prueba deben ser identificables.  Proporcione un nombre a la ID del caso de prueba para que pueda identificarse fácilmente. Esto es útil para detectar errores o identificar un requisito en una etapa posterior.

7. Repetible e independiente. El caso de prueba debe generar los mismos resultados cada vez, independientemente de quién ejecute la prueba.
8. Revisión por pares

Una vez que haya realizado los casos de prueba, los evaluará un colega. Sus colegas pueden encontrar errores en sus casos de prueba, que usted mismo pasó por alto.

Ejemplo de Casos de prueba.

Hay una variedad de formatos para elaborar casos de prueba, en realidad no existe un formato único y estandarizado, dado que dependiendo el negocio o escenario será necesario personalizar los datos para ajustarlo a lo que se requiere probar, sin embargo hay campos mínimos que se deben contemplar en todos los casos de prueba.

lista circular simple, listas enlazadas, estructura de datos circular, estructura de datos con java

En el ejercicio se presentan listas circulares las cuales están formadas por las clases Nodo Simple y ListaCircular, se realiza con listas enlazadas simples un solo enlace hacia el siguiente nodo, el ejercicio realiza inserción de nodos y la impresión de datos.

package listacircular;

public class Nodo {
    
    private int valor;
    // Variable para enlazar los nodos.
    private Nodo siguiente;
    
    public Nodo(){
        this.valor = 0;
        this.siguiente = null;
    }

    public Nodo(int valor, Nodo siguiente) {
        this.valor = valor;
        this.siguiente = siguiente;
    }

    public int getValor() {
        return valor;
    }

    public void setValor(int valor) {
        this.valor = valor;
    }

    public Nodo getSiguiente() {
        return siguiente;
    }

    public void setSiguiente(Nodo siguiente) {
        this.siguiente = siguiente;
    }
    
}

package listacircular;


package prylistascircular;

/**
 *
 * @author laboratorio
 */
public class Circular {

    private Nodo inicio;
    private Nodo fin;

    public Circular() {
        inicio = fin = null;
    }

    public boolean esVacia() {
        return inicio == null && fin == null;
    }

    public void insertarInicio(int dato) {
        Nodo nuevo = new Nodo(dato, fin, inicio);
        if (esVacia()) {
            inicio = fin = nuevo;
        } else {
            inicio.setAnterior(nuevo);
            fin.setSiguiente(nuevo);
            inicio = nuevo;
        }
    }

    public void insertarFin(int dato) {
        Nodo nuevo = new Nodo(dato, fin, inicio);
        if (esVacia()) {
            inicio = fin = nuevo;
        } else {
            inicio.setAnterior(nuevo);
            fin.setSiguiente(nuevo);
            fin = nuevo;
        }
    }

    public void imprimir() {
        Nodo aux = inicio;
        do {
            System.out.println(aux.getDato());
            aux = aux.getSiguiente();
        } while (aux != inicio);

    }

}

package prylistascircular;


/**
 *
 * @author laboratorio
 */
public class Hilo implements Runnable {

    private Circular lista;
    private int min;
    private int max;

    public Hilo(Circular lista, int min, int max) {
        this.lista = lista;
        this.min = min;
        this.max = max;
    }

    @Override
    public void run() {

        for (int i = min; i < max; i++) {
            int acum = 0;
            for (int j = 1; j <= i / 2; j++) {
                if (i % j == 0) {
                    acum += j;
                }

            }
            if (acum == i) {
                lista.insertarFin(i);
                System.out.println("Inserto; " + i);
            }
        }

    }

}

package prylistascircular;

/**
 *
 * @author laboratorio
 */
public class PryListasCircular {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws InterruptedException {
        // TODO code application logic here

        Circular lista = new Circular();

        Hilo h1 = new Hilo(lista, 1, 1000);
        h1.run();
        Hilo h2 = new Hilo(lista, 8000, 9000);
        h2.run();
        Hilo h3 = new Hilo(lista, 33550030, 33551000);
        h3.run();

        lista.imprimir();

    }

}

Ordenar a medida que vamos insertando datos en una estructura de datos tipo lista doblemente enlazada

Ejercicio en java de estructuras de datos Ordenar a medida que vamos insertando datos en una estructura de datos tipo lista doblemente enlazada Se crea un método insertar que recibe un parámetro que corresponde con el dato del nodo a instar en la Lista, según las condiciones se insertará el nuevo nodo en el inicio, en el centro de la lista o en el final.

public class Lista {
    
    private Nodo inicio;
    private Nodo fin;

    public Lista() {       
        inicio=fin=null;
    }
    
    public boolean esVacio(){
        return inicio==fin && fin==null;
    }
    
    public void insertarOrdenado(int dato) {
        if (!esVacio()) {
            Nodo nuevo;
            if (dato < inicio.getDato()) {
                nuevo = new Nodo(null, inicio, dato);
                inicio.setAnterior(nuevo);
                inicio = nuevo;
            } else {
                Nodo aux = inicio;
                while (aux != null && dato > aux.getDato()) {
                    aux = aux.getSiguiente();
                }
                if (aux != null) {
                    nuevo = new Nodo(aux.getAnterior(), aux, dato);
                    aux.getAnterior().setSiguiente(nuevo);
                    aux.setAnterior(nuevo);
                } else {
                    nuevo = new Nodo(fin, null, dato);
                    fin.setSiguiente(nuevo);
                    fin = nuevo;

                }

            }
        } else {
            Nodo nuevo = new Nodo(null, null, dato);
            inicio = fin = nuevo;

        }

    }
    
    public void imprimir(){
        Nodo aux= inicio;
        while(aux != null){
            System.out.println(aux.getDato());
            aux= aux.getSiguiente();
        }
    }
}

Colas con prioridad ejemplo java

En este ejericio vamos a desarrollar en el lenguaje java un ejercicio que permita insertar datos en una cola con prioridad, para ello debemos crear 3 clases; la primera será la clase nodo la cual va tener 3 atributos, la segunda clase será clase Lista, la misma que tendrá el método para insertar datos según la prioridad que le corresponda en la lista. y finalmente la clase que realizará la invocación, instanciando los objetos necesarios para que funcione nuestro ejemplo de colas con prioridad.
En un proyecto de java crear una nueva Clase con nombre Nodo

package colasprioridad;

/**
 *
 * @author paulo.guerra.teran
 */
public class Nodo {
    
    private int valor;
    // Atributo para enlazar los nodos.
    private Nodo siguiente;
    
    int prioridad;

    Nodo(int valor, int prioridad) {
       this.valor=valor;
       this.prioridad=prioridad;
    }

    Nodo() {
       
    }
    
    public void Nodo(){
        this.valor = 0;
        this.siguiente = null;
    }

    public int getValor() {
        return valor;
    }

    public void setValor(int valor) {
        this.valor = valor;
    }

    public Nodo getSiguiente() {
        return siguiente;
    }

    public void setSiguiente(Nodo siguiente) {
        this.siguiente = siguiente;
    }

    @Override
    public String toString() {
        return "Nodo{" + "valor=" + valor + ", prioridad=" + prioridad + '}';
    }
    
    
    
}

Sobre el mismo paquete del proyecto crear una nueva Clase con nombre ListaSimple

package colasprioridad;

/**
 *
 * @author paulo.guerra.teran
 */
public class ListaSimple {

    private Nodo inicio;
    // Puntero que indica el final de la lista o el ultimo nodo.
    private Nodo ultimo;

    public void Lista() {
        inicio = null;
        ultimo = null;
    }



    public void agregar(int valor, int prioridad) {
        Nodo nuevo = new Nodo(valor, prioridad);

        if (inicio == null) {
            inicio = ultimo = nuevo;
        } else {

            if (inicio.prioridad > prioridad) {
                nuevo.setSiguiente(inicio);
                inicio=nuevo;
            }else{
              Nodo ant=null;
              Nodo sig=inicio;
              while(sig!=null && prioridad>=sig.prioridad){
                  ant=sig;
                  sig=sig.getSiguiente();
              }
              nuevo.setSiguiente(sig);
              ant.setSiguiente(nuevo);
              if(sig==null){
                 ultimo=nuevo;
              }
            
            }

        }
    }

    void imprimir() {
        Nodo aux = inicio;
        do {
            System.out.println("" + aux);
            aux = aux.getSiguiente();
        } while (aux != null);

    }

}

Sobre el mismo paquete del proyecto crear una nueva Clase con nombre

package listacircular;


/**
 *
 * @author paulo.guerra.teran
 */
public class ColaPrioridad {

    
    public static void main(String[] args) {
        ListaSimple ls=new ListaSimple();
        System.out.println("Agrego nodo (100) cualquier prioridad (2)");
        ls.agregar(100, 2);
        System.out.println("Agrego nodo (200) prioridad igual al primer nodo (2)");
        ls.agregar(200, 2);
        ls.imprimir();
        System.out.println("Agrego nodo (300) prioridad 1");
        ls.agregar(300, 1);
        ls.imprimir();
        System.out.println("Agrego nodo (400) de prioridad final");
        ls.agregar(400, 3);
        ls.imprimir();
        
        
    }
}

La ejecución del programa la podemos ver en la siguiente imagen!

Ejemplo de árboles, estructura de datos no lineales, trees java, tutorial de estructura de datos

El siguiente ejemplo presenta una estructura de datos conocida como árboles, específicamente este ejemplo trata de emular las instancias finales de un campeonato de fútbol.
Como descripción tendremos tres niveles, en el primer nivel se encontrará el equipo campeón que representa la raiz del árbol, luego en el siguiente nivel, se encontrará 2 equipos de fútbol que representan los finalistas, finalmente en esta estructura de datos por cada nodo del nivel 2(finalistas) tendrán 2 equipos que representan los equipos que participaron en las semifinales.

Se presentan las siguientes clases para resolver este ejercicio de estructura de datos utilizando árboles.

1. Clase Equipo(Nombre, goles)
2. Clase NodoArbol
3. Clase Arbol
4. Clase NodoCola
5. Clase Cola.
6. Clase Principal.

 Vamos a crear la clase Equipo la cual va contener 2 atributos: Nombre y Goles.

package pryarbolequipo;

import java.util.Random;

public class Equipo {
    private String nombre;
    private int goles;

    public Equipo(String nombre,boolean caso) {
        this.nombre = nombre;
        if(caso)
          goles=generarGoles();
        else
          goles=-1;  
    }
     
    public int generarGoles() {
        Random aleatorio=new Random();
        int gol=aleatorio.nextInt();
        if(gol<0)
            gol=gol*(-1);
        gol=gol%8;
        goles=gol;
        return goles;
    }

    public String getNombre() {
        return nombre;
    }

    public int getGoles() {
        return goles;
    }

    @Override
    public String toString() {
        if(goles==-1)
            return "Equipo Campeon: "+nombre;
        else
            return "Equipo "+nombre+" goles=" + goles;
    }    
}

La clase NodoArbol va contener 3 atributos: un Objeto Equipo y dos objetos de la clase NodoArbol, pues es un árbol binario que tiene una referencia hacia el nodo izquierdo y otro para el lado derecho.

package pryarbolequipo;

/**
 *
 * @author Paulo Guerra
 */
public class NodoArbol {

    private Equipo datos;
    private NodoArbol iz;
    private NodoArbol der;

    public NodoArbol(Equipo datos) {
        this.datos = datos;
        iz = der = null;
    }

    public NodoArbol(Equipo datos, NodoArbol iz, NodoArbol der) {
        this.datos = datos;
        this.iz = iz;
        this.der = der;
    }

    public Equipo getDatos() {
        return datos;
    }

    public void setDatos(Equipo datos) {
        this.datos = datos;
    }

    public NodoArbol getIz() {
        return iz;
    }

    public void setIz(NodoArbol iz) {
        this.iz = iz;
    }

    public NodoArbol getDer() {
        return der;
    }

    public void setDer(NodoArbol der) {
        this.der = der;
    }

}

La clase Arbol que es la estructura de datos principal de nuestro ejercicio, contiene como atributo a la raiz, la cual es un objeto de tipo NodoArbol creado anteriormente. Además posee los métodos necesarios para unir con otros 2 nodos para ir formando el árbol de abajo hacia arriba.

package pryarbolequipo;

/**
 *
 * @author Paulo Guerra
 */
public class Arbol {

    private NodoArbol raiz;

    public Arbol() {
        raiz = null;
    }

    public Arbol(Equipo datos) {
        raiz = new NodoArbol(datos);
    }

    public NodoArbol getRaiz() {
        return raiz;
    }

    public void unir(Equipo datos, NodoArbol iz, NodoArbol der) {
        if (iz == der) {
            System.out.println("No se puede unir");
            return;
        }
        raiz = new NodoArbol(datos, iz, der);

    }

    public void recorridoAnchura() {
        if (raiz != null) {
            Cola cola = new Cola();
            cola.encolar(raiz);
            Cola colaAux = new Cola();
            while (!cola.esVacio()) {
                NodoArbol aux = cola.desencolar().getNodoDatos();
                if (aux.getIz() != null) {
                    cola.encolar(aux.getIz());
                }
                if (aux.getDer() != null) {
                    cola.encolar(aux.getDer());
                }
                colaAux.encolar(aux);

            }
            colaAux.imprimir();

        }

    }

}

Al implementar el recorrido por Anchura de un árbol necesitamos implementar la estructura de datos Cola por lo que vamos a necesitar crear los Nodos de la Cola los mismos que van a contener como datos, nodos de la clase Árbol(NodoArbol).

package pryarbolequipo;

/**
 *
 * @author Paulo Guerra
 */
public class NodoCola {
    
    private NodoArbol nodoDatos;
    private NodoCola siguiente;

    public NodoCola(NodoArbol nodoDatos, NodoCola siguiente) {
        this.nodoDatos = nodoDatos;
        this.siguiente = siguiente;
    }

    public NodoArbol getNodoDatos() {
        return nodoDatos;
    }

    public void setNodoDatos(NodoArbol nodoDatos) {
        this.nodoDatos = nodoDatos;
    }

    public NodoCola getSiguiente() {
        return siguiente;
    }

    public void setSiguiente(NodoCola siguiente) {
        this.siguiente = siguiente;
    }
        
}

La Clase Cola implementa cuatro métodos importantes. 1. encolar 2. desencolar 3. verificar si está Vacía la Cola 4. imprimir toda la Cola.

package pryarbolequipo;

/**
 *
 * @author cisco
 */
public class Cola {

    private NodoCola inicio;
    private NodoCola fin;

    public Cola() {
        inicio = fin = null;
    }

    public void encolar(NodoArbol datos) {
        NodoCola nuevo = new NodoCola(datos, null);
        if (inicio == fin && inicio == null) {
            inicio = fin = nuevo;
        } else {
            fin.setSiguiente(nuevo);
            fin = nuevo;
        }
    }

    public NodoCola desencolar() {
        NodoCola aux = inicio;
        inicio = inicio.getSiguiente();
        if (inicio == null) {
            fin = null;
        }
        return aux;
    }

    public boolean esVacio() {
        return inicio == null;
    }

    public void imprimir() {
        NodoCola aux = inicio;
        while (aux != null) {
            System.out.println(aux.getNodoDatos().getDatos().toString());
            aux = aux.getSiguiente();
        }

    }
}

Finalmente la invocación de la clase principal será como se muestra a continuación:

package pryarbolequipo;

/**
 *
 * @author Paulo Guerra
 */
public class Principal {

    /**
     * @param args the command line arguments
     */
    public static Equipo ganador(Equipo eA, Equipo eB){
           while(eA.getGoles()==eB.getGoles()){
                eA.generarGoles();
                eB.generarGoles();
           }
           if(eA.getGoles()>eB.getGoles())
               return new Equipo(eA.getNombre(),false);
           else
               return new Equipo(eB.getNombre(), false);
    
    }
       
    public static void main(String[] args) {
        // TODO code application logic here
        Arbol eq1=new Arbol(new Equipo("Ecuador", true));
        Arbol eq2=new Arbol(new Equipo("Colombia", true));
        Arbol sf1=new Arbol();
        sf1.unir(ganador(eq1.getRaiz().getDatos(),eq2.getRaiz().getDatos()), 
                eq1.getRaiz(),eq2.getRaiz());
        
        Arbol eq3=new Arbol(new Equipo("Argentina", true));
        Arbol eq4=new Arbol(new Equipo("Brasil", true));
        Arbol sf2=new Arbol();
        sf2.unir(ganador(eq3.getRaiz().getDatos(),eq4.getRaiz().getDatos()), 
                eq3.getRaiz(),eq4.getRaiz());
     
        Arbol campeon=new Arbol();
        campeon.unir(ganador(sf1.getRaiz().getDatos(), sf2.getRaiz().getDatos()),
                sf1.getRaiz(),sf2.getRaiz());
        campeon.recorridoAnchura();
    }
    
}

Ejecución run:
Equipo Campeon: Argentina
Equipo Ecuador goles=0
Equipo Argentina goles=7
Equipo Ecuador goles=5
Equipo Colombia goles=0
Equipo Argentina goles=2
Equipo Brasil goles=0
BUILD SUCCESSFUL (total time: 0 seconds)

Para interpretar el resultado de la estructura de datos árbol, se explica a continuación:
El Equipo que está en la raíz es el campeón (Argentina). La final la jugó frente a Ecuador.
Ecuador clasificó ganando el encuentro frente a Colombia y Argentina clasificó ganando el encuentro frente a Brasil.

Generación de datos aleatorios en java.

public int generarGolesAleatorios(){
        Random ra=new Random();
        int gol=ra.nextInt();
        gol=gol<0?gol*(-1):gol;
        gol=gol%6;
        goles=gol;
        return goles;
}

Lectura de archivos java y pasar a una Lista Simplemente enlazada

Ejemplo de lectura de archivos y Lista Simples

En este ejemplo se muestra cómo realizar la lectura de datos desde un archivo, cada línea del archivo contiene campos que se encuentran separados por un caracter especial, una vez que se lee la línea se debe separar cada uno de las palabras y pasarlos a ser almacenados en una Lista simplemente enlazada que va creciendo dinámicamente.

 Crear en Eclipse un nuevo proyecto de java, en mi caso LecturaArchivo.  A continuación se presenta la imagen del proyecto.

En un archivo de texto voy a tener el siguiente contenido:

Crear la Clase Nodo 

public class Nodo {
      private String palabra;
      private Nodo siguiente;
 public Nodo(String palabra, Nodo siguiente) {
  super();
  this.palabra = palabra;
  this.siguiente = siguiente;
 }
 public String getPalabra() {
  return palabra;
 }
 public void setPalabra(String palabra) {
  this.palabra = palabra;
 }
 public Nodo getSiguiente() {
  return siguiente;
 }
 public void setSiguiente(Nodo siguiente) {
  this.siguiente = siguiente;
 }
       
}

Crear la Clase Lista
Para esta clase vamos a crear cuatro métodos principales el agregarNodoFinal la cual se encarga de ir creando un nodo dinámicamente al final de la lista, la cual contiene una palabra leida desde el fichero. El segundo método es imprimir la lista en pantalla para verificar que se guardó la información en la lista simple. Un tercer método que se va encargar de leer un archivo que se le pasa el path/ubicación por parámetro y lo que hace es ir leyendo linea a linea y en un texto auxiliar se va acumulando los Strings, Finalmente se separan el texto auxiliar que tiene acumulado todo el texto del fichero y se separa cada una de las palabras.

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.StringTokenizer;


public class Lista {
 Nodo inicio;
 Nodo fin;
 public Lista() {
  
  inicio=fin=null;
 }
 
 public void agregarNodoFinal(String dato){
  Nodo nuevo=new Nodo(dato,null);
  if(inicio==null){
   inicio=fin=nuevo;
  }else{
   fin.setSiguiente(nuevo);
   fin=nuevo;
   
  }
  
 }
 
 public void imprimir(){
  Nodo aux=inicio;
  while(aux!=null){
   System.out.println(aux.getPalabra());
   aux=aux.getSiguiente();
  }      
 }
 
 
 public String leerArchivo(String path){
  
  String total="";
  try {
   FileReader fr=new FileReader(new File(path));
   BufferedReader br=new BufferedReader(fr);
   
   String linea="";
   while(  (linea=br.readLine())!=null){
    total=total+linea+"\n";
    
   }
   
   
  } catch (FileNotFoundException e) {
   // TODO Auto-generated catch block
   System.out.println("Problemas de archivo: "+e.getMessage());
  } catch (IOException e) {
   // TODO Auto-generated catch block
   System.out.println("Problemas en la lectura del archivo: "+e.getMessage());
  }
  
  return total;
  
  
 }
 
 
 public Lista separar(String total){
  System.out.println(total);
  Lista coleccion=new Lista();
  StringTokenizer st = new StringTokenizer(total, " \n,");
        while (st.hasMoreTokens()) {
            String palabra = st.nextToken();
            coleccion.agregarNodoFinal(palabra);
       }
  return coleccion;
  
 }
 
 

}

La clase Principal (Lectura) consta del siguiente código:

public class Lectura {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        Lista inform=new Lista();
        String total=inform.leerArchivo("texto.txt");
        Lista resultado=inform.separar(total);
        resultado.imprimir();
        
    }
    
}

Estructura de datos java, eliminar nodo, insertar nodo, imprimir

En el siguiente Ejercicio se pretende crear un listado de estudiantes (Curso) utilizando memoria dinámica, específicamente mediante la estructura de datos lista lineal simple, es decir que solo tiene un único enlace. Para el ejercicio se tienen diferentes clases:
1. Estudiante con 3 atributos: nombre, cédula, y edad.
2. Nodo la cual va a contener 2 atributos: Estudiante y siguiente (referencia al nodo siguiente)
3. Lista, es un clase la cual contiene los apuntadores inicio y fin y los métodos de inserción, impresión y eliminación.
4. Clase principal la cual realizará la invocación a la clase lista y demás para verificar su utilización. 

A continuación se presenta el código de la clase Estudiante:

package prylistassimple;

public class Estudiante {
    
    private String nombre;
    private String cedula;
    private int edad;

    public Estudiante() {
    }

    public Estudiante(String nombre, String cedula, int edad) {
        this.nombre = nombre;
        this.edad = edad;
        this.cedula=cedula;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public int getEdad() {
        return edad;
    }

    public void setEdad(int edad) {
        this.edad = edad;
    }
  
    public String getCedula() {
        return cedula;
    }

    public void setCedula(String cedula) {
        this.cedula = cedula;
    }    
}

No se olviden de consultar por palabras claves! Ejemplo de Estructura de datos en java, tutorial de estructura de datos

Búsqueda personalizada

A continuación se presenta el código de la clase Nodo:

package prylistassimple;

public class Nodo {
    private Estudiante alumno;
    private Nodo siguiente;

    public Nodo(Estudiante alumno) {
        this.alumno = alumno;
        siguiente=null;
    }

    public Nodo(Estudiante alumno, Nodo siguiente) {
        this.alumno = alumno;
        this.siguiente = siguiente;
    }

    public Estudiante getAlumno() {
        return alumno;
    }

    public void setAlumno(Estudiante alumno) {
        this.alumno = alumno;
    }

    public Nodo getSiguiente() {
        return siguiente;
    }

    public void setSiguiente(Nodo siguiente) {
        this.siguiente = siguiente;
    }
  
}

A continuación se presenta el código de la clase lista:

package prylistassimple;


public class Lista {

    Nodo inicio;
    Nodo fin;

    public Lista() {
        inicio = null;
        fin = null;
    }

    public void agregarNodoAlInicio(Estudiante obj) {
        Nodo nuevo = new Nodo(obj, inicio);
        inicio = nuevo;
        if (fin == null) {
            fin = nuevo;
        }
    }

    public void agregarNodoAlFinal(Estudiante obj) {
        Nodo nuevo = new Nodo(obj);
        // nuevo.setSiguiente(null);
        if (fin != null) {
            fin.setSiguiente(nuevo);
            fin = nuevo;
        } else {
            fin = nuevo;
            inicio = nuevo;
        }
    }

    public void recorreLista() {
        Nodo aux = inicio;
        int cont=1;
        while (aux != null) {
            System.out.println(cont +". "+aux.getAlumno().getNombre()+ "-"+aux.getAlumno().getCedula());
            cont++;
            aux = aux.getSiguiente();
        }

    }

    public void eliminarInicio() {

        if (inicio != fin) {
            Nodo aux = inicio;
            inicio = inicio.getSiguiente();
            aux = null;
        } else {
            inicio = null;
            fin = null;
        }

    }

    public boolean eliminarNodo(String cedula) {

        if (inicio != null) {//Vericación que existan nodos en la lista

            if (inicio == fin && inicio.getAlumno().getCedula().compareTo(cedula) == 0) { //Si solo existe un único nodo
                inicio = fin = null;
                return true;
            } else if (inicio.getAlumno().getCedula().compareTo(cedula) == 0) { //Si la cedula se encuentra en el primer nodo
                inicio=inicio.getSiguiente(); //Apuntamos el inicio al siguiente nodo
                return true;
            } else {
                //necesitamos dos Nodos 
                Nodo anterior = inicio; //anterior apuntando al inicio
                Nodo temporal = inicio.getSiguiente(); //temporal al siguiente nodo del anterior
                //Debemos recorrer todos los nodos de la lista hasta encontrar una cedula o hasta el final (temporal sea null)
                while (temporal != null && temporal.getAlumno().getCedula().compareTo(cedula) != 0) {
                    anterior=anterior.getSiguiente(); //desplazamos al siguiente nodo
                    temporal=temporal.getSiguiente(); // desplazamos al siguiente nodo de la lista
                }
                //Cuando llegue a este punto pudo ser si encontró una cédula o llegó al fin
                //preguntamos si fue diferente de null (es decir que halló un nodo) 
                //el proceso es eliminar el nodo donde está el temporal
                //Por lo tanto se requiere enlazar el anterior con el enlace siguiente del temporal
                if (temporal != null) {
                    anterior.setSiguiente(temporal.getSiguiente());
                    if (temporal == fin) { // puede darse el caso que el temporal sea el último nodo por lo que debemos referenciar
                        fin = anterior;        // el nuevo fin hacia el anterior
                    }
                    return true;
                }

                return false;
            }

        }return false;

    }

}

A continuación se presenta el código de la clase Principal:

public class Principal {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        
        Lista coleccion=new Lista();
        
        Estudiante alumnoA=new Estudiante("Juan","12345", 20);
        coleccion.agregarNodoAlInicio(alumnoA);
        coleccion.agregarNodoAlFinal(new Estudiante("Santiago","1234321", 11));
        coleccion.agregarNodoAlInicio(new Estudiante("Anabel","09876", 50));
        System.out.println("Imprimir los elementos agregados hasta el momento");
        coleccion.recorreLista();
        System.out.println("Eliminar inicio");
        coleccion.eliminarInicio();
        coleccion.recorreLista();
        coleccion.agregarNodoAlFinal(new Estudiante("Alberto","7765",80));
        System.out.println("Imprimir lista");
        coleccion.recorreLista();
        
        String cedula=JOptionPane.showInputDialog("Ingrese la cédula del estudiante a eliminar");
        if(coleccion.eliminarNodo(cedula)){
            System.out.println("estudiante con cedula No. "+cedula+" borrado");
            System.out.println("Listado actual");
            coleccion.recorreLista();
                   
        }else{
            System.out.println("No existe estudiante con cedula No."+cedula);
        }
    }
    
}

Juego tres en raya en java, tic tac toe en java

A continuación se presenta el código fuente desarrollado en el lenguaje de programación java, el juego es conocido como tic-tac-toe o en otro lugares como tres en raya.

Lo primero que debemos realizar es un nuevo proyecto.
A continuación debemos crear la Clase Juego con sus respectivos métodos por ejemplo:

1. Imprimir el tablero
2. ComprobarEspacioDisponible
3. AgregarFichaTablero
4. gana
5. ConocerCoordenadas

Observe el código fuente del Juego TIC TAC TOE desarrollado en java.

package prytictactoe;

/**
 *
 * @author paulo.guerra.teran
 */
public class Juego {

    private final int ROWS = 3;
    private final int COLUMNS = 3;
    char[][] board = {{'1', '2', '3'}, {'4', '5', '6'}, {'7', '8', '9'}};

    private int x;
    private int y;

    public void imprimirTablero() {

        System.out.println("Tablero de juego");
        for (int i = 0; i < ROWS; i++) {

            for (int j = 0; j < COLUMNS; j++) {
                System.out.print("" + board[i][j] + "");
                if (j < COLUMNS - 1) {
                    System.out.print(" ║ ");
                }

            }
            System.out.println("");
            if (i < COLUMNS - 1) {
                System.out.println("═   ═   ═");
            }
        }

    }

    public void conocerCoordenadas(int valor) {

        switch (valor) {
            case 1:
                x = 0;
                y = 0;
                break;
            case 2:
                x = 0;
                y = 1;
                break;
            case 3:
                x = 0;
                y = 2;
                break;
            case 4:
                x = 1;
                y = 0;
                break;
            case 5:
                x = 1;
                y = 1;
                break;
            case 6:
                x = 1;
                y = 2;
                break;
            case 7:
                x = 2;
                y = 0;
                break;
            case 8:
                x = 2;
                y = 1;
                break;
            case 9:
                x = 2;
                y = 2;
                break;
            default:
                System.out.println("No existe una posición");

        }

    }

    public boolean comprobarEspacioDisponible(int valor) {

        conocerCoordenadas(valor);
        boolean disponible = true;

        if (board[x][y] == 'X' || board[x][y] == 'O') {
            return false;
        } else {
            return true;
        }

    }

    public void asignarFichaTablero(char ficha, int valor) {
        conocerCoordenadas(valor);
        board[x][y] = ficha;
    }

    public boolean gana(char ficha) {
        for (int i = 0; i < board.length; i++)//horizontales
        {
            int cont = 0; //contador para saber cuantas fichas iguales hay
            for (int j = 0; j < board.length; j++) {
                if (board[i][j]==ficha) {
                    cont++;
                }
            }
            if (cont == 3) {
                return true;
            }
        }

        for (int j = 0; j < board.length; j++)//verticales
        {
            int cont = 0; //contador para saber cuantas fichas iguales hay
            for (int i = 0; i < board.length; i++) {
                if (board[i][j]==ficha) {
                    cont++;
                }
            }
            if (cont == 3) {
                return true;
            }
        }

        //diagonal
        if ((board[0][0]==ficha) && (board[1][1]==ficha) && (board[2][2]==ficha)) {
            return true;
        }
        if ((board[0][2]==ficha) && (board[1][1]==ficha) && (board[2][0]==ficha)) {
            return true;
        }

        return false;

    }

}

Una ves que se tiene la lógica del juego mediante los métodos lo que debemos hacer es programar el programa principal el cual tiene el objetivo de realizar la invocaciones necesarias hacia los métodos de la clase. En esta sección se presenta el código que va a controlar los turnos y la parte de invocación para el control del juego. Si tienen alguna duda no duden en contactarme.

package prytictactoe;

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

/**
 *
 * @author paulo.guerra.teran
 */
public class PryTICTACTOE {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws IOException {
        // TODO code application logic here
       
        Juego tictacInstance=new Juego();
        tictacInstance.imprimirTablero();
        
        Scanner opcion=new Scanner(System.in);
        int dato;
        boolean ganador=false;
        char ficha;
        for(int turno=1;turno<=9;turno++){
           boolean valido=true;
           ficha = (turno%2==0) ? 'X' : 'O';
            do{
                System.out.println("Seleccione una opcion (1-9): ");
                dato=opcion.nextInt();
                valido=tictacInstance.comprobarEspacioDisponible(dato);
           }while(!valido);  
           tictacInstance.asignarFichaTablero(ficha, dato);
           tictacInstance.imprimirTablero();
           if(turno>5)
               if(tictacInstance.gana(ficha)){
                    System.out.println("Ganó "+ficha);
                    ganador=true;
                    break;
               }
        }
        if(!ganador){
            System.out.println("Empate!");
        }
        
        
    }
    
}

trabajar con fechas java, fechas java mysql, datetime mysql, date mysql java

En primer lugar debemos crear una base de datos en MySQL en mi caso la base tiene como nombre facturación, en esta base he creado una Tabla Factura, con los siguientes campos idFactura(int,Autoincremental y Clave Primaria),fecha (DATETIME), fechaCorta (DATE)

CREATE TABLE `factura` (
  `idFactura` int(11) NOT NULL auto_increment,
  `Fecha` datetime default NULL,
  `FechaCorta` date default NULL,
  PRIMARY KEY  (`idFactura`)
)

Creamos un nuevo Proyecto de java y en el Método main programamos el siguiente código

public static void main(String[] args) throws ClassNotFoundException, SQLException {
        // TODO code application logic here

        java.util.Date dt = new java.util.Date();
        java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String fechaHora = sdf.format(dt);
        Class.forName("com.mysql.jdbc.Driver");
        Connection cn = DriverManager.getConnection("jdbc:mysql://localhost/facturacion", "root", "pauloguerra");
        
        java.util.Date dtc = new java.util.Date();
        java.text.SimpleDateFormat sdfc = new java.text.SimpleDateFormat("yyyy-MM-dd");
        String yyyymmdd = sdf.format(dtc);
        
        PreparedStatement ps = cn.prepareStatement("insert into Factura(fecha,fechaCorta) values(?,?)");
        ps.setString(1, fechaHora);
        ps.setString(2, yyyymmdd);
        ps.executeUpdate();

    }

Dar clic sobre nuestro proyecto, seleccionar Propiedades, librerías/Bibliotecas y dar clic en agregar librerías, buscamos la libreria MYSQL como se observa en las siguientes imágenes

Lectura de archivos en java con delimitadores

Lectura de archivos con delimitadores:

Archivo almacenado consta de la siguiente información:

avila#12#24#soleado
toledo#16#15#soleado
madrid#15#27#soleado
barcelona#12#20#nublado

Crear un nuevo proyecto en Netbeans y Crear una Clase Clima:

package proyectoarchivos;

/**
 *
 * @author PauloGT
 */
public class Clima {
    
    private String ciudad;
    private int min;
    private int max;
    private String condicion;

    public Clima() {
    }

    @Override
    public String toString() {
        return "Clima{" + "ciudad=" + ciudad + ", min=" + min + ", max=" + max + ", condicion=" + condicion + '}';
    }
    

    public Clima(String ciudad, int min, int max, String condicion) {
        this.ciudad = ciudad;
        this.min = min;
        this.max = max;
        this.condicion = condicion;
    }

    /**
     * @return the ciudad
     */
    public String getCiudad() {
        return ciudad;
    }

    /**
     * @return the min
     */
    public int getMin() {
        return min;
    }

    /**
     * @return the max
     */
    public int getMax() {
        return max;
    }

    /**
     * @return the condicion
     */
    public String getCondicion() {
        return condicion;
    }

    /**
     * @param ciudad the ciudad to set
     */
    public void setCiudad(String ciudad) {
        this.ciudad = ciudad;
    }

    /**
     * @param min the min to set
     */
    public void setMin(int min) {
        this.min = min;
    }

    /**
     * @param max the max to set
     */
    public void setMax(int max) {
        this.max = max;
    }

    /**
     * @param condicion the condicion to set
     */
    public void setCondicion(String condicion) {
        this.condicion = condicion;
    }
           
}

Creamos una clase GestionarInformacion para leer el archivo y pasar la información a Objetos

package proyectoarchivos;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.StringTokenizer;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author PauloGT
 */
public class GestionInformacion {

    File archivo = null;
    FileReader fr = null;
    BufferedReader br = null;
    ArrayList lineas = new ArrayList();
    ArrayList climasCiudad = new ArrayList();

    public void separadores(String linea) {
        StringTokenizer st = new StringTokenizer(linea, "#");
        System.out.println("Datos Personales: ");
        int i = 0;
        String palabras[] = new String[st.countTokens()];
        while (st.hasMoreTokens()) {
            palabras[i] = st.nextToken();
            i++;
       }
        climasCiudad.add(new Clima(palabras[0], Integer.parseInt(palabras[1]), Integer.parseInt(palabras[2]), palabras[3]));
    }

    public ArrayList devolverObjetos() {
        return climasCiudad;
    }

    public void leerArchivo(String nombre) {
        try {
            archivo = new File(nombre);
            fr = new FileReader(archivo);
            br = new BufferedReader(fr);

            // Lectura del fichero
            String linea;
            try {
                while ((linea = br.readLine()) != null) {
                    System.out.println(linea);
                    separadores(linea);
                }

            } catch (IOException ex) {
                Logger.getLogger(GestionInformacion.class.getName()).log(Level.SEVERE, null, ex);
            }
        } catch (FileNotFoundException ex) {
            Logger.getLogger(GestionInformacion.class.getName()).log(Level.SEVERE, null, ex);
        }
        
            
        

    }
}

Finalmente realizamos la llamada a las clases creadas

public static void main(String[] args) {
        // TODO code application logic here
        GestionInformacion obj=new GestionInformacion();
        obj.leerArchivo("clientes.txt");
        for (Clima x :obj.devolverObjetos()) {
            System.out.println(x.toString());
        }
        
    }

Este ejercicio hace la simulación de un formulario que hace una consulta, la cual se demora en la "búsqueda" por lo que aparenta que el formulario está colgado pues una vez presionado el botón no podemos seleccionar ningún elemento del ComboBox.

package hilos2;


import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JComboBox;

/**
 *
 * @author PauloGT
 */
public class Ventana extends Frame {
 
private JButton boton;
   private JComboBox combo;
   
   public Ventana(){
     setLayout(new FlowLayout());
     add(boton=new JButton("Este duerme el proceso: "));
     boton.addActionListener(new EscuchaBoton());
    add(combo=new JComboBox());
    combo.addItem("Item 1");
    combo.addItem("Item 1");
    combo.addItem("Item 1");
    setSize(300,300);
   
   }
   
   class EscuchaBoton implements ActionListener{

 @Override
 public void actionPerformed(final ActionEvent arg0) {
   
    // Simulación de que hace la consulta y se demora
    try {
    Thread.sleep(10000);
     System.out.println("Finalizo el proceso.. ");
   } catch (final InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
 }
   }
}

El main de nuestra aplicación sería:

public static void main(String[] args) {
        // TODO code application logic here
        Ventana obj=new Ventana();
        obj.setVisible(true);
     
    }

Para Solucionar este tipo de problemas debemos usar hilos, por lo que necesitamos simplemente cambiar el código de nuestro programa de la siguiente manera:

package hilos2;


import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JFrame;


/**
 *
 * @author PauloGT
 */
public class Ventana_1 extends Frame {
 
private JButton boton;
   private JComboBox combo;
   
   public Ventana_1(){
     setLayout(new FlowLayout());
     add(boton=new JButton("Este duerme el proceso: "));
     boton.addActionListener(new EscuchaBoton());
    add(combo=new JComboBox());
    combo.addItem("Item 1");
    combo.addItem("Item 1");
    combo.addItem("Item 1");
    setSize(300,300);
   
   }
   
   class EscuchaBoton implements ActionListener{

 @Override
 public void actionPerformed(final ActionEvent arg0) {
   
    
   boton.setEnabled(false);
                        TareaBoton t=new TareaBoton();  // Creamos una instancia de la clase Hilo que creamos
                        t.start(); // ejecutamos el hijo
  
 }
    
   }
   
   class TareaBoton extends Thread{    
     // creamos una innerclass que derive de los Hilos y manejamos todo lo que deseamos realizar en el método run.
       public void run(){
    
           try {
  Thread.sleep(10000);
  System.out.println("Finalizo el proceso.. ");
  } catch (final InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
      }
   
   }
}

Con esto nuestra aplicación no tendrá el problema de que aparenta estar congelado!!! Cualquier novedad pueden hacer sus comentarios.

Recuperar el código autogenerado despues de un insert

A continuación se describen las sentencias necesarias para realizar una sentencias insert hacia la base de datos, y recuperar el código autogenerado de dicho insert.

public void insertarAlumno2(Connection cn, Alumno obj)throws Exception{

//Generamos la sentencias insert

String sql="INSERT INTO ALUMNO VALUES (null,'"+obj.getNombre()
+"','"+obj.getDireccion()+"','"+obj.getTelefono()+"')";

//Creamos el objeto Statement en la que se debe especificar que deseamos recuperar las claves generadas

PreparedStatement ps = cn.prepareStatement(sql,PreparedStatement.RETURN_GENERATED_KEYS);
//Ejecutamos la sentencias sql
ps.executeUpdate();  

// Recuperamos los resultados en el objeto resulset
ResultSet rs = ps.getGeneratedKeys();


while (rs.next()) {
int claveGenerada = rs.getInt(1);
System.out.println("Clave generada = " + claveGenerada);
}

Cómo realizar la comparación de 2 imágenes y determinar si son iguales o similares

Esta entrada contiene el código para determinar si 2 imagenes son iguales, si puede variar los parámetros para que dos imágenes que tienen similitud los reconozca como similares.

Está realizado en Netbeans en un proyecto en consola para ello se debe crear un nuevo proyecto Java Aplication, para mi caso el nombre es ComparacionImagen.

A continuación crear una nueva clase, dar clic sobre el paquete y luego crear la Clase ImageCompare.

package comparacionimagen;
import javax.swing.*;
import java.io.*;
import java.util.*;
import java.awt.*;
import java.awt.image.*;
import com.sun.image.codec.jpeg.*;

 public class ImageCompare {

 protected BufferedImage img1 = null;
 protected BufferedImage img2 = null;
 protected BufferedImage imgc = null;
 protected int comparex = 0;
 protected int comparey = 0;
 protected int factorA = 0;
 protected int factorD = 10;
 protected boolean match = false;
 protected int debugMode = 0; // 1: textual indication of change, 2: difference of factors

 // constructor 1. use filenames
 public ImageCompare(String file1, String file2) {
  this(loadJPG(file1), loadJPG(file2));
 }

 // constructor 2. use awt images.
 public ImageCompare(Image img1, Image img2) {
  this(imageToBufferedImage(img1), imageToBufferedImage(img2));
 }

 // constructor 3. use buffered images. all roads lead to the same place. this place.
 public ImageCompare(BufferedImage img1, BufferedImage img2) {
  this.img1 = img1;
  this.img2 = img2;
  autoSetParameters();
 }

 // like this to perhaps be upgraded to something more heuristic in the future.
 protected void autoSetParameters() {
  comparex = 10;
  comparey = 10;
  factorA = 10;
  factorD = 10;
 }

 // set the parameters for use during change detection.
 public void setParameters(int x, int y, int factorA, int factorD) {
  this.comparex = x;
  this.comparey = y;
  this.factorA = factorA;
  this.factorD = factorD;
 }

 // want to see some stuff in the console as the comparison is happening?
 public void setDebugMode(int m) {
  this.debugMode = m;
 }

 // compare the two images in this object.
 public void compare() {
  // setup change display image
  imgc = imageToBufferedImage(img2);
  Graphics2D gc = imgc.createGraphics();
  gc.setColor(Color.RED);
  // convert to gray images.
  img1 = imageToBufferedImage(GrayFilter.createDisabledImage(img1));
  img2 = imageToBufferedImage(GrayFilter.createDisabledImage(img2));
  // how big are each section
  int blocksx = (int)(img1.getWidth() / comparex);
  int blocksy = (int)(img1.getHeight() / comparey);
  // set to a match by default, if a change is found then flag non-match
  this.match = true;
  // loop through whole image and compare individual blocks of images
  for (int y = 0; y < comparey; y++) {
   if (debugMode > 0) System.out.print("|");
   for (int x = 0; x < comparex; x++) {
    int b1 = getAverageBrightness(img1.getSubimage(x*blocksx, y*blocksy, blocksx - 1, blocksy - 1));
    int b2 = getAverageBrightness(img2.getSubimage(x*blocksx, y*blocksy, blocksx - 1, blocksy - 1));
    int diff = Math.abs(b1 - b2);
    if (diff > factorA) { // the difference in a certain region has passed the threshold value of factorA
     // draw an indicator on the change image to show where change was detected.
     gc.drawRect(x*blocksx, y*blocksy, blocksx - 1, blocksy - 1);
     this.match = false;
    }
    if (debugMode == 1) System.out.print((diff > factorA ? "X" : " "));
    if (debugMode == 2) System.out.print(diff + (x < comparex - 1 ? "," : ""));
   }
   if (debugMode > 0) System.out.println("|");
  }
 }

 // return the image that indicates the regions where changes where detected.
 public BufferedImage getChangeIndicator() {
  return imgc;
 }

 // returns a value specifying some kind of average brightness in the image.
 protected int getAverageBrightness(BufferedImage img) {
  Raster r = img.getData();
  int total = 0;
  for (int y = 0; y < r.getHeight(); y++) {
   for (int x = 0; x < r.getWidth(); x++) {
    total += r.getSample(r.getMinX() + x, r.getMinY() + y, 0);
   }
  }
  return (int)(total / ((r.getWidth()/factorD)*(r.getHeight()/factorD)));
 }


 // returns true if image pair is considered a match
 public boolean match() {
  return this.match;
 }

 // buffered images are just better.
 protected static BufferedImage imageToBufferedImage(Image img) {
  BufferedImage bi = new BufferedImage(img.getWidth(null), img.getHeight(null), BufferedImage.TYPE_INT_RGB);
  Graphics2D g2 = bi.createGraphics();
  g2.drawImage(img, null, null);
  return bi;
 }

 // write a buffered image to a jpeg file.
 protected static void saveJPG(Image img, String filename) {
  BufferedImage bi = imageToBufferedImage(img);
  FileOutputStream out = null;
  try {
   out = new FileOutputStream(filename);
  } catch (java.io.FileNotFoundException io) {
   System.out.println("File Not Found");
  }
  JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);
  JPEGEncodeParam param = encoder.getDefaultJPEGEncodeParam(bi);
  param.setQuality(0.8f,false);
  encoder.setJPEGEncodeParam(param);
  try {
   encoder.encode(bi);
   out.close();
  } catch (java.io.IOException io) {
   System.out.println("IOException");
  }
 }

 // read a jpeg file into a buffered image
 protected static Image loadJPG(String filename) {
  FileInputStream in = null;
  try {
   in = new FileInputStream(filename);
  } catch (java.io.FileNotFoundException io) {
   System.out.println("File Not Found");
  }
  JPEGImageDecoder decoder = JPEGCodec.createJPEGDecoder(in);
  BufferedImage bi = null;
  try {
   bi = decoder.decodeAsBufferedImage();
   in.close();
  } catch (java.io.IOException io) {
   System.out.println("IOException");
  }
  return bi;
 }

}

En el método main debemos ir calibrando a nuestras necesidades

package comparacionimagen;


/**
 *
 * @author Paulo
 */
public class Main {

  

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
       // Especificamos las imagenes que deseamos comparar, cada imagene debe tener una dimension de 300 x 225.
  ImageCompare ic = new ImageCompare("e:\\test1.jpg", "e:\\test5.jpg");
  // Set the comparison parameters.
  //   (numero de regiones verticales, numero de regiones horizontales, sensibilidad, stabilizer)
  ic.setParameters(12, 12, 15, 10); 
                 // Display some indication of the differences in the image.
  ic.setDebugMode(2);
  // Compare.
  ic.compare();
  // Display if these images are considered a match according to our parameters.
  System.out.println("Match: " + ic.match());
  // si las imagenes son distintas se creará una nueva imagen con nombre changes.jpg en la que se muestre las regiones que son distintas pues sobrepasan la sensibilidad.
  if (!ic.match()) {
   ImageCompare.saveJPG(ic.getChangeIndicator(), "e:\\changes.jpg");
  }
 }

}

Información tomada de http://mindmeat.blogspot.com/2008/07/java-image-comparison.html