/home/blaster [ Blaster's blog ]

Archive for Noviembre, 2007

Un ArrayList está pensado para realizar busquedas rapidas de información mientras que un LinkedList no permite posicionarse de manera absoluta y por lo tanto no es conveniente para realizar busquedas.

Por otro lado el LinkedList está pensado para realizar inserciones y eliminación de objetos situados al principio de la lista, funciona mucho más rapido que el ArrayList en inserciones, por ejemplo en la posicion 0, cuando el ArrayList es muy grande.

Entonces si pensamos que tendremos muchas busquedas en listas grandes utilizaremos un ArrayList mientras que si tenemos muchas inserciones y eliminaciones en listas grandes utilizaremos un LinkedList.

En las aplicaciones web se utilizan muchas veces datos temporales en forma de hora, fecha u hora y fecha. Estos se pueden almacenar en una base de datos. El problema surge a la hora de hacer el paso de los tipos de datos entre Java y MySQL. Para ello tenemos:

• java.sql.Data
• java.sql.Time
• java.sql.Timestamp

En función de lo que queramos insertar en la base de datos, así utilizaremos uno u otro. Lo vemos con un ejemplo:

StringBuffer sql = new StringBuffer(50);sql.append(”INSERT INTO pedidos (id, hora, fecha, fecha_hora) “);

sql.append(”VALUES (?,?,?,?”);

PreparedStatement ps = null;

ps = conn.prepareStatement(sql.toString());

ps.setInt(1, id);

if (miHora() != null)

{

ps.setTime(2, new java.sql.Time(miHora.getTime()));

}

else

ps.setTime(2, null);

if (miFecha() != null)

{

ps.setDate(3, new java.sql.Date(miFecha.getTime()));

}

else

ps.setDate(3, null);

if (miFechaHora() != null)

{

ps.setTimestamp(4, new java.sql.Timestamp(miFechaHora.getTime()));

}

else

ps.setTimestamp(4, null);

ps.executeUpdate();

El método que llame a éste método declarará

Date miHora = new Date();

Date miFecha = new Date();

Date miFechaHora = new Date();

Como se observa la declaración es igual en todos los casos, y en función de nuestras necesidades filtraremos la fecha o la hora para almacenarla en la base de datos.

1. Si tienes tiempo para comentar tu código, entonces tienes tiempo para refactorizar.
2. Si tienes tiempo para refactorizar, tienes tiempo para hacer pruebas.
3. Si tienes tiempo para hacer pruebas, tienes tiempo para rediseñar el sistema.
4. Si tienes tiempo para rediseñar el sistema, tienes tiempo para beber.
5. Tómate una cerveza: los comentarios son para lloricas.

El original (en ingles) en secretgeek

Un buen momento para recordar la vieja frase: los verdaderos programadores programan en binario.

Un overflow en java ocurre cuando el valor calculado en una expresión es superior al valor más grande que puede almacenar la variable utilizada en función del tipo de la misma.

Java desprecia los bits de mayor orden ya que no puede almacenarlos en la variable que está utilizando en dicha operación. Un ejemplo puede ser el siguiente:

int n = 2000000000;

System.out.println(n * n); // la salida será: -1651507200

El resultado real es 4,000,000,000,000,000,000 pero este valor necesita un tipo de 64 bits.

———- bytes de mayor orden ———

00110111 10000010 11011010 11001110

———- bytes de menor orden ———

10011101 10010000 00000000 00000000

Un tipo de 32 bits no es suficiente para almacenar este valor y java almacenará únicamente los 32 bits de menor orden:

10011101 10010000 00000000 00000000

Este valor es 1651507200, y como el bit de mayor peso es un 1, implica que este número es negativo dando como resultado final de la operación -1651507200.

Resumiendo, un overflow no eleva una excepción en tiempo de ejcución, pero no realiza las operaciones correctamente lo que puede dar como resultado un valor erróneo en la operación realizada. Entonces hay que tener mucho cuidado en las especificaciones del métdo y utilizar tipos long si se cree que puede existir un overflow en alguna operación.

Hay veces que tenemos que copiar y pegar, pero parece que Java nos pone trabas a ellos cuando resulta demasiado evidente.

Por ejemplo, supongamos este método de una clase ficticia:

public void chorrada() {

	StringBuffer sb = new StringBuffer();

	List temporal = new ArrayList();

	for (int n = 0; n<10; n++) {

		String hola = "hola";

		sb.append(n).append(hola);

		temporal.add(sb);

	}

}

Un código absurdo, pero eso no importa. Ahora coge este código, cópialo y pégalo tres veces seguidas, así:

public void chorrada() {

	StringBuffer sb = new StringBuffer();

	List temporal = new ArrayList();

	for (int n = 0; n<10; n++) {

		String hola = "hola";

		sb.append(n).append(hola);

		sb.append(n);

		temporal.add(sb);

	}

	StringBuffer sb = new StringBuffer();

	List temporal = new ArrayList();

	for (int n = 0; n<10; n++) {

		String hola = "hola";

		sb.append(n).append(hola);

		temporal.add(sb);

	}

	StringBuffer sb = new StringBuffer();

	List temporal = new ArrayList();

	for (int n = 0; n<10; n++) {

		String hola = "hola";

		sb.append(n).append(hola);

		temporal.add(sb);

	}

}

Si tienes un IDE moderno o compilas, verás que la segunda y tercera declaración de las variables sb y temporal fallan: “Variable sb is already define in the scope”, que viene a significar como que la variable ya está definida en el ámbito actual. ¿Y cuál es ese ámbito? El código del método, pero ¿porqué? pues porque está cerrado entre sus propias llaves {}. Fíjate que la variable hola está definida también tres veces, pero no falla al compilar. Eso es porqué su ámbito son las llaves {} del bucle for.

Bueno, una manera de evitar esto es añadirle unas llaves a nuestro código, sin más. Así:

public void chorrada() {

	{

		StringBuffer sb = new StringBuffer();

		List temporal = new ArrayList();

		for (int n = 0; n<10; n++) {

			String hola = "hola";

			sb.append(n).append(hola);

			sb.append(n);

			temporal.add(sb);

		}

	}

	{

		StringBuffer sb = new StringBuffer();

		List temporal = new ArrayList();

		for (int n = 0; n<10; n++) {

			String hola = "hola";

			sb.append(n).append(hola);

			sb.append(n);

			temporal.add(sb);

		}

	}

	{

		StringBuffer sb = new StringBuffer();

		List temporal = new ArrayList();

		for (int n = 0; n<10; n++) {

			String hola = "hola";

			sb.append(n).append(hola);

			sb.append(n);

			temporal.add(sb);

		}

	}

}

Ahora cada fragmento tiene su propio ámbito, podemos definir cuantas variables que queramos dentro, que una vez finalice este ámbito definido por sus propias llaves {}, las variables desaparecerán.

Así conseguiremos copiar y pegar con estilo, sin cambios, digno de un buen código spaghetti listo para sembrar el pánico, así que usar con precaución e intentar evitarlo… pero si no hay más remedio…