Programación fácil con JAVA

Spring Framework y el ciclo de vida MVC

2016-06-03T11:55:00.001-05:00

Spring Framerowk se adhiere el paradigma de programación Modelo-Vista-Controlador (MVC) para el desarrollo de sus proyectos.
Cuando se crea una aplicacion Java SE web todo se hace en torno a un Servlet central, que es el encargado de seleccionar que controlador se encarga de cada respuesta, y dentro de cada uno de estos controladores se realizan las tareas necesarias para servirla.

Spring Framework nos provee para desempeñar la tarea de Servlet central de DispatcherServlet, lo que hace especial a este Servlet, es que aparte de desempeñar las tareas de comunes de despachador, tiene una completa integración con Spring IoC.

Tal y como podemos ver en la imagen anterior, DispatcherServlet realiza las tareas de Controlador Frontal, delega en el Controlador de cada llamada las operaciones internas requeridas para realizar la respuesta y una vez que este le devuelve la información necesaria para emitir dicha respuesta DispatcherServlet delega en un ViewResolver el renderizado de la respuesta.

Típicamente esta acción se realizada con la clase ModelAndView, en dicha clase el Controlador cargaba los datos y el nombre de la vista para que esta fuera renderizada.

public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
Map myModel= new HashMap();
miModelo.put("integer_value", 500);
miModelo.put("string_value", "cadena aleatoria");
ModelAndView miMAV = new ModelAndView();
miMAV.setViewName("my_currently_view");
miMAV.addObject(myModel);
return miMAV;
}

Con la aparición de los Controladores por anotaciones (@Controller), esta operación ha variado significativamente, utilizandose la clase Model a través del Controlador para registrar los datos que serán utilizados por la vista, la cual es devuelta en el retorno del método del controlador.

Leer Excel desde Java con POI

2012-12-04T17:04:00.001-05:00

Hola tal vez alguna ves hemos necesitado leer un archivo excel desde java y no hemos tenido idea de como hacerlo.
Bueno les traigo un método bien fácil y practico para esto necesitamos usar la api Apache POI.
Adjunto el código para que puedan observarlo.
Admite tanto Xls como Xlsx ,estan separados en métodos distintos para que observen las diferencias.
Para esto necesitaran los siguientes plugins:

xbean.jar
dom4j-2.0.0-ALPHA-2.jar ( o la version1.4 da lo mismo)
poi-ooxml-schemas-3.8-20120326.jar
poi-ooxml-3.8-20120326.jar
poi-3.8-20120326.jar

CODIGO EJEMPLO:


import java.io.File;
import java.io.FileInputStream;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

/**

 * @author jonathan-palomino.blogspot.com

 */

public class LectorExcel {

 boolean antiguo = false;
 /**

  * Este metodo es usado para leer archivos Excel

  *

  * @param Nombre_Archivo

  *            - Nombre de archivo Excel.

  */
 private void Leer_Archivo_Excel(String Nombre_Archivo) {

  /**

   * Crea una nueva instancia de Lista_Datos_Celda

   */

  List Lista_Datos_Celda = new ArrayList();

  if (Nombre_Archivo.contains(".xlsx")) {

   GENERAR_XLSX(Nombre_Archivo, Lista_Datos_Celda);

   antiguo = false;

  } else if (Nombre_Archivo.contains(".xls")) {

   GENERAR_XLS(Nombre_Archivo, Lista_Datos_Celda);

   antiguo = true;

  }

  /**

   * Llama el metodo Imprimir_Consola para imprimir los datos de la celda

   * en la consola.

   */

  Imprimir_Consola(Lista_Datos_Celda);

 }

 private void GENERAR_XLSX(String Nombre_Archivo, List Lista_Datos_Celda) {

  try {

   /**

    * Crea una nueva instancia de la clase FileInputStream

    */

   FileInputStream fileInputStream = new FileInputStream(

     Nombre_Archivo);

   /**

    * Crea una nueva instancia de la clase XSSFWorkBook

    */

   XSSFWorkbook Libro_trabajo = new XSSFWorkbook(fileInputStream);

   XSSFSheet Hoja_hssf = Libro_trabajo.getSheetAt(0);

   /**

    * Iterar las filas y las celdas de la hoja de cálculo para obtener

    * toda la data.

    */

   Iterator Iterador_de_Fila = Hoja_hssf.rowIterator();

   while (Iterador_de_Fila.hasNext()) {

    XSSFRow Fila_hssf = (XSSFRow) Iterador_de_Fila.next();

    Iterator iterador = Fila_hssf.cellIterator();

    List Lista_celda_temporal = new ArrayList();

    while (iterador.hasNext()) {

     XSSFCell Celda_hssf = (XSSFCell) iterador.next();

     Lista_celda_temporal.add(Celda_hssf);

    }

    Lista_Datos_Celda.add(Lista_celda_temporal);

   }

  } catch (Exception e) {

   e.printStackTrace();

  }

 }

 private void GENERAR_XLS(String Nombre_Archivo, List Lista_Datos_Celda) {

  try {

   /**

    * Crea una nueva instancia de la clase FileInputStream

    */

   FileInputStream fileInputStream = new FileInputStream(

     Nombre_Archivo);

   /**

    * Crea una nueva instancia de la clase POIFSFileSystem

    */

   POIFSFileSystem fsFileSystem = new POIFSFileSystem(fileInputStream);

   /**

    * Crea una nueva instancia de la clase HSSFWorkBook

    */

   HSSFWorkbook Libro_trabajo = new HSSFWorkbook(fsFileSystem);

   HSSFSheet Hoja_hssf = Libro_trabajo.getSheetAt(0);

   /**

    * Iterar las filas y las celdas de la hoja de cálculo para obtener

    * toda la data.

    */

   Iterator Iterador_de_Fila = Hoja_hssf.rowIterator();

   while (Iterador_de_Fila.hasNext()) {

    HSSFRow Fila_hssf = (HSSFRow) Iterador_de_Fila.next();

    Iterator iterador = Fila_hssf.cellIterator();

    List Lista_celda_temporal = new ArrayList();

    while (iterador.hasNext()) {

     HSSFCell Celda_hssf = (HSSFCell) iterador.next();

     Lista_celda_temporal.add(Celda_hssf);

    }

    Lista_Datos_Celda.add(Lista_celda_temporal);

   }

  } catch (Exception e) {

   e.printStackTrace();

  }

 }

 /**

  * Este método se utiliza para imprimir los datos de la celda a la consola.

  *

  * @param Datos_celdas

  *            - Listado de los datos que hay en la hoja de cálculo.

  */

 private void Imprimir_Consola(List Datos_celdas) {

  String Valor_de_celda;

  for (int i = 0; i < Datos_celdas.size(); i++) {

   List Lista_celda_temporal = (List) Datos_celdas.get(i);

   for (int j = 0; j < Lista_celda_temporal.size(); j++) {

    if (antiguo) {

     HSSFCell hssfCell = (HSSFCell) Lista_celda_temporal.get(j);

     Valor_de_celda = hssfCell.toString();

    } else {

     XSSFCell hssfCell = (XSSFCell) Lista_celda_temporal.get(j);

     Valor_de_celda = hssfCell.toString();

    }

    System.out.print(Valor_de_celda + "\t");

   }

   System.out.println();

  }

 }

 public static void main(String[] args) {

  String fileName = "C:" + File.separator + "Users" + File.separator

    + "synccon" + File.separator + "Desktop" + File.separator

    + "abc.xls";

  System.out.println(fileName);

  new LectorExcel().Leer_Archivo_Excel(fileName);

 }

}

Estructuras dinámicas

2012-07-10T17:00:00.001-05:00

Hola ,hace mucho tiempo que tenemos estructuras optimas para guardar datos como las listas genéricas o los treemap pero a modo de ejemplo vamos a reinventar la rueda.
Lo que intentaremos haces es una estructura doble con 2 apuntadores en memoria para que así puedas ir de derecha a izquierda y viceversa en cualquier momento.
Nos referimos a un nodo doble aquí unas imágenes para obtener una idea.

Nodo inicial con 2 apuntadores inicialmente a null

El nodo final con la misma idea.
Agreguemos una estructura nueva se vería así:

Aqui vemos un nodo inicio apuntando hacia un nodo con datos.
Si aplicamos la misma idea tendremos lo siguiente:

Entonces tenemos una estructura dinámica en memoria ya que los datos se pierden al cerrar el programa o si es que apuntan los nodos inicio y fin a nulo así el recolector de basura los elimina.
Vamos de plano al código:

/**
 *
 * @author jonathan-palomino.blogspot.com
 */
//Clase para una lista doble :
public class NodoDoble {
	private Productos Producto;// informacion
	private NodoDoble ApuntAnt;	// enlace con el anterior
	private NodoDoble ApuntSgte;// enlace con el siguiente

	// constructor
	NodoDoble(Productos Producto){this.Producto=Producto;}
//Esta clase productos será una clase que podrá contener N datos que se podrán setear desde un aplicativo algo así como capas.
	// get/set
        void setPro(Productos Producto){this.Producto=Producto;}
	void setApuntSgte(NodoDoble ApuntSgte){this.ApuntSgte=ApuntSgte;}
	void setApuntAnt(NodoDoble ApuntAnt){this.ApuntAnt = ApuntAnt;}

	Productos getPro(){return Producto;	}
	NodoDoble getApuntSgte(){return ApuntSgte;	}
	NodoDoble getApuntAnt(){return ApuntAnt;	}
}// fin de la clase de nodo doble

Para la clase enlazadora donde podremos poner la lógica de agregación para que trabaje.

/**
 *
 * @author jonathan-palomino.blogspot.com
 */
public class ListaDobleConOrden{
	private NodoDoble inicio;
	private NodoDoble fin;

	// constructor
	ListaDobleConOrden(){inicio=null; fin=null;}

	// get/set
	void setInicio(NodoDoble inicio){this.inicio=inicio;	}
	void setFin(NodoDoble fin){this.fin=fin;	}
	NodoDoble getInicio(){return inicio;	}
	NodoDoble getFin(){ return fin;	}

	// metodos de administracion
	void agrega(Productos Producto){
		NodoDoble nuevo, auxiliar;

		//...preparar nuevo nodo ...
 		nuevo = new NodoDoble(Producto);
		nuevo.setApuntSgte(null);
		nuevo.setApuntAnt(null);

		//...adicionar nuevo nodo a la lista...
		if(inicio == null) {
			//primer nodo
			inicio = nuevo;
			fin = inicio;
		} else //Por codigo orden
                if(Producto.getCodigo().compareTo(
                    inicio.getPro().getCodigo())<0) {
                    //antes del primer nodo
                    nuevo.setApuntSgte(inicio);
                    inicio.setApuntAnt(nuevo);
                    inicio = nuevo;
                } else
                if(Producto.getCodigo().compareTo(
                    fin.getPro().getCodigo())>0 ||
			Producto.getCodigo().compareTo(
                    fin.getPro().getCodigo())==0)	{
                    //después del último nodo
                    nuevo.setApuntAnt(fin);
                    fin.setApuntSgte(nuevo);
                    fin = nuevo;
		} else {
                    //entre dos nodos ya existentes
                    auxiliar = inicio;

                    // ubica el anterior
                    while(Producto.getCodigo().compareTo(
			auxiliar.getPro().getCodigo())>0||
			Producto.getCodigo().compareTo(
			auxiliar.getPro().getCodigo())==0) {
                auxiliar = auxiliar.getApuntSgte();
            }

                    // enlaza
                    nuevo.setApuntSgte(auxiliar);
                    nuevo.setApuntAnt(auxiliar.getApuntAnt());
                    auxiliar.getApuntAnt().setApuntSgte(nuevo);
                    auxiliar.setApuntAnt(nuevo);
		}
	}
	//.....busca un codigo en la lista
	NodoDoble busca(String codigo) {
            // empieza por el primero de la lista
            NodoDoble Auxiliar = inicio;

            // mientras no sea nulo
            while(Auxiliar != null)	{
		if(codigo.equals(Auxiliar.getPro().getCodigo()))
                    return Auxiliar;// lo encontró
		else
                    Auxiliar = Auxiliar.getApuntSgte(); // pasa al siguiente
	}// fin del while
	// terminó la lista y no lo encontró
	return null;
	}
}//fin de la clase ListaDobleConOrden

La clase productos solo es una clase de seteo u getteo de valores:

public class Productos {

private  String Codigo;
    // constructor vacío
    public Productos(){ }
    // constructor que recibe un objeto con datos
    public Productos(Productos obj)
    {
        Codigo = obj.getCodigo();
    }
    public String getCodigo() {
        return Codigo;
    }
    public void setCodigo(String Codigo) {
        this.Codigo = Codigo;
    }
}

Para ejemplo de uso:

public class Principal{
static ListaDobleConOrden ldco =new ListaDobleConOrden();
Productos Productos;
public static void main(String args[]){
ldco.setInicio(null);
    Productos =new Productos();
    Productos.setDescripcion( "abc" );
    ldco.agrega(Productos);
}
}

En caso necesites buscar algo se puede usar

NodoDoble auxiliar = Principal.ldco.busca(codigo);

Jtable con Checkboxs

2012-06-01T17:00:00.001-05:00

Si en alguna oportunidad has necesitado poner checkbox en un Jtable y no tubiste ni idea aquí veremos lo fácil que resulta.
Todo va dentro de un arreglo estático pero Uds pueden ponerlo en un for while u otra estructura de control antes de lanzar el agregado o la función getTable()
Adjunto el código:

/** 
* 
* @author http://jonathan-palomino.blogspot.com/ 
* 
*/ 
import javax.swing.SwingUtilities; 
import java.awt.BorderLayout; 
import javax.swing.JPanel; 
import javax.swing.JFrame; 
import javax.swing.UIManager;
import javax.swing.JScrollPane; 
import javax.swing.JTable; 
import javax.swing.table.DefaultTableModel;
public class J_table extends JFrame {
    private static final long serialVersionUID = 1L; 
    private JPanel jContentPane = null; 
    private JScrollPane scroll = null; 
    private JTable Table = null; 
    Object[] columnas = {"ACTIVOS", "NOMBRE", "EDAD"}; 
    Object[][] datos = { 
        {true,"JOSE",50}, 
        {false,"ANDREA",12}, 
        {true,"IVETTE",18}, 
        {false,"JUAN",18}};
    /** 
     * This method initializes scroll    
     *     
     * @return javax.swing.JScrollPane    
     */ 
    private JScrollPane getScroll() { 
        if (scroll == null) { 
            scroll = new JScrollPane(); 
            scroll.setViewportView(getTable()); 
        } 
        return scroll; 
    }
    /** 
     * This method initializes Table    
     *     
     * @return javax.swing.JTable    
     */ 
    private JTable getTable() { 
        if (Table == null) { 
             DefaultTableModel modelo = new DefaultTableModel(datos, columnas) { 
                    public Class getColumnClass(int column) { 
                        return getValueAt(1, column).getClass(); 
                    } 
                }; 
            Table = new JTable(modelo); 
           
        } 
        return Table; 
    }
    /** 
     * @param args 
     */ 
    public static void main(String[] args) { 
        // TODO Auto-generated method stub 
        SwingUtilities.invokeLater(new Runnable() { 
            public void run() { 
                try{ 
                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName()); 
                }catch(Exception e) { 
                    e.printStackTrace(); 
                } 
                J_table thisClass = new J_table(); 
                thisClass.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
                thisClass.setVisible(true); 
            } 
        }); 
    }
    /** 
     * This is the default constructor 
     */ 
    public J_table() { 
        super(); 
        initialize(); 
    }
    /** 
     * This method initializes this 
     * 
     * @return void 
     */ 
    private void initialize() { 
        this.setSize(609, 281); 
        this.setContentPane(getJContentPane()); 
        this.setTitle("JTable con checkbox por http://jonathan-palomino.blogspot.com/"); 
        this.setLocationRelativeTo(null); 
    }
    /** 
     * This method initializes jContentPane 
     * 
     * @return javax.swing.JPanel 
     */ 
    private JPanel getJContentPane() { 
        if (jContentPane == null) { 
            jContentPane = new JPanel(); 
            jContentPane.setLayout(new BorderLayout()); 
            jContentPane.add(getScroll(), BorderLayout.CENTER); 
        } 
        return jContentPane; 
    }
}

Jlabel editable con tecla Enter

2012-06-01T16:51:00.001-05:00

En este caso podremos editar en tiempo de ejecución un Jlabel con la tecla Enter con lo cual lo podremos modificar a nuestro gusto.
Dejo el código para que lo prueben:

/** 
* 
* @author http://jonathan-palomino.blogspot.com/ 
* 
*/ 
import javax.swing.SwingUtilities; 
import java.awt.BorderLayout; 
import javax.swing.JPanel; 
import javax.swing.JFrame; 
import javax.swing.JTextField;
import java.awt.CardLayout; 
import java.awt.event.KeyAdapter; 
import java.awt.event.KeyEvent; 
import java.awt.event.MouseAdapter; 
import java.awt.event.MouseEvent;
import javax.swing.JLabel; 
import java.awt.Font; 
import javax.swing.SwingConstants;
public class principal extends JFrame {
    private static final long serialVersionUID = 1L; 
    private JPanel jContentPane = null; 
    private JPanel panel_edicion = null; 
    private JLabel etiqueta_editable = null; 
    /*************************************/ 
    //si el usuario hizo enter 
    private static final int confirmar = KeyEvent.VK_ENTER; 
    //si es usuario pulso escape 
    private static final int cancelo = KeyEvent.VK_ESCAPE; 
    private CardLayout card;//utilizo el carlayotu para manejar varios objetos dentro del mismo panel 
    private static final String txt_caja = "text field";  //  @jve:decl-index=0: 
    private JTextField caja_edicion; 
    private static final String LABEL = "label"; 
    private String valor=new String("");
    /** 
     * This method initializes panel_edicion    
     *     
     * @return javax.swing.JPanel    
     */ 
    private JPanel getPanel_edicion() { 
        if (panel_edicion == null) { 
            card = new CardLayout(); 
            etiqueta_editable = new JLabel(); 
            etiqueta_editable.setText("Programación fácil con JAVA"); 
            etiqueta_editable.setHorizontalAlignment(SwingConstants.CENTER); 
            etiqueta_editable.setFont(new Font("Dialog", Font.BOLD, 48)); 
            etiqueta_editable.addMouseListener(new MouseAdapter() { 
                public void mouseClicked(MouseEvent e) { 
                    //si el usurario hizo doble clic encima de la etiqueta 
                    if (e.getClickCount() == 2) { 
                        editando(); 
                    } 
                } 
            }); 
            caja_edicion = new JTextField(); 
            caja_edicion.addKeyListener(new KeyAdapter() { 
                public void keyReleased(KeyEvent e) { 
                    if (e.getKeyCode() == confirmar) { 
                        confirmar(); 
                    } else if (e.getKeyCode() == cancelo) { 
                        cancelar(); 
                    } 
                } 
            }); 
            panel_edicion = new JPanel(card); 
            panel_edicion.add(caja_edicion, txt_caja); 
            panel_edicion.add(etiqueta_editable, LABEL); 
            card.show(panel_edicion, LABEL); 
        } 
        return panel_edicion; 
    }
    /** 
     * @param args 
     */ 
    public static void main(String[] args) { 
        // TODO Auto-generated method stub 
        SwingUtilities.invokeLater(new Runnable() { 
            public void run() { 
                principal thisClass = new principal(); 
                thisClass.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
                thisClass.setVisible(true); 
            } 
        }); 
    }
    /** 
     * This is the default constructor 
     */ 
    public principal() { 
        super(); 
        initialize(); 
    }
    /** 
     * This method initializes this 
     * 
     * @return void 
     */ 
    private void initialize() { 
        this.setSize(864, 251); 
        this.setContentPane(getJContentPane()); 
        this.setTitle("JLabel editable en tiempo de ejecucion por jonathan-palomino.blogspot.com"); 
        this.setLocationRelativeTo(null); 
    }
    /** 
     * This method initializes jContentPane 
     * 
     * @return javax.swing.JPanel 
     */ 
    private JPanel getJContentPane() { 
        if (jContentPane == null) { 
            jContentPane = new JPanel(); 
            jContentPane.setLayout(new BorderLayout()); 
            jContentPane.add(getPanel_edicion(), BorderLayout.CENTER); 
        } 
        return jContentPane; 
    } 
    /*********************************************/ 
    private void editando() { 
        card.show(getPanel_edicion(), txt_caja); 
        caja_edicion.setText(valor); 
        caja_edicion.requestFocus(); 
        caja_edicion.selectAll(); 
    }
    private void cancelar() { 
        caja_edicion.setText(valor); 
        card.show(getPanel_edicion(), LABEL); 
    }
    public void confirmar() { 
        valor = caja_edicion.getText(); 
        etiqueta_editable.setText(valor); 
        card.show(getPanel_edicion(), LABEL); 
    } 
    
}

Aplicando sombra un texto

2012-06-01T16:46:00.001-05:00

Hola,quien no ha querido aplicar efectos al titulo de una aplicación en este caso aplicaremos sombra y su inclinación como tamaño según parámetros.
Así obtendrán esta imagen

/** 
* 
* @author http://jonathan-palomino.blogspot.com/ 
* 
*/ 
import javax.swing.SwingUtilities; 
import java.awt.BorderLayout; 
import java.awt.Color; 
import java.awt.Font; 
import java.awt.Graphics; 
import java.awt.Graphics2D;
import javax.swing.JPanel; 
import javax.swing.JFrame; 
import java.awt.geom.AffineTransform;
public class Principal extends JFrame {
    private static final long serialVersionUID = 1L; 
    private JPanel jContentPane = null; 
    private int tamaño = 55; 
    private String mensaje = "Programación fácil con JAVA";  //  @jve:decl-index=0: 
    private int Width=50; 
        private double inclinacion_vertical =-0.95; 
        private double inclinacion_horizontal=0; 
        private double escala_altura=2; 
    /** 
     * @param args 
     */ 
    public static void main(String[] args) { 
        // TODO Auto-generated method stub 
        SwingUtilities.invokeLater(new Runnable() { 
            public void run() { 
                Principal thisClass = new Principal(); 
                thisClass.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
                thisClass.setVisible(true); 
            } 
        }); 
    }
    /** 
     * This is the default constructor 
     */ 
    public Principal() { 
        super(); 
        initialize(); 
        
    }
    /** 
     * This method initializes this 
     * 
     * @return void 
     */ 
    private void initialize() { 
        this.setSize(985, 257); 
        this.setResizable(false); 
        this.setLocationRelativeTo(null); 
        this.setContentPane(getJContentPane()); 
        this.setTitle("TEXTO CON SOMBRA"); 
        this.setBackground(Color.white); 
        Font font = new Font("DokChampa", Font.BOLD, tamaño); 
        this.setFont(font); 
    }
    /** 
     * This method initializes jContentPane 
     * 
     * @return javax.swing.JPanel 
     */ 
    private JPanel getJContentPane() { 
        if (jContentPane == null) { 
            jContentPane = new JPanel(); 
            jContentPane.setLayout(new BorderLayout()); 
        } 
        return jContentPane; 
    }
        public void paint(Graphics g) { 
            super.paint(g); 
            Graphics2D graph = (Graphics2D)g; 
            int x = Width; 
            int y = tamaño*5/2; 
            graph.translate(10, y); 
            graph.setPaint(Color.lightGray);            
            AffineTransform origTransform = graph.getTransform(); 
            graph.shear(inclinacion_vertical, inclinacion_horizontal); 
            graph.scale(1, escala_altura); 
            graph.drawString(mensaje, 0, 0); 
            graph.setTransform(origTransform); 
            graph.setPaint(Color.blue); 
            graph.drawString(mensaje, 0, 0); 
        } 
   
}

Crear un pop up en un boton

2012-04-20T13:03:00.001-05:00

Si querían poner un pop up en sus botones como menú de opciones esta es la forma les adjunto el código:

import javax.swing.JButton; 
import javax.swing.JFrame; 
import javax.swing.JLabel; 
import javax.swing.JMenuItem; 
import javax.swing.JPopupMenu;
/** 
* 
* @author jonathan-palomino.blogspot.com 
*/ 
public class Pop_Up extends JFrame{
    public Pop_Up() { 
        setSize(200,150); 
        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE); 
        prueba.setBounds(40, 40, 140, 50); 
        fantasma.setBounds(10, 10, 50, 30); 
        fantasma.setText(""); 
        prueba.setText("Boton padre"); 
        element.add(ele1); 
        element.add(ele2); 
        
        prueba.setComponentPopupMenu(element); 
        
        add(prueba); 
        add(fantasma); 
    } 
    public static void main(String[] args){ 
        Pop_Up ob = new Pop_Up(); 
        ob.show(); 
    } 
    JButton prueba = new JButton(); 
    JPopupMenu element = new JPopupMenu(); 
    JMenuItem ele1 = new JMenuItem("Elemento1");    
    JMenuItem ele2 = new JMenuItem("Elemento2"); 
    JLabel fantasma = new JLabel(); 
}

Zipear archivos

2012-04-20T12:14:00.001-05:00

Para zipear archivos desde java les traigo la siguiente clase:

/** 
* 
* @author jonathan-palomino.blogspot.com
*/ 
import java.util.logging.Level; 
import java.util.logging.Logger; 
import java.util.zip.*; 
import java.io.*; 
  
public class Zipear { 
    public static void Comprimir(String args[]) throws IOException{ 
              if (args.length < 2) { 
            System.err.println("use: Zip.zip file1 file2 file3"); 
            System.exit(-1); 
        } 
        File zipFile = new File(args[0]); 
        if (zipFile.exists()) { 
            System.err.println("Archivo Zip existente seleccione otro"); 
            System.exit(-2); 
        } 
        FileOutputStream fos = new FileOutputStream(zipFile); 
        ZipOutputStream zos = new ZipOutputStream(fos); 
        int bytesRead; 
        byte[] buffer = new byte[1024]; 
        CRC32 crc = new CRC32(); 
        for (int i=1, n=args.length; i < n; i++) { 
            String name = args[i]; 
            System.out.println("--------"+name); 
            File file = new File(name); 
            if (!file.exists()) { 
                System.err.println("Skipping: " + name); 
                continue; 
            } 
            BufferedInputStream bis = new BufferedInputStream( 
                new FileInputStream(file)); 
            crc.reset(); 
            while ((bytesRead = bis.read(buffer)) != -1) { 
                crc.update(buffer, 0, bytesRead); 
            } 
            bis.close(); 
            // Reset to beginning of input stream 
            bis = new BufferedInputStream( 
                new FileInputStream(file)); 
            ZipEntry entry = new ZipEntry(name); 
            entry.setMethod(ZipEntry.STORED); 
            entry.setCompressedSize(file.length()); 
            entry.setSize(file.length()); 
            entry.setCrc(crc.getValue()); 
            zos.putNextEntry(entry); 
            while ((bytesRead = bis.read(buffer)) != -1) { 
                zos.write(buffer, 0, bytesRead); 
            } 
            bis.close(); 
        } 
        zos.close(); 
    } 
    public static void main(String args[])  { 
        String argumentos[] = {"C:\\zip.zip","C:\\Test.pdf"}; 
        try { 
            Comprimir(argumentos); 
        } catch (IOException ex) { 
            Logger.getLogger(Zipear.class.getName()).log(Level.SEVERE, null, ex); 
        } 
    } 
}

Capturar pantalla

2012-04-20T11:58:00.001-05:00

Si queremos por algún motivo obtener la captura de pantalla con java aquí les dejo el código:

import java.awt.Dimension; 
import java.awt.Rectangle; 
import java.awt.Robot; 
import java.awt.Toolkit; 
import java.awt.image.BufferedImage; 
import java.util.logging.Level; 
import java.util.logging.Logger; 
import javax.imageio.ImageIO; 
import java.io.File; 
/** 
* 
* @author jonathan-palomino.blogspot.com 
*/ 
public class Capturar_pantalla { 
    
    public static void main(String [] args){ 
        try { 
            captureScreen("C:\\archivo.png"); 
        } catch (Exception ex) { 
            Logger.getLogger(Capturar_pantalla.class.getName()).log(Level.SEVERE, null, ex); 
        } 
    } 
    public static void captureScreen(String fileName) throws Exception { 
  
   Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize(); 
   Rectangle screenRectangle = new Rectangle(screenSize); 
   Robot robot = new Robot(); 
   BufferedImage image = robot.createScreenCapture(screenRectangle); 
   ImageIO.write(image, "png", new File(fileName)); 
  
} 
}

y lo guardan en “archivo.png” o el que deseen para este caso deje el método como static pero no es necesario.

Generar PDF

2012-04-20T11:42:00.001-05:00

El propósito de este post es generar un pdf sencillo mediante Java.

Nos vamos a la página http://sourceforge.net/projects/itext/files/ y descargamos iText. La importamos en nuestro proyecto yendo al menú Biblioteca—agregar archivo jar y seleccionamos los 2 jar.

El código

Se trata de una aplicación muy sencilla que escribirá en el pdf un párrafo con un saludo y otro con la fecha actual.

import com.itextpdf.text.Document;
import com.itextpdf.text.Paragraph;
import com.itextpdf.text.pdf.PdfWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.util.Date;

public class GeneratePDF {

    public static void main(String[] args) {
        try {
            OutputStream file = new FileOutputStream(new File("C:\\Test.pdf"));

            Document document = new Document();
            PdfWriter.getInstance(document, file);
            document.open();
            document.add(new Paragraph("Hola a todos!"));
            document.add(new Paragraph(new Date().toString()));

document.close();
file.close();

} catch (Exception e) {

            e.printStackTrace();
        }
    }
}

cambiar icono jframe

2012-04-20T10:58:00.001-05:00

1)El ícono debe ser una imagen de extensión PNG. Esto se hace más fácil, ya que conseguir una figura y convertirlo en formato .ico es muy complicado. Los PNG nos ayudan bastante.
2)La imagen que será el ícono debe estar dentro del paquete de fuentes, como si fuera una clase más. Si estuviera dentro de un paquete, sería mucho mejor.

3)En el código del JFrame que vamos a poner el ícono, sobreescribimos el método getIconImage() conteniendo el siguiente código: (notar cómo se está llamando a la imagen .png)
public Image getIconImage() {
Image retValue = Toolkit.getDefaultToolkit().
getImage(ClassLoader.getSystemResource("resources/icono.png"));
return retValue;
}
4)En la vista de diseño del JFrame, lo seleccionamos y vamos sus propiedades, buscamos la propiedad "iconImagen" y hacemos clic en el botón de puntos suspensivos. Se mostrará una ventana de diálogo como esta:

De la lista desplegable, seleccionamos "Valor de componente existente". Esto hará que cambie la ventana a la siguiente forma:

Seleccionamos la opción "Propiedad" y hacemos clic en el botón de puntos suspendidos. Aparecerá una ventana de diálogo más pequeña, y seleccionamos la propiedad "iconImage" que aparece ahí.

le damos Clic en Aceptar, y se verá así:

y nuevamente clic en "Aceptar" para cerrar la ventana de selección de imagen.
Ahora, veremos que las propiedades del JFrame ya tiene un nuevo valor

Ejecutamos la aplicación con el JFrame y veremos nuestro JFrame con un ícono diferente.

Validador de RUT

2011-10-02T00:30:00.000-05:00

Es una forma sencilla de obtener un rut completo a partir de los dígitos anteriores.
De facil uso ya que el método que obtiene el dígito de control es muy sencillo prácticamente de niños

package validador.rut;
/*
 * v.java
 *
 * Creado en 09/08/2011, 05:58:13 PM
 *
 * Aplicacion creada por jonathan-palomino.blogspot.com.
 *
 */

/**
 *
 * @author Jonathan palomino 
 */
class v {
static String RUT="12345678";
    public static void main(String args[]) {
        int M = 0, S = 1;
        int T = Integer.parseInt(RUT);
        for (; T != 0; T /= 10) {
            S = (S + T % 10 * (9 - M++ % 6)) % 11;
        }
        System.out.println(RUT+"-"+(char) (S != 0 ? S + 47 : 75));
    }
}

Usar Zoom en imagenes

2011-07-28T18:01:00.001-05:00

Alguna ves quisiste darle zoom a una imagen o quisiste agregar esa función a un proyecto tuyo pues ahora te traigo la solución.
Se trata de una clase o librería x decirlo asi que te dará esa habilidad.

package Zoom;

/**
 *
 * @author JONATHAN
 */
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.RenderingHints;
import java.awt.image.BufferedImage;
import javax.swing.JPanel;

public class Zoom extends JPanel {

    private Image FOTO_ORIGINAL;
    private Image FOTO_tmp;
    private BufferedImage Imagen_en_memoria;
    private Graphics2D g2D;
    private boolean con_foto = false;   

    private int valEscalaX=0;
    private int valEscalaY=0;

    /* al crear el objeto se crea con una imagen pasada como parametro*/
    public Zoom(BufferedImage f){
        this.FOTO_ORIGINAL = f;
        this.FOTO_tmp = f;
        this.setSize(f.getWidth(),f.getHeight());
        this.setVisible(true);
        this.con_foto=true;
    }

    @Override
    protected void paintComponent(Graphics g) {
      Graphics2D g2 = (Graphics2D)g;
      if(this.con_foto){
        Imagen_en_memoria = new BufferedImage(this.getWidth(), this.getHeight(), BufferedImage.TYPE_INT_RGB);
        g2D = Imagen_en_memoria.createGraphics();
        g2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        //se aÃ±ade la foto
        g2D.drawImage(FOTO_tmp,0, 0, FOTO_tmp.getWidth(this), FOTO_tmp.getHeight(this), this);
        g2.drawImage(Imagen_en_memoria, 0, 0, this);
      }
    }

    public void Aumentar(int Valor_Zoom){
        //se calcula el incremento
        valEscalaX =  (int) (FOTO_tmp.getWidth(this) * escala(Valor_Zoom) );
        valEscalaY =  (int) (FOTO_tmp.getHeight(this) * escala(Valor_Zoom) );
        //se escala la imagen sumado el nuevo incremento
        this.FOTO_tmp = FOTO_tmp.getScaledInstance((int) (FOTO_tmp.getWidth(this) + valEscalaX), (int) (FOTO_tmp.getHeight(this) + valEscalaY), Image.SCALE_AREA_AVERAGING);
        resize();
    }

    public void Disminuir(int Valor_Zoom){
        valEscalaX =  (int) (FOTO_tmp.getWidth(this) * escala(Valor_Zoom) );
        valEscalaY =  (int) (FOTO_tmp.getHeight(this) * escala(Valor_Zoom) );
        this.FOTO_tmp = FOTO_tmp.getScaledInstance((int) (FOTO_tmp.getWidth(this) - valEscalaX), (int) (FOTO_tmp.getHeight(this) - valEscalaY), Image.SCALE_AREA_AVERAGING);
        resize();
     }

    private float escala(int v){
        return  v/100f;
    }

    public void Restaurar(){
        this.FOTO_tmp = this.FOTO_ORIGINAL;
        resize();
    }

    private void resize(){
        this.setSize(FOTO_tmp.getWidth(this),FOTO_tmp.getHeight(this));
    }
}

Ahora los métodos para operar esta clase son los siguientes en este caso con este abrilos la imagen en un jpanel que estará dentro de un jscrollpane.
El motivo es para que la imagen al dimensionarse en el jpanel no dimensione tambien el jframe que se usara para visualizar el contenido

private void Abrir_Imagen() {
        fileChooser = new JFileChooser();
        fileChooser.setFileFilter(filter);
        fileChooser.setCurrentDirectory(Directorio);
        int result = fileChooser.showOpenDialog(null);
        if (result == JFileChooser.APPROVE_OPTION) {
            try {
                BufferedImage imagen = ImageIO.read(fileChooser.getSelectedFile());
                Cambiar(imagen.getWidth(), imagen.getHeight());
                zoom = new Zoom(imagen);
                this.Panel.removeAll();
                this.Panel.add(zoom);
                this.Panel.repaint();
                this.Directorio = fileChooser.getCurrentDirectory();
            } catch (IOException ex) {
                System.out.println("error: " + ex);
            }
        }
    }
    private void Cambiar(int alto, int ancho) {
        Panel.setPreferredSize(new Dimension(alto, ancho));
        Panel.setSize(alto, ancho);
    }

Ahora como dije zoom nos permitirá aumentar como disminuir entonces se necesitan estos métodos también.

zoom.Aumentar(50);
zoom.Disminuir(50);
zoom.Restaurar();

Donde 50 en ambos casos es el valor a aumentar o disminuir con respecto a su imagen y bueno restaurar es para regresar a las dimensiones anteriores u originales.

Coneccion SQL SERVER Y PHP 5.3.x con Netbeans

2011-07-26T14:27:00.000-05:00

Hola aun no creo esta entrada pero tengo un ejemplo de como conectar sql server 2008 con php5 fue realizado por mi autoria para un trabajo de la universidad con base de datos espero comentarios acerca de su creación.

Aplicación multi-lenguaje uso de Java y Properties

2011-07-26T01:31:00.001-05:00

El archivo Properties puede servirnos tambien para crear aplicaciones multilenguaje, por ejemplo guardar en cada archivo la estructura del idioma que utilizamos y en otros archivos el lenguaje al que deseamos traducir nuestra aplicacion, osea:

Creamos los archivos .Properties para cada lenguaje.
Para el idioma español podemos tener:

//esto formatea el codigo java

# Idioma español
#

#titulo aplicacion
titulo=Aplicación Multilenguaje

!Datos personales
titulo_datos=Datos Personales
nombre=Nombre:
Apellidos=Apellidos:
mail=Correo Electronico:
dir=Dirección:
fono=Telefono:

#salir
salir=Salir

! menu
archivo=Archivo
nuevo=Nuevo
abrir=Abrir...
guardar=Guardar como...
!Salir

herramientas=Herramientas
es=Español
en=Ingles

ayuda=Ayuda
enlinea=Ayuda en linea...
acerca=Acerca de...

Y para el ingles:

# Idioma Ingles
#
#

#titulo aplicacion
titulo=Multilingual Application

!Datos personales
titulo_datos=Personal Data
nombre=First Name:
Apellidos=Last Name:
mail=Your Email:
dir=Address:
fono=Phone:

#salir
salir=Exit

! menu
archivo=File
nuevo=New
abrir=Open...
guardar=Save as...
!Salir

herramientas=Tools
es=Spanish
en=English

ayuda=Help
enlinea=Online Help...
acerca=About..

Como puede verse, la cantidad de elementos en ambos archivos propeties, es la misma, asi tambien el KEY para cada parametro tambien es la misma, solo cambia el contenido de estos, uno en español y otro en ingles.

Nos creamos una clase para cargar estos archivos:

import java.io.IOException;
import java.util.Properties;

public class NProperties extends Properties{

    public NProperties(String idioma){
        if(idioma.equals("ES")){//español
            getProperties("_ES.properties");
        }else if(idioma.equals("EN")){//Ingles
            getProperties("_EN.properties");
        }else{//sino por default idioma español
            getProperties("ES");
        }
    }

    /* se leen las propiedades */
     private void getProperties(String idioma) {
        try {                
            this.load( getClass().getResourceAsStream(idioma) );
        } catch (IOException ex) {            
        }
   }

}

Convertir números a texto en java

2011-07-26T01:21:00.002-05:00

//esto formatea el codigo java

import java.util.regex.Pattern;
/**
 * @web http://jonathan-palomino.blogspot.com/
 */
public class Numero_Letra {

    private final String[] UNIDADES = {"", "un ", "dos ", "tres ", "cuatro ", "cinco ", "seis ", "siete ", "ocho ", "nueve "};
    private final String[] DECENAS = {"diez ", "once ", "doce ", "trece ", "catorce ", "quince ", "dieciseis ",
        "diecisiete ", "dieciocho ", "diecinueve", "veinte ", "treinta ", "cuarenta ",
        "cincuenta ", "sesenta ", "setenta ", "ochenta ", "noventa "};
    private final String[] CENTENAS = {"", "ciento ", "doscientos ", "trecientos ", "cuatrocientos ", "quinientos ", "seiscientos ",
        "setecientos ", "ochocientos ", "novecientos "};

   public Numero_Letra() {
   }

    public String Convertir(String numero, boolean mayusculas) {
        String literal = "";
        String parte_decimal;    
        //si el numero utiliza (.) en lugar de (,) -> se reemplaza
        numero = numero.replace(".", ",");
        //si el numero no tiene parte decimal, se le agrega ,00
        if(numero.indexOf(",")==-1){
            numero = numero + ",00";
        }
        //se valida formato de entrada -> 0,00 y 999 999 999,00
        if (Pattern.matches("\\d{1,9},\\d{1,2}", numero)) {
            //se divide el numero 0000000,00 -> entero y decimal
            String Num[] = numero.split(",");            
            //de da formato al numero decimal
            parte_decimal = Num[1] + "/100 Bolivianos.";
            //se convierte el numero a literal
            if (Integer.parseInt(Num[0]) == 0) {//si el valor es cero
                literal = "cero ";
            } else if (Integer.parseInt(Num[0]) > 999999) {//si es millon
                literal = getMillones(Num[0]);
            } else if (Integer.parseInt(Num[0]) > 999) {//si es miles
                literal = getMiles(Num[0]);
            } else if (Integer.parseInt(Num[0]) > 99) {//si es centena
                literal = getCentenas(Num[0]);
            } else if (Integer.parseInt(Num[0]) > 9) {//si es decena
                literal = getDecenas(Num[0]);
            } else {//sino unidades -> 9
                literal = getUnidades(Num[0]);
            }
            //devuelve el resultado en mayusculas o minusculas
            if (mayusculas) {
                return (literal + parte_decimal).toUpperCase();
            } else {
                return (literal + parte_decimal);
            }
        } else {//error, no se puede convertir
            return literal = null;
        }
    }

    /* funciones para convertir los numeros a literales */

    private String getUnidades(String numero) {// 1 - 9
        //si tuviera algun 0 antes se lo quita -> 09 = 9 o 009=9
        String num = numero.substring(numero.length() - 1);
        return UNIDADES[Integer.parseInt(num)];
    }

    private String getDecenas(String num) {// 99                        
        int n = Integer.parseInt(num);
        if (n < 10) {//para casos como -> 01 - 09
            return getUnidades(num);
        } else if (n > 19) {//para 20...99
            String u = getUnidades(num);
            if (u.equals("")) { //para 20,30,40,50,60,70,80,90
                return DECENAS[Integer.parseInt(num.substring(0, 1)) + 8];
            } else {
                return DECENAS[Integer.parseInt(num.substring(0, 1)) + 8] + "y " + u;
            }
        } else {//numeros entre 11 y 19
            return DECENAS[n - 10];
        }
    }

    private String getCentenas(String num) {// 999 o 099
        if( Integer.parseInt(num)>99 ){//es centena
            if (Integer.parseInt(num) == 100) {//caso especial
                return " cien ";
            } else {
                 return CENTENAS[Integer.parseInt(num.substring(0, 1))] + getDecenas(num.substring(1));
            } 
        }else{//por Ej. 099 
            //se quita el 0 antes de convertir a decenas
            return getDecenas(Integer.parseInt(num)+"");            
        }        
    }

    private String getMiles(String numero) {// 999 999
        //obtiene las centenas
        String c = numero.substring(numero.length() - 3);
        //obtiene los miles
        String m = numero.substring(0, numero.length() - 3);
        String n="";
        //se comprueba que miles tenga valor entero
        if (Integer.parseInt(m) > 0) {
            n = getCentenas(m);           
            return n + "mil " + getCentenas(c);
        } else {
            return "" + getCentenas(c);
        }

    }

    private String getMillones(String numero) { //000 000 000        
        //se obtiene los miles
        String miles = numero.substring(numero.length() - 6);
        //se obtiene los millones
        String millon = numero.substring(0, numero.length() - 6);
        String n = "";
        if(millon.length()>1){
            n = getCentenas(millon) + "millones ";
        }else{
            n = getUnidades(millon) + "millon ";
        }
        return n + getMiles(miles);        
    }
}

Esta clase, recibe un numero de 0,00 a 999999999.00 en formato String, el separador decimal puede ser un punto (.) o una coma (,), ademas tiene un parametro booleano "mayusculas" el cual sea verdadero (true) o falso (false), retorna el resultado en mayusculas o minusculas, esta clase no acepta numeros negativos ni tampoco numero mayores o iguales a mil millones, aunque claro trate de escribir esta clase para que sea facilmente comprensible y asi pueda ser ampliado o modificado segun sus necesidades.

La forma de llamara a esta clase es:

Numero_Letra NumLetra = new Numero_Letra();
String numero = "20004.70";
System.out.println( numero  + " literal = "  + NumLetra.Convertir(numero,true));

Algoritmo Julio Cesar (Criptografia)

2011-07-26T00:46:00.001-05:00

Este es un algoritmo sencillo consiste en alterar con un intervalo numérico menor a 10 la posición ascii tanto para encriptar o desencriptar.

Por ejemplo a en ascii es 97 pero con un intervalo de 1 se imprimiría un ascii 98 que es b
//esto formatea el codigo java

public class cesar {

private String tabla = "abcdefghijklmnopqrstuvwxyzáéíóú 1234567890@.,;:-+*/$#¿?!¡=()[]{}";

    public cesar(){
    }

    public String Encriptar(String t, int key){
        String texto = LimpiarCadena(t);
        //aqui se almacena el resultado
        String res = "";
        for(int i = 0; i < texto.length();i++)
        {
            //busca la posicion del caracter en la variable tabla
            int pos = tabla.indexOf(texto.charAt(i));
            //realiza el reemplazo
            if ((pos + key) < tabla.length()){
                res = res + tabla.charAt(pos+key);
            }
            else
            {
                res = res + tabla.charAt((pos+key) - tabla.length());
            }
        }
        return res;
    }

    public String Desencriptar(String t, int key){
        String texto = LimpiarCadena(t);
        String res = "";
        for(int i = 0; i < texto.length();i++)
        {
            int pos = tabla.indexOf(texto.charAt(i));
            if ((pos - key) < 0){
                res = res + tabla.charAt((pos-key) + tabla.length());
            }
            else
            {
                res = res + tabla.charAt(pos-key);
            }
        }
        return res;
    }

    private String LimpiarCadena(String t){
        //transforma el texto a minusculas
        t = t.toLowerCase();
        //eliminamos todos los retornos de carro
        t = t.replaceAll("\n", "");
        //eliminamos caracteres prohibidos
        for(int i = 0; i < t.length();i++)
        {
            int pos = tabla.indexOf(t.charAt(i));
            if (pos == -1){
                t = t.replace(t.charAt(i), ' ');
            }
        }
        return t;
    }
}

Ahora la forma de instanciarlo es asi:

cesar cesar = new cesar();
String cadena_final = cesar.Encriptar(texto_inicial, intervalo);
String cadena_inicial= cesar.Desencriptar(cadena_final, intervalo);

Uso de taryicon o icono de reloj

2011-07-26T00:31:00.000-05:00

Hola alguna ves quisieron una aplicación que se minimizara a la barra de reloj osea un segundo plano con Trayicon logramos esto sencillamente agregamos a este modulo lo que necesitamos y listo ademas haremos uso de un PopupMenu para visualizar opciones de dicho programa.

Adjunto el código para que lo usen.
//esto formatea el codigo java

import java.awt.*;
import java.awt.event.*;
import javax.swing.ImageIcon;
public class EjemploSystemTray {
    public EjemploSystemTray() {
        //se declara el objeto tipo icono
        final TrayIcon iconoSystemTray;
        //se verifica que el SystemTray sea soportado
        if (SystemTray.isSupported()) {
            //se obtiene una instancia estática de la clase SystemTray
            SystemTray tray = SystemTray.getSystemTray();
            //esta es la imagen de icono que esta en la misma carpeta que las clases
            ImageIcon icono = new ImageIcon(EjemploSystemTray.class.getResource("CARITA.PNG"));
            //este listener nos permite capturar cualquier tipo de evento
            //que se haga con el mouse sobre el icono
            MouseListener mouseListener = new MouseListener() {
                public void mouseClicked(MouseEvent e) {
                    System.out.println("Icono del System Tray - Mouse clicked!");
                }
                public void mouseEntered(MouseEvent e) {
                    System.out.println("Icono del System Tray - Mouse entered!");
                }
                public void mouseExited(MouseEvent e) {
                    System.out.println("Icono del System Tray - Mouse exited!");
                }
                public void mousePressed(MouseEvent e) {
                    System.out.println("Icono del System Tray - Mouse pressed!");
                }
                public void mouseReleased(MouseEvent e) {
                    System.out.println("Icono del System Tray - Mouse released!");
                }
            };
            //este listener se asociara con un item del menu contextual
            //que aparece al hacer click derecho sobre el icono
            ActionListener escuchadorSalir = new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    System.out.println("Saliendo...");
                    System.exit(0);
                }
            };
            //menu que aparece al hacer click derecho
            PopupMenu popup = new PopupMenu();
            MenuItem item = new MenuItem("Exit");
            item.addActionListener(escuchadorSalir);
            popup.add(item);
            //iniciamos el objeto TrayIcon
            iconoSystemTray = new TrayIcon(icono.getImage(), "Prueba System Tray", popup);
            //este tipo de listener captura el doble click sobre el icono
            ActionListener accionMostrarMensaje = new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    iconoSystemTray.displayMessage("Titulo mensaje",
                            "Este es el contenido del mensaje!",
                            TrayIcon.MessageType.INFO);
                }
            };

            iconoSystemTray.setImageAutoSize(true);
            iconoSystemTray.addActionListener(accionMostrarMensaje);
            iconoSystemTray.addMouseListener(mouseListener);

            //se debe capturar una excepción en caso que falle la adicion de un icono
            try {
                tray.add(iconoSystemTray);
            } catch (AWTException e) {
                System.err.println("No es posible agregar el icono al System Tray");
            }
        }
        else
            System.err.println("Tu sistema no soporta el System Tray :(");
    }
    public static void main(String[] args) {
        new EjemploSystemTray();
    }
}

SUDOKU

2011-07-12T01:51:00.001-05:00

Bueno hace tiempo vi por ahí que preguntaban como hacer un SUDOKU bueno les traigo las respuesta y en código java como tiene que ser es una aplicación de consola que pronto pasara a frame pero por lo pronto disfrútenla.
Son libres de hacer lo que deseen con el codigo:

//codigo java
/**
 *
 * @author JONATHAN
 */
import java.io.*;
import java.util.*;
import java.lang.*;
import java.math.*;

public class SUDOKU {
 
 //PROPIEDADES.
 public static int nivel = 1;
 
 
 //METODO PARA CARGAR JUEGO.
 public static int[][] cargar_juego( int nivel){
  
  int[][] matriz = new int[9][9];
  
  switch (nivel){
  
  case 2:
  
  matriz[0][0] = 7;matriz[0][4] = 5;matriz[0][6] = 4;matriz[1][0] = 4;
  matriz[1][3] = 1;matriz[1][4] = 9;matriz[1][6] = 6;matriz[1][7] = 2;
  matriz[1][8] = 7;matriz[2][2] = 6;matriz[2][8] = 9;matriz[3][0] = 9;
  matriz[3][2] = 3;matriz[3][6] = 8;matriz[4][3] = 4;matriz[4][5] = 3;
  matriz[5][2] = 8;matriz[5][6] = 5;matriz[5][8] = 2;matriz[6][0] = 5;
  matriz[6][6] = 2;matriz[7][0] = 2;matriz[7][1] = 9;matriz[7][2] = 1;
  matriz[7][4] = 4;matriz[7][5] = 7;matriz[7][8] = 8;matriz[8][2] = 7;
  matriz[8][4] = 1;matriz[8][8] = 5;
  
  break;
  
  
  case 1:
  default:
  
  matriz[0][2] = 9;matriz[0][5] = 8;matriz[0][6] = 5; matriz[0][7] = 4;
  matriz[1][8] = 7;matriz[2][1] = 5;matriz[2][2] = 4; matriz[2][4] = 9;
  matriz[2][6] = 1;matriz[3][5] = 6;matriz[3][6] = 3; matriz[3][7] = 2;
  matriz[4][1] = 8;matriz[4][2] = 2;matriz[4][6] = 4; matriz[4][7] = 1;
  matriz[5][1] = 3;matriz[5][2] = 5;matriz[5][3] = 2; matriz[6][2] = 7;
  matriz[6][4] = 3;matriz[6][6] = 2;matriz[6][7] = 5; matriz[7][0] = 9;
  matriz[8][1] = 4;matriz[8][2] = 3;matriz[8][3] = 8; matriz[8][7] = 9;
  
  break;
  
  }
  
  return matriz;
 }
 
 //METODO PARA NO SOBREESCRIBIR VALORES EN EL JUEGO.
 public static boolean es_origen( int fila, int columna, int[][] matriz ){
  
  boolean resultado = false;
  if ( matriz[fila][columna] != 0)
   resultado = true;
  
  return resultado;
  
 }
 
 //METODO QUE DETECTA SI EL JUEGO FUE TERMINADO.
 public static boolean terminado( int[][] matriz ){
  
  boolean resultado = true;
  
  for ( int f = 0; f < matriz.length; f ++)
   for ( int c = 0; c < matriz[0].length; c ++)
    if ( matriz[f][c] == 0 )
     resultado = false;
  
   
  return resultado;

 }
 
 //METODO QUE IMPRIME UN MENSAJE CON BORDE.
 public static void mensaje ( String mensaje ){
  
  //CABECERA.
  System.out.print("Ã‰");
  for(int i = 0; i < (mensaje.length() + 20); i ++ )
   System.out.print ("Ã");
  System.out.print ("Â»\n");

  //CUERPO.
  System.out.print("Âº          ");
  System.out.print( mensaje );
  System.out.print("          Âº\n");
 
  //PIE
  System.out.print("Ãˆ");
  for(int i = 0; i < (mensaje.length() + 20); i ++ )
   System.out.print ("Ã");
   
  System.out.print ("Â¼\n\n");
   
  
 }
 
 //METODO QUE IMPRIME EL VECTOR.
 public static void imprime_vector ( int[][] matriz ){
  
  
  System.out.println( " Â°Â°Â°Â°Â°Â°Â°Â°Â°Â°Â°Â°Â²Â°Â°Â°Â°Â°Â°Â°Â°Â°Â°Â°Â²Â°Â°Â°Â°Â°Â°Â°Â°Â°Â°Â°Â° " );
  
  for ( int f = 0; f < matriz.length; f ++ ){
  
   System.out.print(" Â° ");
   
   for ( int c = 0; c < matriz.length; c++){
    
    if ( matriz[f][c] != 0 ) 
     System.out.print ( matriz[f][c] );
    else 
     System.out.print (" ");
    
    if ( es_origen( f, c, cargar_juego( nivel ) ) )
     System.out.print (" ");
    else
     System.out.print (" ");
    
    if ( c == 2 || c == 5) 
     System.out.print ("Â² ");
    else
     System.out.print ("Â° ") ;
     
   }
   System.out.println();
   if ( f != 2 && f != 5)
    System.out.print( " Â°Â°Â°Â°Â°Â°Â°Â°Â°Â°Â°Â°Â²Â°Â°Â°Â°Â°Â°Â°Â°Â°Â°Â°Â²Â°Â°Â°Â°Â°Â°Â°Â°Â°Â°Â°Â° " );
   else
    System.out.print( " Â²Â²Â²Â²Â²Â²Â²Â²Â²Â²Â²Â²Â²Â²Â²Â²Â²Â²Â²Â²Â²Â²Â²Â²Â²Â²Â²Â²Â²Â²Â²Â²Â²Â²Â²Â²Â² " );
   System.out.println();
  }
 }

 //METODO PARA COMPROBAR FILAS.
 public static boolean existe_fila( int numero, int fila, int[][] matriz ){
  
  boolean resultado = false;
  
  for ( int i = 0; i < matriz.length; i ++ )
   if ( matriz[(fila-1)][i] == numero ){
     resultado = true;
     break;
   }
   
  //COMPROBAMOS SI ES 0.
  if ( numero == 0 ) resultado = false;
  
  return resultado;
  
 }
 
 //METODO PARA COMPROBAR COLUMNAS.
 public static boolean existe_columna( int numero, int columna, int[][] matriz ){
  
  boolean resultado = false;
  
  for ( int i = 0; i < matriz.length; i ++ )
   if ( matriz[i][(columna-1)] == numero ){
     resultado = true;
     break;
   }
   
  //COMPROBAMOS SI ES 0.
  if ( numero == 0 ) resultado = false;
  
  return resultado;
  
 }
 
 // METODO PARA COMPROBAR LOS INDICES.
 public static boolean comprobar_indice ( int indice ){
  
  if ( indice > 0 && indice < 10)
   return true;
  else
   return false;
  
 }
 
 // METODO PARA COMPROBAR LOS VALORES.
 public static boolean comprobar_valor ( int valor ){
  
  if ( valor >= 0 && valor < 10)
   return true;
  else
   return false;
  
 }
 
 //METODO PARA COMPROBAR LAS CAJAS.
 public static boolean existe_caja ( int valor, int fila, int columna, int[][] matriz ){
  
  //VARIABLES.
  int minimo_fila;
  int maximo_fila;
  int minimo_columna;
  int maximo_columna;
  boolean resultado = false;
 
  //DETERMINAMOS LAS FILAS DE LA CAJA.
  if ( fila > 0 && fila < 4){
   minimo_fila = 0;
   maximo_fila = 2;
  }else if ( fila > 3 && fila < 7 ){
   minimo_fila = 3;
   maximo_fila = 5;
  }else{
   minimo_fila = 6;
   maximo_fila = 8;
  }
    
  //DETERMINAMOS LAS COLUMNAS DE LA CAJA.
  if ( columna > 0 && columna < 4){
   minimo_columna = 0;
   maximo_columna = 2;
  }else if ( columna > 3 && columna < 7 ){
   minimo_columna = 3;
   maximo_columna = 5;
  }else{
   minimo_columna = 6;
   maximo_columna = 8;
  }
  
  //RECORREMOS EL RANGO DE LA CAJA, Y BUSCAMOS EL VALOR.
  for ( int f = minimo_fila; f <= maximo_fila; f++ )
   for ( int c = minimo_columna; c <= maximo_columna; c++)
    if ( matriz[f][c] == valor ){
     resultado = true;
     break; 
     
    }
   
   
  //COMPROBAMOS SI ES 0.
  if ( valor == 0 ) resultado = false;
  
  //REGRESAMOS EL VALOR BOOLEANO.
  return resultado;
   
 
  
 }
 
 //METODO PRINCIPAL
 public static void main ( String[] args ) throws Exception
 {
  
  //VARIABLES.
  BufferedReader teclado = new BufferedReader( new InputStreamReader ( System.in ) );
  int[][] sudoku = new int[9][9];
  int fila = 0;
  int columna = 0;
  int valor = 0;
  
  //CARGAMOS EL JUEGO.
  sudoku = cargar_juego( nivel );
   
  while ( true ){
  
  //IMPRIMIMOS EL VECTOR.
  imprime_vector ( sudoku );
  
  //PEDIMOS LOS DATOS.
  System.out.println( "Inserte las coordenadas (fila/columna): " );
  
  //FILA.
  System.out.print( "[fila]: " );
  fila = Integer.parseInt( teclado.readLine() );
  
  //COLUMNA.
  System.out.print( "[columna]: " );
  columna = Integer.parseInt( teclado.readLine() );
  
  //VALOR.
  System.out.print( "[valor]: " );
  valor = Integer.parseInt( teclado.readLine() );
  
  //COMPROBAMOS LA FILA ESTA EN RANGO.
  if ( !comprobar_indice(fila) )
   mensaje ("El valor de la fila no es correcto..");
  
  //COMPROBAMOS LA COLUMNA ESTA EN RANGO.
  else if ( !comprobar_indice(columna) )
   mensaje ( "El valor de la columna no es correcto.");
   
  //COMPROBAMOS QUE EL VALOR ESTA EN RANGO.
  else if ( !comprobar_valor(valor) )
   mensaje ( "El valor introducido no es valido..");
   
  //COMPROBAMOS QUE USE CASILLAS DISPONIBLES.
  else if ( es_origen( (fila - 1), (columna - 1), cargar_juego( nivel ) ) )
   mensaje ( "Ese valor es predeterminado del juego...");
   
  //COMPRUEBA QUE NO SE REPITA EL VALOR EN LA FILA.
  else if ( existe_fila( valor, fila, sudoku ) )
   mensaje ("[X] El valor " + valor + " ya ha sido usado en la fila..");
   
  //COMPRUEBA QUE NO SE REPITA EL VALOR EN LA COLUMNA..
  else if ( existe_columna( valor, columna, sudoku ) )
   mensaje ( "[X] El valor " + valor + " ya ha sido usado en la columna..");
   
  //COMPRUEBA QUE EL VALOR NO ESTÃ‰ EN LA CAJA.
  else if ( existe_caja( valor, fila, columna, sudoku ) )
   mensaje ( "[X] El valor ya existe en la caja..");
   
  //INTRODUCIMOS EL VALOR A LA MATRIZ.
  else {
   sudoku[(fila - 1)][(columna - 1)] = valor;
   mensaje( "[" + fila + "," + columna + "]=" + valor + " Correcto.");
  }
  
  
  //COMPRUEBA SI SE TERMINÃ“ EL JUEGO.
  if ( terminado( sudoku ) ){
   mensaje( "FELICIDADES!!!! HAS TERMINADO EL JUEGO!!");
   imprime_vector( sudoku );
   System.out.println ( "Presiona una tecla para continuar en el siguiente nivel..");
   teclado.readLine();
   
   //AUMENTAMOS EL NIVEL DEL JUEGO.
   nivel ++;
   sudoku = cargar_juego( nivel );
   mensaje( "SUDOKU NIVEL " + nivel );
  }
 
 
  }
 
 } 

 
}

Resultados de la Busqueda

2011-06-10T19:38:00.001-05:00

Resultados de la Busqueda

Hola y lo nuevo

2011-06-10T19:04:00.000-05:00

Hola a todos mis lectores como podrán haber visto el diseño de la pagina ha cambiado y creo que para bien ya que tendrán el contenido mas accesible y mas ordenado, pero no kiero acabar ahí eh agregado ciertos elementos que tal ves les sera molesto como la publicidad espero me comprendan necesitaba rentabilizar en algo esta pagina pero no obligo a nadie ver la publicidad si les parece bien apoyarme sino ignoren ese contenido.

Este cambio trae algunas mejoras eh revisado las estadísticas y por lo visto lo mas buscado es el tema de arreglos, números primos,ordenamiento, búsqueda,excepciones,ect.

Por lo cual si necesitan que agregue algún contenido que no existe actualmente en mi blog pero les es de interés posteenlo sin ningún inconveniente eso me ayudara a mejorar.

Gracias.

imágenes en java

2011-06-10T18:22:00.001-05:00

Los métodos getWidth o getHeight de Image me devuenven -1

El Problema: Si te devuelve -1, significa que no pudo obtener el tamaño, es porque no se cargo la imagen aún

Estas cargando las imágenes de la siguiente manera:

Image imgen = Toolkit.getDefaultToolkit().getImage( getClass().getResource("objeto.jpeg") );
int ancho = imgen.getWidth(null);
int alto = imgen.getHeight(null);
System.out.println("ANCHO:"+ancho+" ALTO:"+alto);

La salida es algo como:

ANCHO:-1 ALTO:-1

Esto es porque Toolkit.getDefaultToolkit().getImage() retorna primero y luego empieza a cargar los pixels.

Solución:
Utilizar la Clase Image Icon para cargar ya que este método retorna cuando se termino de cargar la imagen.

Image imgen = new ImageIcon(getClass().getResource("imagen.gif")).getImage();
int ancho = imgen.getWidth(null);
int alto = imgen.getHeight(null);
System.out.println("ANCHO:"+ancho+" ALTO:"+alto);

La salida es algo como:

ANCHO:50 ALTO:50

CONECCION JAVA CON SQL SERVER 2008

2011-05-04T01:15:00.000-05:00

Hola seguro ya revisaron como conectar java con sql 2005 de mi blog click aqui si no es asi, los pasos son similares no hay mucha varianza salvo en ciertas opciones que detallare.
Necesitaremos para esto

el driver jdbc 3.0
Sql server 2008 (yo use la version express como practica ademas es gratiuta y orientada a educacion)
Obviamente el ide java netbeans o otro ide

Les dejo entonces el link para el driver jdbc3.0 http://www.microsoft.com/downloads/es-es/details.aspx?FamilyID=a737000d-68d0-4531-b65d-da0f2a735707
Obviamente descargen el exe.

Luego descargenlo en algun lugar para el ejemplo lo baje a mi escritorio.
PEro basta de palabras vamos con las imagenes....
PASO1:

PASO2:

PASO3:

PASO4:

PASO 5 Y EL MAS IMPORTANTE

PASO 6:

PASO 7:

Ahora que ya tenemos la coneccion desde el netbeans notad que me entrego la ruta url JDBC con esa podras realizar la coneccion desde codigo.

Ahora el codigo java lo pueden consegir de mi anterior publicacion(ver link arriba) o si teneis alguna a modificar simplemente apliquen los cambios.

Hola liberando mi codigo reproductor mp3 java

2011-04-12T22:12:00.000-05:00

Hola hace tiempo presente un reproductor mp3 en java click aqui que implementa una libreria necesaria para leer y descodificar los ficheros mp3 y reproducirlos en tal la interfaz es algo amigable pero con el trabajo y el estudio casi no me da tiempo para buscarle mejoras por lo cual libero mi codigo con licencia GLP v3 en googlecode.
Se que el proyecto da para mas y que mas de alguno esta deseoso de saber como lo realize y poder estudiar el codigo y es mas espero que me ayuden a corregir los errores que tenga,añadir funciones extra,retirar codigo redundante.
aqui la direccion lo eh subido completo es decir solo lo tendran que bajar e importar a un proyecto java http://code.google.com/p/reproductor-mp3-java/

y si eres usuario consola-linux lo bajas asi
svn checkout http://reproductor-mp3-java.googlecode.com/svn/trunk/ reproductor-mp3-java-read-only

Metodo de ordenamiento propio

2011-04-03T20:18:00.010-05:00

Hola como algunos de uds saben existen multiples metodos de ordenar elementos ya sea de un arreglo o de otro tipo de objeto.

Presento mi propio metodo de ordenamiento que me vino a la mente en un chispaso hoy.

por ejemplo si tenemos esto:

ingreso = 5,7,15,0,2,1

de salida tendriamos esto

salida = 0,1,2,5,7,15

Para ello existe la burbuja,el de ciclos y muchos otros mas pero como me gusta generar contenido propio muestro el mio.

Consta de 2 clases para no marearlos con tanto codigo.

Clase Main.java

import java.util.Random;
/**
 *
 * @author JONATHAN
 */
public class Main {
    public static void main(String[] args) {
        // TODO code application logic here
        int[] arreglo_temp = null;
        arreglo_temp = Crear_lista(5);
        Libreria objeto = new Libreria();
        System.out.println("ORIGINAL : "+ objeto.Visualizar(arreglo_temp));
        System.out.println("ORDENADO : "+ objeto.Visualizar(objeto.ordenar(arreglo_temp)));
    }

    private static int[] Crear_lista(int n) {
        int[] arre = new int[n];
        Random generador = new Random();
        for (int i = 0; i < arre.length; i++) {
            arre[i] = generador.nextInt(10);
        }
        return arre;
    }
}

Hasta ahi simple verdad, cumplo con la regla de orientado a objetos, sin nada de complicaciones de codigo.

El metodo Crear_lista genera un array de elementos aleatorios,jejeje asi no parece predeterminado a nada.

Ahora pasemos a la clase Libreria.java es decir la que trabaja con el ordenamiento.

import java.util.ArrayList;
/**
 *
 * @author JONATHAN
 */
class Libreria {
    private int[] vector;
    private int elementos;

    public Libreria() {
    }
    //para imprimir el array de la forma / 0 / 1 / 2 / 3 / 4 /5

    public String Visualizar(int[] v) {
        String s = " / ";
        for (int i = 0; i < v.length; i++) {
            s += v[i] + " / ";
        }
        return s;
    }

    int[] ordenar(int[] v) {
        this.vector = v;
        elementos = vector.length;
        ArrayList uno = new ArrayList();
        for (int i = 0; i < elementos; i++)
        {
            uno.add(vector[i]);//Recorro el arreglo y agrego cada elemento al arraylist
        }
        for(int i=0;i
        {
            vector[i]=toEntero(uno.get(indice_Menor(uno)));//Asigno al arreglo
            //primitivo el elemento menor del arraylist
            uno.remove(toEntero(indice_Menor(uno)));
            //Proceso a eliminar dicho elemento del arraylist
            //Se ejecuta un bucle rescatando el menor elemento.
            //Asi ordenaria mi arreglo
        }
        return vector;
    }

    private int indice_Menor(ArrayList indice) {
        int b = 0;
        for (int i = 0; i < indice.size(); i++) {
            if (toEntero(indice.get(i)) < toEntero(indice.get(b))) {
                b = i;
            }
        }
        return b;
    }

    private int toEntero(Object get) {
        //los arraylist retornan objetos pero necesito trabajar con enteros
        //Simplemente convierto a entero un objeto cuando es llamada esta funcion
        return Integer.parseInt(get.toString());
    }

}

Hagamos un resumen existen los metodos:

Visualizar(int[] v);
ordenar(int[] v);
indice_Menor(ArrayList indice);
toEntero(Object get);

El metodo Visualizar(int[] v) es solo para la presentacion de datos de modo que no aparescan todos juntos.

El metodo ordenar(int[] v) es para realizar el ordenamiento propiamente dicho.

El metodo indice_Menor(ArrayList indice) sirve para obtener el menor elemento de un arraylist y retorna su indice para procesarlo.

Finalmente como los arraylist trabajan con objetos necesito un convertidor porque lo que usare seran enteros, para ese caso esta toEntero(Object get) que me retornara como entero cualquier objeto enviado.

Espero les sirva es algo que se me ocurrio comenten y diganme que les parece.