Java: Convertir un arreglo o array a una lista.

En algunos casos puede ser mas conveniente tener nuestros objetos dentro de una lista (List<Object>) que dentro de un arreglo (Object[]). En tal caso puede se puede realizar la conversión de arreglo a lista muy fácilmente.

En el siguiente ejemplo se puede observar como se define un arreglo de Integer (Integer[]) y luego se convierte en una lista de Integer (List<Integer>). Luego esta un ejemplo de como definir una lista de String (List<String>) directamente utilizando el métodos Arrays.asList().

	import java.util.Arrays;
	import java.util.List;
	public class ArrayToList {
	public static void main(String[] args){
	//Se crea un array de Integers
	Integer[] numeros = new Integer[5];
	numeros[0] = 0;
	numeros[1] = 1;
	numeros[2] = 2;
	numeros[3] = 3;
	numeros[4] = 4;
	//Se pasa el array de Integer a una lista
	List<Integer> listNumeros = Arrays.asList(numeros);
	//Recorremos la lista
	System.out.println("---recorriendo Lista de numeros---");
	for(Integer numero : listNumeros){
	System.out.println(numero);
	}
	//Otra forma de definir un array
	//String[] strings = {"Elemento1","Elemento2","Elemento3"};
	//Se puede definir la lista directamente desde el metodo asList
	List<String> listString = Arrays.asList("Elemento1","Elemento2","Elemento3");
	System.out.println("---Recorriendo lista de strings---");
	for(String string : listString){
	System.out.println(string);
	}
	}
	}

view raw ArrayToList.java hosted with ❤ by GitHub

Luego de ejecutar el código el resultado sería el siguiente.

	---recorriendo Lista de numeros---
	0
	1
	2
	3
	4
	---Recorriendo lista de strings---
	Elemento1
	Elemento2
	Elemento3

view raw ArrayToListOutput hosted with ❤ by GitHub

Java: Convertir String a Date

Para convertir un objeto del tipo String a Date debemos definir primero el formato en que usa el String a convertir. Para tal caso existe la clase DateFormat que tiene varias implementaciones pero en este caso la veremos con SimpleDateFormat. Estas clases nos permiten convertir un objeto String a Date usando un formato o sintaxis que se adecua a el String que enviamos.

El siguiente ejemplo muestra varios String los cuales deseamos pasar a fecha:

	import java.text.DateFormat;
	import java.text.ParseException;
	import java.text.SimpleDateFormat;
	import java.util.Date;
	public class StringToDate {
	public static void main(String[] args){
	//Diferentes fechas a parsear
	String stringFechaHora = "2014-10-20 20:10:59";
	String stringFecha = "20/10/2014";
	String stringHora = "10:20:59";
	try {
	//Se necesita definir un formato para poder cambiar el String a Date
	//En este caso buscará en el String año-mes-dia hora:minutos:segundos
	DateFormat fechaHora = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	Date convertido = fechaHora.parse(stringFechaHora);
	System.out.println(convertido);
	//En este caso buscará en el String dia/mes/año
	DateFormat fecha = new SimpleDateFormat("dd/MM/yyyy");
	convertido = fecha.parse(stringFecha);
	System.out.println(convertido);
	//En este caso buscará en el String hora:minutos:segundos
	DateFormat hora = new SimpleDateFormat("HH:mm:ss");
	convertido = hora.parse(stringHora);
	System.out.println(convertido);
	//En este caso buscara hora:minutos:segundos en el String "20/10/2014"
	//No lo encntrará y será error por lo que nos mandará al catch.
	convertido = hora.parse(stringFecha);
	System.out.println(convertido);
	} catch (ParseException e) {
	System.out.println("Error: " + e.getMessage());
	}
	}
	}

view raw StringToDate.java hosted with ❤ by GitHub

El código anterior nos permite parsear el String buscando por los elementos que se definio en el formato. El resultado del código anterior es el siguiente:

	Mon Oct 20 20:10:59 CST 2014
	Mon Oct 20 00:00:00 CST 2014
	Thu Jan 01 10:20:59 CST 1970
	Error: Unparseable date: "20/10/2014"

view raw StringToDateOutput hosted with ❤ by GitHub

En la siguiente imagen se pueden observar algunos ejemplos de SimpleDateFormat con sus resultados en String.

Java: Agregar imagen a botón

En esta entrada se agregara una imagen a un botón en Java. Existen varias formas pero observaremos como hacerlas usando la clase URL para ubicar el archivo que deseamos. Al final obtendremos algo como esto:

La imagen puede que se un archivo dentro de nuestro proyecto o con una imagen en la web. Luego simplemente se agrega la imagen al botón por medio de su constructor. El siguente script muestra la forma de hacerlo:

	ImageIcon dukesIcon = null;
	java.net.URL imgURL1 = ImageButton.class.getResource("/img/ReallySmallDuke.png");
	//puedes obetner imagenes directamente de la web
	java.net.URL imgURL2 = null;
	try{
	imgURL2 = new java.net.URL("http://openjdk.java.net/images/duke-thinking.png");
	} catch (MalformedURLException e){
	System.out.println("URL invalida");
	}
	if (imgURL != null) {
	dukesIcon = new ImageIcon(imgURL1); //Usa imgURL1 o imgURL2
	} else {
	System.out.println("No se pudo cargar la imagen.");
	}
	JButton jButton = new JButton("Ejemplo", dukesIcon);

view raw ImageButtonShort.java hosted with ❤ by GitHub

Si ponen la imagen dentro de su proyecto es recomendable usar un paquete para guardarlas.

A continuación el código completo de la solución:

	import java.awt.BorderLayout;
	import javax.swing.BoxLayout;
	import javax.swing.ImageIcon;
	import javax.swing.JButton;
	import javax.swing.JFrame;
	import javax.swing.JPanel;
	public class ImageButton extends JFrame {
	public void crearBoton() {
	JPanel hPanel = new JPanel();
	hPanel.setLayout(new BoxLayout(hPanel, BoxLayout.X_AXIS));
	ImageIcon dukesIcon = null;
	java.net.URL imgURL1 = ImageButton.class.getResource("/img/ReallySmallDuke.png");
	//puedes obetner imagenes directamente de la web
	java.net.URL imgURL2 = null;
	try{
	imgURL2 = new java.net.URL("http://openjdk.java.net/images/duke-thinking.png");
	} catch (MalformedURLException e){
	System.out.println("URL invalida");
	}
	if (imgURL != null) {
	dukesIcon = new ImageIcon(imgURL1); //Usa imgURL1 o imgURL2
	} else {
	System.out.println("No se pudo cargar la imagen.");
	}
	JButton jButton = new JButton("Ejemplo",
	dukesIcon);
	jButton.setVerticalTextPosition(JButton.BOTTOM);
	jButton.setHorizontalTextPosition(JButton.RIGHT);
	hPanel.add(jButton);
	getContentPane().add(hPanel, BorderLayout.CENTER);
	}
	public static void main(String[] args) {
	mostrarGUI();
	}
	private static void mostrarGUI() {
	ImageButton boton = new ImageButton();
	boton.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	boton.crearBoton();
	boton.pack();
	boton.setVisible(true);
	}
	}

view raw ImageButton.java hosted with ❤ by GitHub

Java: Archivos Temporales

Un ejemplo de como escribir información en un archivo temporal en Java. No existe diferencia entre lo que se puede escribir en un archivo normal y uno temporal. Generalmente los temporales nos sirven cuando queremos crear archivos en un applet.

En este ejemplo se crea el archivo "archivo.tmp" y se le escribe información de dos formas diferentes.

	import java.io.BufferedWriter;
	import java.io.File;
	import java.io.FileWriter;
	import java.io.IOException;
	public class ArchivoTemporal
	{
	public static void main(String[] args)
	{
	try{
	//Crear un archivo temporal
	File temp = File.createTempFile("archivo", ".tmp");
	//Le indicamos que lo eleminte cuando se cierre el programa.
	temp.deleteOnExit();
	//Escribir contenido con BufferedWriter
	BufferedWriter bw = new BufferedWriter(new FileWriter(temp));
	bw.write("This is the temporary file content");
	bw.close();
	/*¨--- ALTERNATIVA ---*/
	//Escribir el archivo con un InputStream
	InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream("com/pack/yourfile");
	FileOutputStream outputStream = new FileOutputStream(file);
	int read = 0;
	byte[] bytes = new byte[is.available()];
	while ((read = is.read(bytes)) != -1) {
	outputStream.write(bytes, 0, read);
	}
	is.close();
	outputStream.close();
	}catch(IOException e){
	e.printStackTrace();
	}
	}
	}

view raw ArchivoTemporal.java hosted with ❤ by GitHub

Java: Convertir double a long.

Muchas veces no es necesario convertir en java una variable del tipo double a long. Para realizar esto existen varias formas, pero se mostraran las mas sencillas. Para hacerlo se puede simplemente castear o utilizar el método round como se ve en el siguiente script:

	public class Utils {
	public static void main(String[] args) {
	//Trunca los decimales.
	double d = 1234.56;
	long x = (long) d;
	System.out.println(x);
	//Redondea los decimales
	d = 1234.56;
	x = Math.round(d);
	System.out.println(x);
	}
	}

view raw DoubleToLong.java hosted with ❤ by GitHub

Si se castea simplemente se truncaran los decimales. Si se utiliza el método round utilizará técnicas de redondeo. El código anterior devolvería lo siguiente:
1234
1235

Java: Popup con swing.

Entre las utilidades de la librería swing de java existe la de JPopup. Esta clase nos permite crear un panel emergente o pop up al cual se le pueden agregar JMenuItem y realizar acciones dependiendo de la selección. Aquí un ejemplo de como se ve:

Para realizar el ejemplo anterior se puede utilizar el siguiente código:

	import java.awt.event.ActionEvent;
	import java.awt.event.ActionListener;
	import java.awt.event.MouseAdapter;
	import java.awt.event.MouseEvent;
	import javax.swing.JFrame;
	import javax.swing.JLabel;
	import javax.swing.JMenuItem;
	import javax.swing.JPopupMenu;
	public class PopupExample extends JFrame {
	JLabel jLabel;
	JPopupMenu jPopupMenu;
	private void prepararUI() {
	jLabel = new JLabel("Elemento", JLabel.CENTER);
	getContentPane().add(jLabel);
	//Le agregamos los elementos al Popup
	jPopupMenu = new JPopupMenu();
	JMenuItem jMenuItem_A = new JMenuItem("Menu Item A");
	JMenuItem jMenuItem_B = new JMenuItem("Menu Item B");
	JMenuItem jMenuItem_C = new JMenuItem("Menu Item C");
	jPopupMenu.add(jMenuItem_A);
	jPopupMenu.add(jMenuItem_B);
	jPopupMenu.add(jMenuItem_C);
	jMenuItem_A.addActionListener(menuActionListener);
	jMenuItem_B.addActionListener(menuActionListener);
	jMenuItem_C.addActionListener(menuActionListener);
	addMouseListener(myMouseAdapter);
	}
	//Creamos un MouseAdapter para controlar cuando mostrar el popup.
	MouseAdapter myMouseAdapter = new MouseAdapter() {
	@Override
	public void mousePressed(MouseEvent e) {
	if (e.isPopupTrigger()) {
	jPopupMenu.show(e.getComponent(), e.getX(), e.getY());
	}
	}
	@Override
	public void mouseReleased(MouseEvent e) {
	if (e.isPopupTrigger()) {
	jPopupMenu.show(e.getComponent(), e.getX(), e.getY());
	}
	}
	};
	ActionListener menuActionListener = new ActionListener(){
	@Override
	public void actionPerformed(ActionEvent e) {
	jLabel.setText(e.getActionCommand());
	}
	};
	private static void crearGUI() {
	PopupExample myFrame = new PopupExample();
	myFrame.setTitle("javainutil.blogspot.com");
	myFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	myFrame.setSize(400, 300);
	myFrame.prepararUI();
	myFrame.setVisible(true);
	}
	public static void main(String[] args) {
	crearGUI();
	}
	}

view raw Popup.java hosted with ❤ by GitHub

Java: Menu con swing.

En java se pueden utilizar los elementos gráficos de swing para crear menús, con la clase JMenu, con una gran cantidad de elementos diferentes. En el siguiente ejemplo se mostrara como hacer menús y agregarles elementos con funcionalidad básica. Dentro de el menú se pueden observar checkbox, radiobuttons, etc.

Se debe agregar un ActionListener a cada elemento de los menús para darles funcionalidad. Aca se puede observar el código para realizar el menú del ejemplo:

	import java.awt.event.ActionEvent;
	import java.awt.event.ActionListener;
	import java.awt.event.KeyEvent;
	import javax.swing.ButtonGroup;
	import javax.swing.JCheckBoxMenuItem;
	import javax.swing.JFrame;
	import javax.swing.JLabel;
	import javax.swing.JMenu;
	import javax.swing.JMenuBar;
	import javax.swing.JMenuItem;
	import javax.swing.JRadioButtonMenuItem;
	public class MenuExample extends JFrame {
	JLabel jLabel;
	private void perpararUI() {
	jLabel = new JLabel("Elemento", JLabel.CENTER);
	getContentPane().add(jLabel);
	JMenuBar jMenuBar = new JMenuBar();
	JMenu menuFile = new JMenu("Archivo");
	menuFile.setMnemonic(KeyEvent.VK_F);
	jMenuBar.add(menuFile);
	JMenu menuOption = new JMenu("Opciones");
	menuOption.setMnemonic(KeyEvent.VK_P);
	jMenuBar.add(menuOption);
	//MenuItem Nuevo, Abrir, Guardar abajo de File
	JMenuItem menuItemNew = new JMenuItem("Nuevo", KeyEvent.VK_N);
	menuFile.add(menuItemNew);
	JMenuItem menuItemOpen = new JMenuItem("Abrir", KeyEvent.VK_O);
	menuFile.add(menuItemOpen);
	JMenuItem menuItemSave = new JMenuItem("Guardar", KeyEvent.VK_S);
	menuFile.add(menuItemSave);
	//CheckBox A, B, C bajo opciones
	JCheckBoxMenuItem jCheckBoxMenuItem_A = new JCheckBoxMenuItem("Check A");
	jCheckBoxMenuItem_A.setMnemonic(KeyEvent.VK_A);
	menuOption.add(jCheckBoxMenuItem_A);
	JCheckBoxMenuItem jCheckBoxMenuItem_B = new JCheckBoxMenuItem("Check B");
	jCheckBoxMenuItem_B.setMnemonic(KeyEvent.VK_B);
	menuOption.add(jCheckBoxMenuItem_B);
	JCheckBoxMenuItem jCheckBoxMenuItem_C = new JCheckBoxMenuItem("Check C");
	jCheckBoxMenuItem_C.setMnemonic(KeyEvent.VK_C);
	menuOption.add(jCheckBoxMenuItem_C);
	menuOption.addSeparator();
	//Crear ButtonGroup para los radio button D, E, F
	ButtonGroup buttonGroup = new ButtonGroup();
	JRadioButtonMenuItem jRadioButtonMenuItem_D = new JRadioButtonMenuItem("Opcion D", true);
	jRadioButtonMenuItem_D.setMnemonic(KeyEvent.VK_D);
	menuOption.add(jRadioButtonMenuItem_D);
	buttonGroup.add(jRadioButtonMenuItem_D);
	JRadioButtonMenuItem jRadioButtonMenuItem_E = new JRadioButtonMenuItem("Opcion E");
	jRadioButtonMenuItem_E.setMnemonic(KeyEvent.VK_E);
	menuOption.add(jRadioButtonMenuItem_E);
	buttonGroup.add(jRadioButtonMenuItem_E);
	JRadioButtonMenuItem jRadioButtonMenuItem_F = new JRadioButtonMenuItem("Opcion F");
	jRadioButtonMenuItem_F.setMnemonic(KeyEvent.VK_F);
	menuOption.add(jRadioButtonMenuItem_F);
	buttonGroup.add(jRadioButtonMenuItem_F);
	setJMenuBar(jMenuBar);
	ActionListener menuActionListener = new ActionListener(){
	@Override
	public void actionPerformed(ActionEvent e) {
	jLabel.setText(e.getActionCommand());
	}
	};
	//Agregar ActionListener
	menuItemNew.addActionListener(menuActionListener);
	menuItemOpen.addActionListener(menuActionListener);
	menuItemSave.addActionListener(menuActionListener);
	jCheckBoxMenuItem_A.addActionListener(menuActionListener);
	jCheckBoxMenuItem_B.addActionListener(menuActionListener);
	jCheckBoxMenuItem_C.addActionListener(menuActionListener);
	jRadioButtonMenuItem_D.addActionListener(menuActionListener);
	jRadioButtonMenuItem_E.addActionListener(menuActionListener);
	jRadioButtonMenuItem_F.addActionListener(menuActionListener);
	}
	private static void crearGUI() {
	MenuExample myFrame = new MenuExample();
	myFrame.setTitle("javainutil.blogspot.com");
	myFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	myFrame.setSize(400, 300);
	myFrame.perpararUI();
	myFrame.setVisible(true);
	}
	public static void main(String[] args) {
	crearGUI();
	}
	}

view raw Menu.java hosted with ❤ by GitHub