SDeveloper

En la entrada anterior vimos como hacer uso de la clase ArrayList. En esta ocasión nos vamos a centrar en otra estructura de datos un poco más completa. La clase LinkedList.

import java.util.LinkedList;

public class LinkedListExample
{
	/**
	 * In this example we can see how to use the class LinkedList with 
	 * some of his methods more important.
	 * En este ejemplo podemos ver como hacer uso de la clase LinkedList con
	 * algunos de sus metodos más importantes.
	 * 
	 * @author SuarezDeveloper
	 * @param args
	 */
	public static void main(String[] args)
	{
		LinkedList<String> lista = new LinkedList<String>();
		
		lista.add("1"); // Añade al final el elemento
		lista.addFirst("0"); // Añade al inicio el elemento
		lista.addLast("2"); // Añade al final el elemento
		lista.addLast("3"); 
		lista.addLast("4");
		lista.set(1, "nuevo1"); // Sustituye el contenido de la casilla 1 por "nuevo1"
		lista.isEmpty(); // Devuelve si está o no vacía
		lista.get(1); // Recupera el contenido de la posición 1
		lista.getFirst(); // Recupera el contenido de la primera posición de la lista
		lista.getLast(); // Recupera el contenido de la última posición de la lista
		lista.pollFirst(); // Recupera y borra el primer elemento de la lista
		lista.pollLast(); // Recupera y borra el último elemento de la lista
		lista.remove(0); // Borra la posición 0
		lista.remove("98"); //Busca el elemento y si lo encuentra lo borra
		lista.removeFirst(); // Borra el primer elemento
		lista.removeLast(); // Borra el último elemento
		lista.contains("2"); // Devuelve si la lista contiene o no el elemento
		lista.size(); // Devuelve el tamaño de la lista
		lista.clear(); // Vacia la lista
		
		
	}
}

A continuación os dejo un código explicativo de como usar un ArrayList

import java.util.ArrayList;

public class ArrayListExample
{
	/**
	 * In this example we can see how to use the class ArrayList with 
	 * some of his methods more important.
	 * En este ejemplo podemos ver como hacer uso de la clase ArrayList con
	 * algunos de sus metodos más importantes.
	 * .
	 * @author SuarezDeveloper
	 * @param args Not use
	 */ 
	public static void main(String[] args)
	{
		ArrayList<String> array = new ArrayList<String>();
		
		array.add("hola"); //Añade "hola" a la lista (Actualmente vacia, por tanto en la posicion 0)
		array.add(0, "adios"); // Añade "adios" en la posicion 0 y desplaza el resto de elementos a la derecha, poniendose "hola" en la posicion 1
		array.get(0); // Te devueve el objeto insertado en la poscición 0
		array.contains("hola"); // Devuelve true o false dependiendo de si contiene o no el objeto
		array.set(0, "nuevoAdios"); // Sustituye el contenido de la posición 0 por "nuevoAdios"
		array.isEmpty(); // Devuelve si está o no vacia
		array.ensureCapacity(50); // Internamente esta clase contiene un array, con este metodo podemos definir el tamaño interno del array.
		array.size(); // Devuelve el número de elementos insertados
		array.remove(0); // Borra la posición 0
		array.remove("hola"); // Borra el elemento "hola"
		System.out.print(array.size());
		array.clear(); // Vacia la lista
	}
}

Lo necesario

Es necesario descargar una librería para poder twittear con Java. Existen varías librerías para Java pero en este caso nosotros vamos a hacer uso de la librería Twitter4J (la recomendada por twitter).

• Twitter4J

Una vez descargado el zip, lo descomprimís. Aparecerá una carpeta llamada lib donde tendremos que adjuntar el archivo a un nuevo proyecto. Aquí tenéis un tutorial de como poder añadir librerías externas a un proyecto en Eclipse.

Una vez añadida la librería o antes de esto debemos crearnos una aplicación en Twitter para que este nos de permisos para poder usar su API. Para crear una nueva aplicación entramos en https://dev.twitter.com/ y nos logueamos.
Una vez logueados situamos el ratón sobre nuestro nombre de usuario y seleccionamos My Applications.

Hecho esto nos aparecerá la siguiente ventana donde pulsaremos Create a new application

Rellenáis todos los campos y tendréis vuestra «aplicación» completada. Dentro de la aplicación hay datos que son necesarios para poder comunicarnos con Twitter desde nuestra aplicación en Java

Nota: Si no aparece «Read, write, and direct messages» modificadlo desde la configuración de la aplicación.

Dando permisos
El próximo código solo tendréis que ejecutarlo una vez. Lo que hace este código es dar permisos de un usuario concreto a la aplicación Java. Cuando se ejecute, se os abrirá el navegador web que tengáis por defecto y si estáis logueados en Twitter os preguntará si queréis dar permisos a vuestra aplicación. La página os devolverá un código PIN. Copiad el código y volved a la consola de Java donde estará esperando que pongáis el código.

Una vez introducido el código PIN en la consola esta mostrará los siguientes dos datos:

• Access token
• Access token secret

Copiad esos datos pues serán imprescindibles para la comunicación con el cliente.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import twitter4j.conf.ConfigurationBuilder;
import twitter4j.Twitter;
import twitter4j.TwitterException;
import twitter4j.TwitterFactory;
import twitter4j.auth.AccessToken;
import twitter4j.auth.RequestToken;

/**
 * @author Antonio Suárez Cortés
 */
public class TwitterJ
{
	/**
	 * @param args
	 * @throws IOException
	 * @throws TwitterException
	 */

	public static void main(String[] args) throws IOException, TwitterException
	{
		ConfigurationBuilder cb = new ConfigurationBuilder();
		cb.setDebugEnabled(true)
			.setOAuthConsumerKey("La Consumer Key suministrada por Twitter")
			.setOAuthConsumerSecret("El Consumer Secret suministrada por Twitter");
		Twitter twitter = new TwitterFactory(cb.build()).getInstance();

		// Si están seteados el Token y el TokenSecret la siguiente
		// linea lanzará IllegalStateException
		RequestToken requestToken = twitter.getOAuthRequestToken();
		System.out.println("Obtenido request token.");
		System.out.println("Request token: " + requestToken.getToken());
		System.out.println("Request token secret: " + requestToken.getTokenSecret());
		AccessToken accessToken = null;

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		while (null == accessToken)
		{
			String osName = System.getProperty("os.name");
			String url = requestToken.getAuthorizationURL();
			System.out.println("La siguiente URL será abierta en su navegador:");
			System.out.println(requestToken.getAuthorizationURL());
			if (osName.contains("Windows"))
				Runtime.getRuntime().exec("rundll32 url.dll,FileProtocolHandler " + url);
			else
				if (osName.contains("Mac OS"))
					Runtime.getRuntime().exec("open " + url);
				else
					if (osName.indexOf("nix") >= 0 || osName.indexOf("nux") >= 0)
					{

						String[] browsers =
						{ "epiphany", "firefox", "mozilla", "konqueror", "netscape", "opera", "links", "lynx" };

						StringBuffer cmd = new StringBuffer();
						for (int i = 0; i  0)
				accessToken = twitter.getOAuthAccessToken(requestToken, pin);
			else
				// Si eres una aplicación de confianza (una multinacional por
				// ejemplo) no necesitas PIN, por eso aparece esta línea
				accessToken = twitter.getOAuthAccessToken(requestToken);
		}
		System.out.println("Obtenido el access token.");
		System.out.println("Access token: " + accessToken.getToken());
		System.out.println("Access token secret: " + accessToken.getTokenSecret());

		System.exit(0);

	}
}

El código final
En este punto del tutorial disponemos de los siguientes datos:

• Consumer Key
• Consumer Secret
• Access token
• Access token secret

Eso es todo lo necesario para poder comunicarnos con la cuenta de Twitter asociada a ese Access token. Por tanto para cada cuenta a la que queramos acceder desde Java es necesario disponer del Access token de esta.

Y ya por fin el tan ansiado código!!

import twitter4j.Paging;
import twitter4j.ResponseList;
import twitter4j.Status;
import twitter4j.Twitter;
import twitter4j.TwitterException;
import twitter4j.TwitterFactory;
import twitter4j.conf.ConfigurationBuilder;

public class Uso
{
	public static void main(String ar[]) throws TwitterException
	{
		Twitter twitter;
		ConfigurationBuilder cb = new ConfigurationBuilder();
		//Aquí deberéis sustituir vuestras key, secret, token y tokenSecret.
		//Estas son las claves de mi cuenta @SuarezDeveloper
		cb.setDebugEnabled(true)
			.setOAuthConsumerKey("[Your Costumer Key]")
			.setOAuthConsumerSecret("[Your Customer Secret]")
			.setOAuthAccessToken("[Your Access Token]")
			.setOAuthAccessTokenSecret("Your Access Token Secret");
		twitter = new TwitterFactory(cb.build()).getInstance();

		//Recuperar listado de ultimos tweets escritos
		//El paging sirve para decir el número máx de tweets que quieres recuperar
		Paging pagina = new Paging();
		pagina.setCount(50);

		//Recupera como máx 50 tweets escritos por tí
		ResponseList listado = twitter.getUserTimeline(pagina);
		for (int i = 0; i < listado.size(); i++)
			System.out.println(listado.get(i).getText());

		//Recupera como máx los ultimos 50 tweets de tus tablon de novedades
		listado = twitter.getHomeTimeline(pagina);
		for (int i = 0; i < listado.size(); i++)
			System.out.println(listado.get(i).getText());

		//Actualizar tu estado
		Status tweetEscrito = twitter.updateStatus("Este tweet ha sido mandado desde el manual de https://suarezdeveloper.wordpress.com/2012/04/12/como-twittear-con-java/ #SuarezDeveloperTwitter");
	}
}

En ocasiones necesitamos añadir funcionabilidad extra a nuestros proyectos. Una forma sencilla de hacerlo es mediante librerías externas con extensión .jar. Lo que ahora voy a intentar explicar es como configurar el proyecto para poder usar esas librerías usando Eclipse.

Primero y antes de nada debemos crear un nuevo proyecto java. Seguidamente clickamos con el botón derecho sobre el y seleccionamos Build Path / Configure Build Path

Seguidamente nos aparecerá una ventana emergente donde deberemos dirigirnos a la pestaña Libraries. En esta ventana podremos observar que actualmente se encuentran las librerías propias de java (el JRE). Ya solo nos quedaría clickar en el botón Add External Jars… añadir la o las librerías necesarias y pulsar en aceptar.

Finalmente os añado una captura de ejemplo de como importar una librería externa a una clase.

En ocasiones es necesario saber la ruta del archivo .jar del programa, esto se puede averiguar de la siguiente forma.

import java.io.File;

public class uso
{
 public static void main(String ars[])
 {

 recurso = uso.class.getResource(recurso).toString();
 System.out.println("nRuta del archivo .class ejecutado: ");
 System.out.println(recurso);

}

}

El título lo dice todo, recupera y lista todas los dispositivos de almacenamiento del sistema (HDDs, pen drives, lectores de DVD…)

import java.io.File;

public class Uso
{
	public static void main(String ars[])
	{
		System.out.println("Raices");
		//Recupera todos los dispositivos de almacenamiento del sistema.
		File[] a = File.listRoots();
		for(int i=0; i<a.length;i++)
			System.out.println(a[i].getAbsolutePath());
	}
}

A continuación pongo el código para como localizar y posicionar el ratón del sistema usando Java. Lo que hace el programita de ejemplo es restringir el movimiento del ratón a un rectángulo en el centro de la pantalla de 200×200 px.

import java.awt.AWTException;
import java.awt.MouseInfo;
import java.awt.Point;
import java.awt.Robot;
import java.awt.Toolkit;

public class Ubicacion extends Thread
{
   public static void main(String args[]) throws InterruptedException, AWTException
   {
      Point p;
      Robot robot = new Robot();
      while (true)
      {
         //Para no consumir toda la CPU
         sleep(1); 
         //Recupera la posición del ratón
         p = MouseInfo.getPointerInfo().getLocation(); 
         if (p.x > Toolkit.getDefaultToolkit().getScreenSize().getWidth() / 2 + 100)
            //Mueve el ratón a la posición deseada
            robot.mouseMove((int) Toolkit.getDefaultToolkit().getScreenSize().getWidth() / 2 + 100, p.y); 

         if (p.y > Toolkit.getDefaultToolkit().getScreenSize().getHeight() / 2 + 100)
            robot.mouseMove(p.x, (int) Toolkit.getDefaultToolkit().getScreenSize().getHeight() / 2 + 100);

         if (p.x < Toolkit.getDefaultToolkit().getScreenSize().getWidth() / 2 - 100)
            robot.mouseMove((int) Toolkit.getDefaultToolkit().getScreenSize().getWidth() / 2 - 100, p.y);

         if (p.y < Toolkit.getDefaultToolkit().getScreenSize().getHeight() / 2 - 100)
            robot.mouseMove(p.x, (int) Toolkit.getDefaultToolkit().getScreenSize().getHeight() / 2 - 100);
      }
   }
}

Hace algún tiempo pensé que sería interesante tener un gestor propio del portapapeles. Siempre que copiamos algo el portapapeles nos machaca lo anterior y a veces es interesante tener un programa que gestione todo eso. Ya se que existen muchos programas que lo hacen, pero cuando las cosas las haces tu sabes las limitaciones que tiene y puedes modificarlas/mejorarlas a tu gusto.
Lo que pego abajo es una clase que se comunica con el portapapeles pudiendo leer y escribir cadenas en él.
Aunque no lo he tratado supongo que esto será extensible a ficheros sin demasiada complicación.

Estuve mirando la implementación del listener del clipboard pero no se porqué no lanzaba el evento al copiar algo nuevo. Si tengo tiempo volveré a mirar a ver si consigo hacerlo funcionar (trabajaba sobre Windows en ese momento)

import java.awt.Toolkit;
import java.awt.datatransfer.*;
import java.io.IOException;

public class BoardListener implements ClipboardOwner
{
	// Método que recupera una cadena del portapapeles.
	public String getClipboard()
 	{
 		// Obtenemos el contenido del portapapeles del sistema.
 		Transferable t = Toolkit.getDefaultToolkit().getSystemClipboard().getContents(null);
		try
 		{
			// Comprobamos que la información sea de tipo cadena, lo recuperamos y lo devolvemos.
 			if (t != null && t.isDataFlavorSupported(DataFlavor.stringFlavor))
 			{
 				String text = (String) t.getTransferData(DataFlavor.stringFlavor);
 				return text;
 			}
 		}
 		catch (UnsupportedFlavorException e)
 		{
 			e.printStackTrace();
 		}
 		catch (IOException e)
 		{
 			e.printStackTrace();
 		}
		// Si lo copiado no es un texto, devolvemos null
 		return null;
 	}

	// Método que inserta en el portapapeles una cadena.
	 public void setClipboard(String str)
 	{
 		StringSelection ss = new StringSelection(str);
 		Toolkit.getDefaultToolkit().getSystemClipboard().setContents(ss, this);
	 }

	// Necesario para poder implementar la interfaz ClipboardOwner. Para nosotros no tendrá uso, pero es obligatorio "implementarlo".
	 @Override
	 public void lostOwnership(Clipboard clipboard, Transferable contents)
 	{
		// TODO Auto-generated method stub
	}
}

Hace un tiempo me encontré con un programa llamado Kamaleon, el cual era muy útil pues partía archivos en partes de tamaño fijo o aleatorio. La gracia y diferencia con otros programas era que además camuflaba las partes con imágenes. Empecé a usarlo y vi que tenía una limitación bastante grande, el programa explotaba cuando el archivo a partir era superior a cierto tamaño (no recuerdo si 2 o 4 gigas). Así que me decidí y me puse a crear mi propio programa, el JKamaleon (no compatible con el original).

El código es algo extenso y está programado en Java. La verdad es que no está programado eficientemente pero realiza su cometido a la perfección, parte y une archivos.

A continuación os pongo el enlace del código del programa y el archivo JKamaleon.jar listo para usar.

Enlace de descarga: http://dl.dropbox.com/u/22472292/Descargas/JKamaleon.rar