Optimización

Usar y tirar (autoboxing)

2019-12-22T17:21:00.000-06:00

A partir de java 5 es posible evitar hacer conversiones explícitas de int a java.lang.Integer, por ejemplo:

   public void main() {
      Integer suma1 = sum(1, 2);
      suma1 = sum(1, 2);
   }

   static int sum(Integer a, Integer b) {
      return a + b;
   }

Cuando cuando se de-compila el código de la functión main (Útilizando Bytecode viewer), se obtiene lo siguiente:

     public main() { //()V
         ...

         L1 {
             iconst_1
             invokestatic java/lang/Integer.valueOf(I)Ljava/lang/Integer;
             iconst_2
             invokestatic java/lang/Integer.valueOf(I)Ljava/lang/Integer;
             invokestatic AutoboxExample.sum(Ljava/lang/Integer;Ljava/lang/Integer;)I
             invokestatic java/lang/Integer.valueOf(I)Ljava/lang/Integer;
             astore1
         }
         L3 {
             iconst_1
             invokestatic java/lang/Integer.valueOf(I)Ljava/lang/Integer;
             iconst_2
             invokestatic java/lang/Integer.valueOf(I)Ljava/lang/Integer;
             invokestatic AutoboxExample.sum(Ljava/lang/Integer;Ljava/lang/Integer;)I
             invokestatic java/lang/Integer.valueOf(I)Ljava/lang/Integer;
             astore1
         }
         L4 {
             return
         }
         L2 {
         }
     }

Donde se ve que el código compilado es idéntico a cuando se utiliza valueOf explícitamente.

Esta funcionalidad del compilador, evita que se creen objetos de tipo Integer mediante el constructor Integer(int). Internamente la función valueOf(int), utiliza un cache, para disminuir la creación de objetos de un solo uso.

Este cache está configurado por defecto para los número de -128 a 127 y se puede configurar para incrementar la cantidad de elementos (-XX:AutoBoxCacheMax=<size>).

Usar y tirar (foreach)

2019-11-27T17:03:00.004-06:00

Para iterar sobre un List se puede realizar de la siguiente manera:

  List<string> list = ...;

  int size = list.size();
  for (int i = 0; i < size; i++) {
   String str = list.get(i);
   // ...
   System.out.println(str);
  }

Alternativamente se puede escribir utilizando un interator y un ciclo while:

  List<string> list = ...;

  Iterator<string> iterator = list.iterator();
  while (iterator.hasNext()) {
   String str = iterator.next();
   // ...
   System.out.println(str);
  }

A partir de java 5 se puede escribir así utilizando un foreach:

  List<string> list = ...;

  for (String str : list) {
   // ...
   System.out.println(str);
  }

Al de-compilar la versión con foreach (última) se observa que el compilador, en genera el mismo código que la versión iterator-while. Pero el iterador es un objeto de "usar y tirar", debido a su corta vida, por lo que básicamente es basura, por lo que hay que justificar muy bien su uso. El objetivo de utilizar un iterator, se da principalmente en ambiente multi-hilo, donde pueden ocurrir modificaciones, mientras se esta iterando la lista, pero si la iteración se da en un ambiente de un solo hilo, no es necesario crear el iterator y lo ideal es utilizar el for-size.

Usar y tirar (vargs)

2019-11-26T12:41:00.001-06:00

Objetos de un solo uso

Los objetos de un solo uso son comunes y muchas veces no es trivial visualizarlos, pues son creados implícitamente, por ejemplo:

 public static void main(String[] args) {
  test1("a", "b");
  test2("a", "b");
  test3(new String[] { "a", "b" });
 }
 public static void test1(String... args) {
 }
 public static void test2(String arg1, String arg2) {
 }
 public static void test3(String[] args) {
 }

Al de-compilar la función main, utilizando Bytecode Viewer, se obtiene lo siguiente

Los segmentos L1 y L3, son la invocación del método test1 y el segmento L5 es la invocación del método test3. El código en ambos casos es idéntico, creando un arreglo de cadenas con longitud 2 (iconst_2 y newarray). La implicación es que se crea un arreglo implícitamente, al invocar una función con argumentos variables.

Si el código se modifica, para invocar 2 veces la misma función:

  test1("a", "b");

  test1("a", "b");

El resultado de de-compilar el .class se obtiene lo siguiente:

Donde es posible ver que se crean 2 arreglos distintos, lo cual provoca que el garbage collector sea invocado demasiadas veces.

Para lidiar con el problema algunas herramientas o APIs, evitan utilizar varargs. Por ejemplo Log4j 2, declara múltiples funciones con el mismo nombre, pero que reciben parámetros Object desde el 1 hasta el 9.

Funcionalidades similares, se dan con el foreach o la creación de cadenas.

assert en Java

2019-11-24T00:05:00.000-06:00

Encontré un caso de uso útil para la sentencia assert de java. Cuando se puede definir una constante dependiente de otra previamente definida, por ejemplo:

    public static final String EXT = ".js";

    public static final int EXT_LENGTH = 3;

    static {
        assert EXT_LENGTH == EXT.length();
    }

    public static void main(String[] args) {
        // ...
        String filename = args[0];
        if (filename.endsWith(EXT)) {
            String name = filename.substring(0, filename.length() - EXT_LENGTH);
            System.out.println(name);
            name = filename.substring(0, filename.length() - EXT_LENGTH_ALT);
            System.out.println(name);
        }
        // ...
    }

Al observar el .class, utilizando BYTECODE VIEWER, podemos ver el código equivalente al generado por el compilador:

Como es posible observar, al utilizar la constante literal EXT_LENGTH (cuyo valor se conoce en tiempo de compilación), el valor se substituye directamente, mientras que al utilizar la constante, el código no cambia, pues el valor se conoce al momento de la ejecución. El tema de utilizar assert, es validar que cuando se realiza un cambio (por ejemplo de extensión en este caso), se verifique que el valor de la constante literal se modifique también, si se utiliza maven, es posible definir la propiedad enableAssertions con el valor de true, lo que permite que los asserts se evalúen en conjunto con las pruebas unitarias (ver Surefire maven plugin).

foreach en Java (for para Collections y arrays nativos)

2019-11-23T23:47:00.000-06:00

A partir de la versión 5 de java la secuencia de control for, puede utilizarse como un foreach. El uso de dicha notación hace que la cantidad de código escrito sea menor, pero tiene sus implicaciones negativas, veamos el siguiente ejemplo:

void iterateArray() {
String[] array = new String[] { "alfa", "beta" };
for (String current : array) {
System.out.println(current);
}
}

void iterateCollection() {
Collection collection = Arrays.asList("alfa", "beta");
for (String current : collection) {
System.out.println(current);
}
}

Ambos códigos se "parecen", pero al revisar el código generado podemos observar las diferencias de fondo, utilizando BYTECODE VIEWER, donde es posible decompilar la clase resultante y ver lo que genera el compilador (también muestra las instrucciones de la JVM, pero en este caso nos interesa el código generado)

Como se puede ver, de inicio si bien el código escrito por el programador es menor, el código generador por el compilador, para ser ejecutado por la JVM, es similar al que se empleaba antes de java 5 (es decir sin la sentencia de control foreach). Cabe destacar que ademas por lo generar al ejecutar la instrucción iterator de la colección, se crea un objeto para iterar (ver complementación de Iterable en ArrayList por ejemplo, el cual regresa "new Itr()")

Conversión de una fecha a una cadena

2012-05-22T00:13:00.004-05:00

Cuando es importante el que el tiempo de respuesta sea mínimo, la conversión a cadenas de tipos complejos, pero comunes, puede volverse importante. Un ejemplo de esto, es la conversión de fechas a cadenas. La mayoría de los APIs de generación de bitácoras, tocan el tema como un factor importante en el desempeño de una aplicación, puesto que la generación de las bitácoras, pueden influir drásticamente en tiempo de respuesta, dada la cantidad de las mismas que pueden generarse.

Para convertir una fecha a una cadena, en un formato determinado, particularmente sin utilizar los nombres de los días o de los meses, se puede realizar utilizando un arreglo de caracteres y utilizando funciones matemáticas simples.

01: package org.test.util;
02: 
03: import java.util.Calendar;
04: 
05: public final class DateTimeUtil {
06: 
07:         private static final Calendar calendar;
08:         private static final char[] buffer;
09: 
10:         static {
11:                 calendar = Calendar.getInstance();
12:                 buffer = new char[23];
13:         }
14: 
15:         private DateTimeUtil() {
16:         }
17: 
18:         /**
19:          * formato equivalente a "yyyy/MM/dd HH:mm:ss,SSS"
20:          */
21:         public static String formatDate(long time) {
22:                 int year;
23:                 int month;
24:                 int day;
25:                 int hour;
26:                 int minute;
27:                 int second;
28:                 int millisecond;
29:                 synchronized (calendar) {
30:                         calendar.setTimeInMillis(time);
31:                         year = calendar.get(Calendar.YEAR);
32:                         month = calendar.get(Calendar.MONTH);
33:                         day = calendar.get(Calendar.DAY_OF_MONTH);
34:                         hour = calendar.get(Calendar.HOUR_OF_DAY);
35:                         minute = calendar.get(Calendar.MINUTE);
36:                         second = calendar.get(Calendar.SECOND);
37:                         millisecond = calendar.get(Calendar.MILLISECOND);
38:                 }
39:                 synchronized (buffer) {
40:                         buffer[0] = (char) ('0' + year / 1000);
41:                         year %= 1000;
42:                         buffer[1] = (char) ('0' + year / 100);
43:                         year %= 100;
44:                         buffer[2] = (char) ('0' + year / 10);
45:                         year %= 10;
46:                         buffer[3] = (char) ('0' + year);
47:                         buffer[4] = '/';
48:                         buffer[5] = (char) ('0' + month / 10);
49:                         month %= 10;
50:                         buffer[6] = (char) ('0' + month);
51:                         buffer[7] = '/';
52:                         buffer[8] = (char) ('0' + day / 10);
53:                         day %= 10;
54:                         buffer[9] = (char) ('0' + day);
55:                         buffer[10] = ' ';
56:                         buffer[11] = (char) ('0' + hour / 10);
57:                         hour %= 10;
58:                         buffer[12] = (char) ('0' + hour);
59:                         buffer[13] = ':';
60:                         buffer[14] = (char) ('0' + minute / 10);
61:                         minute %= 10;
62:                         buffer[15] = (char) ('0' + minute);
63:                         buffer[16] = ':';
64:                         buffer[17] = (char) ('0' + second / 10);
65:                         second %= 10;
66:                         buffer[18] = (char) ('0' + second);
67:                         buffer[19] = ',';
68:                         buffer[20] = (char) ('0' + millisecond / 100);
69:                         millisecond %= 100;
70:                         buffer[21] = (char) ('0' + millisecond / 10);
71:                         millisecond %= 10;
72:                         buffer[22] = (char) ('0' + millisecond);
73:                         return new String(buffer);
74:                 }
75:         }
76: 
77: }

Cómo se puede observar, se utiliza una sola instancia de java.util.Calendar, así como una sola instancia de un arreglo de caracteres, con el fin de minimizar el uso de memoria. Debido a esto, es necesario sincronizar el código que extrae el año, mes, día, hora, minuto, segundo y milisegundo. Posteriormente se libera el objeto calendar y se sincroniza el código que realiza el formateo los datos extraídos previamente, esto utilizando las operaciones división, suma y modulo. Finalmente, se construye una cadena con el arreglo de caracteres.

El formato es fijo, por lo que no hay necesidad de tratar de detectar posibles opciones. No se utilizan formatos que dependan del lenguaje, por lo que la longitud, también es fija. Esto en conjunto ayuda a minimizar el tiempo de respuesta, dando una opción al uso de la clase java.util.SimpleDateFormat, la cual al ser una clase genérica, puede tardar un poco más, debido a la necesidad de resolver las situaciones con el idioma.

Constantes dinámicas

2012-05-17T23:00:00.001-05:00

En ocasiones es neceasario cargar valores constantes de un archivo de configuración. Estos archivos de configuración se cargan en memoria parseando el archivo y posteriormente obteniendo la propiedad respectiva de objeto que resulta del parseo del archivo. Incluso puede exiatir la neceaidad de realizar la conversión de la esta a número, fecha, booleano, etc..

El siguiente código es común encontrarlo en cualquier desarrollo (se presume que la variable properties es del tipo java.util.Properties):


 while (condition) {

  System.out.println(Float.parseFloat(properties
    .getProperty("percent")));
  System.out.println(currentData.getCurrentAmount()
    * Float.parseFloat(properties.getProperty("percent")));
  float amount = currentData.getCurrentAmount()
    * Float.parseFloat(properties.getProperty("percent"));
  save(amount);

 }

Donde, como se puede ver, se parsea hasta 3 veces la misma propiedad. Para solventar este problema, es posible declarar en la clase (o en una clase auxiliar) esta propiedad, incluso realizando la conversión previamente.


  private static final float PERCENT = Float.parseFloat(properties
   .getProperty("percent"));

Y en el código anterior:


  while (condition) {
    System.out.println(PERCENT);
    System.out.println(currentData.getCurrentAmount() * PERCENT);
    float amount = currentData.getCurrentAmount() * PERCENT;
    save(amount);
  }

Con lo cual se evita el procesamiento adiciónal de recuperar la propiedad y posteriormente realizar la conversión.

Extraer un caracter de una cadena en java

2011-10-19T21:48:00.000-05:00

En ocasiones, es necesario extraer un caracter de una cadena. Existen varias formas de realizar esta accion, una de ellas, es la siguiente:

String s = "Hola mundo";
  s.substring(0,1);

Sin embargo, la forma optima de realizar esta tarea, es utilizado la funcion charAt.

String s = "Hola mundo";
  s.charAt(0);

La principal ventaja en utilizar esta ultima funcion, radica en que se obtiene un valor directamente, mientras que en el primer codigo, se obtiene un objeto, por lo que al comparar, en el primer caso, es necesario utilizar la funcion equals, mientras que en la segunda se utiliza el operador de comparacion ==, derivado de lo mismo (al menos hasta java 1.6), el valor retornado por la funcion charAt, se puede utilizar dentro de una instruccion switch.

Concatenacion de dos cadenas (concat)

2011-08-21T01:45:00.000-05:00

La concatenacion de cadenas, es una operacion ampliamente utilizada en los lenguajes de programacion. Pero en el caso de algunos lenguajes compilados, existen metodos poco utilizados, pero muy utiles. Un ejemplo es el metodo java.lant.String.concat o System.String.Concat que tienen algunos lenguajes de programación como java o C#. Veamos por que.

Cuando es necesario concatenar exactamente 2 cadenas y utilizar inmediatamente el resultado de esto (por ejemplo, agregar una extension a un nombre de archivo, para crearlo) es recomendable utilizar este metodo y no algun otro alternativo, como el uso de operadores o de clases auxiliares, como lo es java.lang.StringBuilder o System.StringBuilder.

¿Que ocurre, cuando se emplea StringBuilder?

Creacion del objeto StringBuilder, inicializado, con la primer cadena (Creacion del primer objeto)
Agregar los elementos caracteres de la segunda cadena (posiblemente expandiendo el buffer del builder, posiblemente creando el segundo objeto implicito, un arreglo de caracteres).
Crear un nuevo objeto cadena (Creacion del segundo o tercer objeto)

¿Que ocurre cuando se emplea el metodo concat?

Cracion de un nuevo objeto cadena, con la longitud exacta de la suma de ambos elementos (Creacion del primer y unico nuevo objeto)
Copiar los elementos de la primer cadena
Copiar los elementos de la segunda cadena

Cuando se trata de concatenar exactamente dos cadenas, el metodo concat es optimo, en terminos de uso de memoria, por que solo utiliza la cantidad exacta de memoria, mientras que la clase StringBuilder, al ser generica (para concatenar cualquier cantidad de cadenas) aloja bloques de memoria de tamaños distintos, tratando de evitar alojar memoria posteriormente (normalmente, son bloques cada vez mas grandes) y al finalmente, crea un objeto String, con el resultado de la concatenacion.

Nota: Dependiendo del lenguaje de programacion, asi como la version del mismo, el metodo de concatenacion, puede o no tener alguna de las siguientes optimizaciones.

Si el metodo recibe dos parametros exactamente y es miembro estatico

Si ambos parametros son nulos, se regresa la cadena vacia.
Cuando alguno de los dos parametros es nulo, se regresa el otro parametro.
Cuando alguno de los dos parametros es la cadena vacia, se regresa el otro parametro.

Cuando el metodo no es estatico y se invoca utilizando un objeto de la clase String

Si el parametro que se recibe es nulo, se regresa la cadena referenciada por this.
Si el parametro que se recibe es la cadena vacia, se regresa la cadena referenciada por this.

Utilizar la memoria RAM como cache en Linux (ramdisk)

2011-07-15T22:23:00.000-05:00

La mayoria de las distribuciones de linux cuentan con la capacidad de utilizar la memoria de acceso aleatorio como un sistema de archivos normal, donde se puede crear, leer, escribir y borrar un archivo, asi como crear directorios y borrarlos.

Lo primero que hay que ubicar, es que existan los archivos que inician con el prefijo ram, en el directorio /dev. Al ejecutar el listado de estos archivos, se obtiene una salida similar a esta:

$ ls -l /dev/ram*

brw-rw----. 1 root disk 1, 0 Jul 14 22:36 /dev/ram0

brw-rw----. 1 root disk 1, 1 Jul 14 22:49 /dev/ram1

brw-rw----. 1 root disk 1, 10 Jul 14 22:36 /dev/ram10

brw-rw----. 1 root disk 1, 11 Jul 14 22:36 /dev/ram11

brw-rw----. 1 root disk 1, 12 Jul 14 22:36 /dev/ram12

brw-rw----. 1 root disk 1, 13 Jul 14 22:36 /dev/ram13

brw-rw----. 1 root disk 1, 14 Jul 14 22:36 /dev/ram14

brw-rw----. 1 root disk 1, 15 Jul 14 22:36 /dev/ram15

brw-rw----. 1 root disk 1, 2 Jul 14 22:36 /dev/ram2

brw-rw----. 1 root disk 1, 3 Jul 14 22:36 /dev/ram3

brw-rw----. 1 root disk 1, 4 Jul 14 22:36 /dev/ram4

brw-rw----. 1 root disk 1, 5 Jul 14 22:36 /dev/ram5

brw-rw----. 1 root disk 1, 6 Jul 14 22:36 /dev/ram6

brw-rw----. 1 root disk 1, 7 Jul 14 22:36 /dev/ram7

brw-rw----. 1 root disk 1, 8 Jul 14 22:36 /dev/ram8

brw-rw----. 1 root disk 1, 9 Jul 14 22:36 /dev/ram9

Para formatear y utilizar estos archivos, es necesario hacerlo como el usuario root. Esto, debido a que el propietario de los archivos es root.

$ su -

Password:

# mkfs.ext2 -q /dev/ram1

# mkdir tmp

# mount /dev/ram1 tmp

# df -k tmp

Filesystem 1K-blocks Used Available Use% Mounted on

/dev/ram1 15863 140 14904 1% /root/tmp

Ahora en el directorio tmp, se tiene un sistema de archivos, que utiliza la memoria de acceso aleatorio, como un directorio normal dentro del sistema. Cabe destacar que este directorio, sera destruido cuando se reinicie el sistema, por lo que cualquier informacion importante, debe ser respaldada previamente antes de reiniciar.

---

Utilizar la memoria RAM como cache automatico en Linux

2011-07-14T02:24:00.002-05:00

En los sistemas linux, el uso de memoria RAM como cache, es gestionado por el kernel de manera automatica, sin necesidad de configurar o ejecutar los programas de manera distinta a la usual.

Veamos el siguiente ejemplo, en el cual, se tiene un archivo de 25.85M aproximadamente.

$ ls -l archivo.bin

-rwxr-xr-x. 1 cmartine cmartine 27109840 Jul 1 10:52 archivo.bin

Utilizando el comando time, para determinar el tiempo de ejecucion y el comando cat para realizar la lectura del archivo, obtenemos lo siguiente en la primer ejecucion. Nota: se envia la salida al dispositivo /dev/null, para descartarla.

$ time cat archivo.bin > /dev/null

real 0m0.466s

user 0m0.002s

sys 0m0.123s

El tiempo que se tardo en ejecutar fue de 0.466 segundo. Posteriormente, ejecutando el mismo comando inmediatamente 3 veces seguidas, se obtiene el siguiente resultado:

$ time cat archivo.bin > /dev/null

real 0m0.040s

user 0m0.002s

sys 0m0.037s

$ time cat archivo.bin > /dev/null

real 0m0.026s

user 0m0.001s

sys 0m0.025s

$ time cat archivo.bin > /dev/null

real 0m0.029s

user 0m0.000s

sys 0m0.025s

Como se puede observar, el tiempo real, disminuyo drasticamente a menos de la decima parte del tiempo original. Esto es debido a que el kernel de linux maneja de manera automatica la memoria RAM que no se emplea en crear un cache de los archivos utilizados, sin necesidad de realizar configuracion alguna. La cantidad de memoria que esta siendoutilizada en este cache, se puede consultar utilizando el comando top.

¿Por que linux hace esto? Sencillamente por que si no se emplea la memoria, estaria desocupada (desperdiciandose cuando el sistema no la esta utilizando para realizar algun trabajo). Es importante aclara, que cuando se ejecuta un programa, el cual requiere utilizar mucha memoria, se libera parte de la memoria utilizada para el cache y se asigna al programa, pudiendo llegar a la situacion en que el cache ya no tenga memoria asignada, por que un programa requiere utilizar toda la memoria del sistema

Comparacion entre 2 fechas

2011-06-23T14:19:00.003-05:00

Comparar 2 fechas, para determinar cual es mayor, puede ser sencillo, sobre todo, si con lo que trabajas soporta el concepto de fecha y/o tiempo, por ejemplo: java.util.Date en java o System.DateTime en C#, que son lenguajes de programacion o incluso en hojas de datos, tipo Microsoft Excel o LibreOffice Calc.

El problema, se presenta, cuando es necesario trabajar con lenguajes que no conocen el concepto, como los shells de unix o cuando se almacenan archivos que contienen la fecha en el nombre del mismo.

En este punto la abstraccion de la fecha y la forma en como se representa, suele tomar un papel importante, dado que puede resolver completamente el problema, si se emplea el formato correcto.

Formas comunes de representar una fecha son: dia/mes/año en mexico o mes/dia/año en EEUU. Para nombres de archivos se suelen substituir las diagonales, por guiones, asi como el uso del nombre del mes y no el numero de mes. Por ejemplo:

Jun/27/2011
Oct/21/2011
Jul/1/2011
Oct/24/2005
Jul/4/2011

Si se ordena alfabeticamente, se obtiene lo siguiente:

Jul/1/2011
Jul/4/2011
Jun/27/2011
Oct/21/2011
Oct/24/2005

Lo cual no es lo que se requiere, sin embargo, si se reacomoda la fecha utilizando el orden año, mes, dia:

2011/Jun/27
2011/Oct/21
2011/Jul/1
2005/Oct/24
2011/Jul/4

Al ordenar se obtiene lo siguiente:

2005/Oct/24
2011/Jul/1
2011/Jul/4
2011/Jun/27
2011/Oct/21

El problema con el que nos encontramos es que la l esta antes que la n, en orden alfabetico, para sortear este inconveniente, en vez del nombre del mes, utilizamos el numero del mes:

2011/6/27
2011/10/21
2011/7/1
2005/10/24
2011/7/4

Al ordenar, obtenemos lo siguiente:

2005/10/24
2011/6/27
2011/10/1
2011/7/1
2011/7/4

Este resultado tampoco es correcto, esto es debido a que la longitud de los meses, es variable, por lo que, agregamos un 0 a la izquierda, cuando el mes esta formado por un solo digito (es recomendable tambien hacerlo para los dias)

2011/06/27
2011/10/21
2011/07/01
2005/10/24
2011/07/04

Al ordenar, obtenemos lo siguiente:

2005/10/24
2011/06/27
2011/07/01
2011/07/04
2011/10/01

Que es finalmente lo que se requiere.

Esto, se puede aplicar a la creacion de nombres de archivos, por ejemplo, para poder ordenarlos por una fecha en particular, sobre todo cuando la fecha de creacion, es incorrecta (cuando son enviados por correo electronico y se pierde la fecha de creacion del archivo), por ejemplo los siguientes nombres de archivos seran ordenados correctamente por el sistema operativo al momento de listarlos (esto tanto en windows, linux o mac os)

reporte_2011-06-27.txt
reporte_2011-10-21.txt
reporte_2011-07-01.txt
reporte_2005-10-24.txt
reporte_2011-07-04.txt

Al ser listados, se obtiene lo siguiente:

reporte_2005-10-24.txt
reporte_2011-06-27.txt
reporte_2011-07-01.txt
reporte_2011-07-04.txt
reporte_2011-10-21.txt

En unix, incluso, es posible emplear las fechas en este formato, con el comando expr, el cual puede comparar dos cadenas y determinar cual es mayor o menor.

Implementación la funcion compareTo de IComparable en C#

2011-05-05T22:43:00.002-05:00

La interfaces IComparable e IComparable<t> de C#, se utilizan para comparar objetos, normalmente del mismo tipo y determinar, si alguno es mayor, menor o la equivalencia. A continuacion, se presentan 4 ejemplos de como implementar esta funcionalidad.

Nota1: Para el primer ejemplo, se utiliza el concepto de National Identification Number (CURP en México, RUN en Chile, DNI en España y Argentina o Tarjeta de Identidad en colombia, por ejemplo)
Nota2: Por razones de compatibilidad, se implementan 2 interfaces distintas, con funcionalidades similares, en la implementacion de estas clases.

class Person1 : System.IComparable, System.IComparable<Person1>
    {
        private string nin; // National Identification Number
        private string name;
        private string surname;

        //...

        public int CompareTo(object obj)
        {
            if (obj is Person1)
            {
                return obj == null ? 1 : nin.CompareTo(((Person1)obj).nin);
            }
            throw new System.ArgumentException();
        }

        public int CompareTo(Person1 p)
        {
            return p == null ? 1 : nin.CompareTo(p.nin);
        }

    }

    class Person2 : System.IComparable, System.IComparable<Person2>
    {
        private int id;
        private string name;
        private string surname;

        //...

        public int CompareTo(object obj)
        {
            if (obj is Person2)
            {
                return obj == null ? 1 : id.CompareTo(((Person2)obj).id);
            }
            throw new System.ArgumentException();
        }

        public int CompareTo(Person2 p)
        {
            return p == null ? 1 : id.CompareTo(p.id);
        }


    }

    class Person3 : System.IComparable, System.IComparable<Person3>
    {
        private int id;
        private string name;
        private string surname;

        //...

        public int CompareTo(object obj)
        {
            if (obj == null)
            {
                return 1;
            }
            else
            {
                if (obj is Person3)
                {
                    Person3 o = (Person3)obj;
                    return id - o.id;
                }
                throw new System.ArgumentException();
            }
        }

        public int CompareTo(Person3 p)
        {
            return p == null ? 1 : id - p.id;
        }

    }

    class Person4 : System.IComparable, System.IComparable<Person4>
    {
        private int idPart1;
        private string idPart2;
        private string name;
        private string surname;

        //...

        private int CompareTo0(Person4 p)
        {
            int v = idPart1 - p.idPart1;
            if (v == 0)
            {
                v = idPart2.CompareTo(p.idPart2);
            }
            return v;
        }

        public int CompareTo(object obj)
        {
            if (obj == null)
            {
                return 1;
            }
            else
            {
                if (obj is Person4)
                {
                    return CompareTo0((Person4)obj);
                }
                throw new System.ArgumentException();
            }
        }

        public int CompareTo(Person4 p)
        {
            if (p == null)
            {
                return 1;
            }
            else
            {
                return CompareTo0(p);
            }
        }

    }

En el primer y segundo ejemplo, se implementa la funcionalidad, utilizando la funcion CompareTo implementada por la clase string y por la estructura int32. Regresando el resultado de ejecutar dicha funcion. En el tercer ejemplo, se muestra, como se puede implementar utilizando la diferencia entre 2 enteros (es posible utilizar cualquier tipo entero, como un byte, short, int). Finalmente, en el cuarto ejemplo, se implementa la funcionalidad utilizando 2 propiedades, donde se compara la primer propiedad y en caso de igualdad, se regresa el resultado de comparar la segunda propiedad. Tambiem, en este ultimo ejemplo, define una funcion intermedia (CompareTo0), la cual hace la comparacion real y es llamada por las 2 implementaciones del CompareTo.

Como se observa. por razones de compatibilidad, es necesario implementar la funcionalidad de 2 interfaces, una utlizando Generics y otra sin pre-generics. En la version Generics, es necesario validar que el tipo de corresponde con la clase que implementa, en caso de no coincidir, hay que generar una excepcion del tipo ArgumentException. En el caso del null, la documentacion tambien especifica regresar 1 explicitamente. Final mente, en C#, como en C, se especifican valores validos cualquier entero positivo, negativo o cero (dentro de los rangos de int32)

Es recomendable, por cuestiones de simplicidad en la implementacion, incluir en la comparacion solo los valores que corresponden a la llave primaria, comparandolos, en orden de importancia, regresando el valor, del primero que resulte distinto (como se muestra en el ejemplo 4).

Implementación la funcion compareTo de Comparable en java

2011-04-28T00:15:00.009-05:00

La interface Comparable se emplea, para indicar si el objeto representado por this es menor, igual o mayor que el objeto que se pasa como parametro. A continuacion se presentan 3 ejemplos de clases que definen la funcion compareTo en base a una propiedad existente. Nota, en algunos paises existe el concepto de National Identification Number (CURP en México, RUN en Chile, DNI en España y Argentina o Tarjeta de Identidad en colombia, por ejemplo)

public class ExamplePerson1 implements Comparable<ExamplePerson1> {

 private String nin; // National Identification Number
 private String name;
 private String surname;

 ...

 @Override
 public int compareTo(ExamplePerson1 o) {
  return this.nin.compareTo(o.nin);
 }

}

public class ExamplePerson2 implements Comparable<ExamplePerson2> {

 private Integer id;
 private String name;
 private String surname;

 ...

 @Override
 public int compareTo(ExamplePerson2 o) {
  return this.id.compareTo(o.id);
 }

}

public class ExamplePerson3 implements Comparable<ExamplePerson3> {

 private int id;
 private String name;
 private String surname;

 ...

 @Override
 public int compareTo(ExamplePerson3 o) {
  return this.id < o.id ? -1 : (this.id == o.id ? 0 : 1);
 }

}

En el ejemplo 1 y 2, se emplean propiedades de tipo String e Integer las cuales implementan la interface Comparable, por lo que solo se regresa el resultado de llamar la funcion compareTo de la propiedad respectiva. En el ejemplo 3 se utiliza una propiedad de tipo nativo y se muestra un ejemplo de como puede implementarse la funcion, utilizando las clases que envuelven a los tipos nativos (wrappers), evitando el uso de autoboxing y autounboxing.

En estos ejemplos, solo se emplea una propiedad, para implementar la funcionalidad. La recomendacion, es utilizar solo los atributos que forman la llave primaria (el concepto de base de datos). En caso de requerir utilizar mas de una propiedad, se incremanta el grado de complejidad. Como se muestra en el siguiente ejemplo.

public class ExamplePerson4 implements Comparable<ExamplePerson4> {

 private Integer idPart1;
 private Integer idPart2;
 private String name;
 private String surname;

 ...

 @Override
 public int compareTo(ExamplePerson4 o) {
  int result = this.idPart1.compareTo(o.idPart1);
  if(result == 0) {
   result = this.idPart2.compareTo(o.idPart2);
  }
  return result;
 }

}

Como se observa, si la comparacion de la primer propiedad es cero, hay que comparar la segunda propiedad y asi sucesivamente, hasta encontrar una distinta o ya no tener mas propiedades.

--- Actualizacion ---

En ocasiones, es necesario evitar que la comparacion genere una excepcion del tipo NullPointerException, cuando el parametro que recibe la funcion compareTo, es null. Para procesar el null, es necesario insertar un if para validar si es null, en caso de ser null, se regresa el valor necesario (normalmente 0), en caso contrario, se regresa el valor calculado, utilizando el algoritmo descrito anteriormente.

public class ExamplePerson5 implements Comparable<ExamplePerson5> {

 private Integer id;
 private String name;
 private String surname;

 ...

 @Override
 public int compareTo(ExamplePerson5 o) {
  return o == null ? 0 : this.id.compareTo(o.id);
 }

}

Existe la posibilidad de implmentarlo utilizando un try-catch, en vez de utilizar un if. Si bien en apariencia no se ejecutan 2 operaciones, cuando se emplea el if (primero la comparacion contra null y posteriormente la evaluacion del if en si). En la practica no es optimo, dado que cuando se recibe un null, se genera una excepcion, que implicitamente es, la creacion del objeto excepcion, el llenado del stack (que en el caso de un programa muy sencillo son 3 o 4 elementos en el stack, pero en el caso de sistemas complejos, pueden ser mas de 50 elementos).

public class ExamplePerson6 implements Comparable<ExamplePerson6> {

 private Integer id;
 private String name;
 private String surname;

 ...

 @Override
 public int compareTo(ExamplePerson6 o) {
  try {
   return this.id.compareTo(o.id);
  } catch (NullPointerException e) {
   return 0;
  }
 }

}

En conclusion, siempre es recomendable utilizar un if, si se necesita regresar un valor en caso de que el parametro sea null y evitar el uso de un try-catch.

Diferencia entre 2 fechas (años cumplidos) en java

2011-04-27T21:36:00.001-05:00

Obtener los años cumplidos, a partir de una fecha en particular, tiene sus aplicaciones (validar mayoria de edad en las personas, verificar si aun aplica una garantia, a partir de la fecha de compra, etc)

La aproximacion, es la siguiente:

 1 import java.util.Calendar;
 2 import java.util.Date;
 3 
 4 public class DatesDiff {
 5 
 6  public static int calculateAge(Date bornDate) {
 7   Calendar cal = Calendar.getInstance(); // current date
 8   int currYear = cal.get(Calendar.YEAR);
 9   int currMonth = cal.get(Calendar.MONTH);
10   int currDay = cal.get(Calendar.DAY_OF_MONTH);
11   cal.setTime(bornDate); // now born date
12   int years = currYear - cal.get(Calendar.YEAR);
13   int bornMonth = cal.get(Calendar.MONTH);
14   if (bornMonth == currMonth) { // same month
15    return cal.get(Calendar.DAY_OF_MONTH) <= currDay ? years
16      : years - 1;
17   } else {
18    return bornMonth < currMonth ? years - 1 : years;
19   }
20  }
21 
22 }

Explicación:
07-07: Se obtiene la fecha actual, al obtener una instancia del objeto Calendar
08-10: Se obtienen lo valores del año, mes y dia actual (cache)
11-11: Se actualiza el objeto cal, con la fecha de nacimiento
12-12: Se calcula la diferencia de años
13-13: Se obtiene el año de nacimiento (cache)
14-14: Se verifica si el mes actual coincide con el mes de nacimiento
15-15: Si los meses coinciden, se valida si el los dias coinciden, de ser este el caso, se regresan la diferencia de años, en caso contrario (aun no se cumple otro año) se regresa la diferencia menos uno.
18-18: Si los meses no coinciden, se regresala diferencia de los años menos 1 si el mes de nacimiento es menor que el mes actual y la diferencia de años, en caso contrario

En este codigo, se utiliza un solo objeto Calendar en vez de 2 objetos distintos. En vez de utilizar un objeto Calendar nuevo, obtenemos los valores que se emplearan a posteriormente en variables de tipo nativo, las cuales radican en el pila (stack), en vez de el (heap).

Una optimizacion posible, es parametrizar la fecha actual, para el tema de internacionalizacion, con respecto a las zonas horarias, ya que se da la posibilidad que tomando en cuenta la fecha de la zona horaria de un pais distnto puede ser que se cumpla o no un año mas.

tablas de hash y su relacion con las funciones GetHashCode y Equals de C# y hashCode y equals de Java

2010-07-01T23:55:00.000-05:00

La mayoria de los lenguajes de programacion implementan tablas de hash en alguna de sus variantes (Hashtable, HashMap en Java o Hastable en C#). Un problema asociado a esta funcionalidad, es la correcta implementacion de las funciones para generar el codigo el codigo de hash de la llave, que sirve para obtener el valor asociado a la misma dentro de la tabla de hash.

Como se vio en el post hashCode y equals funcion en Java o GetHashCode y Equals en C#, una tabla de hash, se puede comparar con un diccionario. Dado que la funcion que obtiene el codigo hash de un objeto (GetHashCode para C# y hashCode para Java) puede obtener el valor entre -2³¹ y +2³¹ y si el codigo de hash, es unico, entonces, este codigo puede fungir como una "llave" adicional, sobre todo, si se define correctamente y se implementa una funcion que genere este codigo lo mas rapido posible.

Los tiempos de respuesta y uso de memoria de una tabla de hash, dependen de como se implemente, asi como de una correcta definicion de la funcion que genere el codigo de hash. El secreto del desempeño de la tabla de hash, esta el uso de la aritmetica modular, utilizada para determinar que codigos de hash son similares.

Tanto en Java, como en C# el codigo de hash, esta representado por un numero entero de 32 bits (4 bytes), esto da la posibilidad de tener 2³² (poco mas de 4 mil millones o millardos) posibles codigos de hash distintos. Como se vio en otro post, el codigo de hash, se emplea para "indexar" la informacion y realizar una busqueda ejecutando el menor numero de comparaciones posibles.

Para ver como funciona comparemos ahora la tabla de hash con un hospital, el cual tiene un archivo, donde por cuestiones de orden, se colocan los expedientes en cajones. Existen 27 cajones (utilizaremos el alfabeto ingles, el cual no tiene ñ, ch, ni acentos, dieresis u otras letras, simbolos, acentos, etc) cada cajon almacena los expedientes correspondientes a la letra inicial del nombre de la persona.

Suponiendo que el hospital es nuevo (new Hospital()), los 27 cajones estan vacios. cuando llega el primer paciente, se le genera un nuevo expediente y cuando se da de alta, se almacena su expediente en el archivo, si el paciente se llama Ricardo, el cajon que tiene una letra R al frente tendra un unico expediente y los otros 26 expedientes, seguiran vacios.

Si llega un nuevo paciente, llamado Juan, lo ideal, es que se busque si no tiene un expediente, entonces, buscando en el cajon donde se almacenan los expedientes que inician con J, nos damos cuenta de que no tiene expediente y creamos uno nuevo, para posteriormente almacenarlo.

Pero, este hospital es un poco desordenado al momento de almacenar los archivos, pues cuando llega otra persona con cuyo nombre es Ramon, el nuevo expediente, simplemente se pone encima del anterior y cuando llega Rosa, ocurre lo mismo, es decir, dentro del cada cajon, los expedientes, no se ordenan. Esto provoca que cuando llega una persona llamada Romario, se deba buscar el nombre en 3 expedientes distintos, puesto que al no estar ordenados alfabeticamente, hay que comparar el nombre para verificar que no es el expediente buscado. Por lo que es ligeramente mas tardado el proceso de busqueda del expediente de una persona cuyo nombre inicia con R que si inicia con J o si inicia con cualquier otra letra del abecedario. Ya se atendio Romario y se le genero un expediente. Extrañamente, viene una persona que se llama Ruperto (si, ya se, muchas R), esto provoca que el cajon donde estan estos expedientes, comienze a desbordarse y la busqueda cada vez tarde mas.

Esto que estoy describiendo, ocurre, cuando la funcion que genera el codigo de hash (la letra inicial del nombre, en este caso) esta incorrectamente definida y todos o la mayoria de los elementos que estamos almacenando tengan el mismo codigo de hash.

Para evitar esta situacion, se suelen definir funciones, en ocasiones extrañamente complejas, imaginemos por un momento, que cambiase las reglas para almacenar la informacion, ahora tendre las mismas 27 cajas, pero para determinar el cajon donde se almacenara el expediente, se sumara el valor ASCII de cada letra del nombre de la persona, el resultado se multiplicara por 13 (un numero primo por cierto) y se realizara la operacion modulo 27, al resultado de este, se le sumara 1, el resultado de esto, se convertira a una letra, 1 por A, 2 por B ... y 27 por Z ... Despues de realizar todas estas operaciones , no duden que probablemente haya uno y solo un expediente por cajon, pero ahora la generacion del codigo de hash se volvio costosa en tiempo.

Ahora, que ocurre cuando se agregan mas letras al abecedario, por ejemplo acentos y dieresis, asi como la letra ñ, pero sin agregar cajones a nuestro sistema de almacenamiento. La solucion es buscar similitudes o equivalencias, por ejemplo n es parecida a la letra ñ y las letras acentuadas o con dieresis a las mismas sin el acento o la dieresis. Esto es buscar similitudes o equivalencias. Para realizar estas operaciones de "equivalencias" las tablas de hash, utilizan aritmetica modular, es decir, dado que el universo para la generacion del codigo de hash, es basto, se emplea este tipo de aritmetica, para determinar que codigos de hash son similares y almacenarlos conjuntamente.

operador +, cadenas, cadenas constante y el compilador en C#

2010-06-03T16:13:00.000-05:00

Al igual que en java, el compilador de C# es capaz de realizar optimizaciones al momento de compilar el codigo y convertir una instruccion en otra, utilizando las funciones definidas en la clase String.

Como se vio en el post dedicado a java, es posible utilizar el compilador a nuestro favor, cuando se conoce como funciona.
En el siguiente ejemplo, se muestra una concatenacion, utilizando el operador +.

01: using System;
02: using System.Collections.Generic;
03: using System.Linq;
04: using System.Text;
05: 
06: namespace ClassLibrary1
07: {
08:     public class Class1
09:     {
10:         void Test()
11:         {
12:             string a = "cadena1";
13:             string b = "cadena2";
14:             string x = a + b;
15:             Console.WriteLine(x);
16:         }
17:     }
18: }
19:

Al decompilar el codigo, empleando el comando ildasm, se obtiene el siguiente codigo:

.method private hidebysig instance void  Test() cil managed
   {
     // Code size       29 (0x1d)
     .maxstack  2
     .locals init ([0] string a,
              [1] string b,
              [2] string x)
     IL_0000:  nop
     IL_0001:  ldstr      "cadena1"
     IL_0006:  stloc.0
     IL_0007:  ldstr      "cadena2"
     IL_000c:  stloc.1
     IL_000d:  ldloc.0
     IL_000e:  ldloc.1
     IL_000f:  call       string [mscorlib]System.String::Concat(string,
                                                              string)
     IL_0014:  stloc.2
     IL_0015:  ldloc.2
     IL_0016:  call       void [mscorlib]System.Console::WriteLine(string)
     IL_001b:  nop
     IL_001c:  ret
   } // end of method Class1::Test

El codigo que genera codigo similar es el siguiente:

01: using System;
02: using System.Collections.Generic;
03: using System.Linq;
04: using System.Text;
05: 
06: namespace ClassLibrary1
07: {
08:     public class Class2
09:     {
10:         void Test()
11:         {
12:             string x = String.Concat("cadena1","cadena2");
13:             Console.WriteLine(x);
14:         }
15:     }
16: }
17:

Como es posible observar, el codigo generado ejecuta una funcion propia de la clase String, la cual sabe concatenar cadenas, generando una nueva cadena del tamaño necesario. Sin embargo, este comportamiento solo se presenta cuando se emplean 2, 3 y hasta 4 cadenas, ya cuando se trata de 5 o mas cadenas, primero construye un arreglo de cadenas, con las cadenas a concatenar y posteriormente emplea el metodo Concat(String[]). Por ejemplo:

01: using System;
02: using System.Collections.Generic;
03: using System.Linq;
04: using System.Text;
05: 
06: namespace ClassLibrary1
07: {
08:     class Class3
09:     {
10:         void Test()
11:         {
12:             string a = "cadena1";
13:             string b = "cadena2";
14:             string c = "cadena3";
15:             string d = "cadena4";
16:             string e = "cadena5";
17:             string x = a + b + c + d + e;
18:             Console.WriteLine(x);
19:         }
20:     }
21: }
22:

Produciendo el siguiente codigo:

.method private hidebysig instance void  Test() cil managed
  {
    // Code size       84 (0x54)
    .maxstack  3
    .locals init ([0] string a,
             [1] string b,
             [2] string c,
             [3] string d,
             [4] string e,
             [5] string x,
             [6] string[] CS$0$0000)
    IL_0000:  nop
    IL_0001:  ldstr      "cadena1"
    IL_0006:  stloc.0
    IL_0007:  ldstr      "cadena2"
    IL_000c:  stloc.1
    IL_000d:  ldstr      "cadena3"
    IL_0012:  stloc.2
    IL_0013:  ldstr      "cadena4"
    IL_0018:  stloc.3
    IL_0019:  ldstr      "cadena5"
    IL_001e:  stloc.s    e
    IL_0020:  ldc.i4.5
    IL_0021:  newarr     [mscorlib]System.String
    IL_0026:  stloc.s    CS$0$0000
    IL_0028:  ldloc.s    CS$0$0000
    IL_002a:  ldc.i4.0
    IL_002b:  ldloc.0
    IL_002c:  stelem.ref
    IL_002d:  ldloc.s    CS$0$0000
    IL_002f:  ldc.i4.1
    IL_0030:  ldloc.1
    IL_0031:  stelem.ref
    IL_0032:  ldloc.s    CS$0$0000
    IL_0034:  ldc.i4.2
    IL_0035:  ldloc.2
    IL_0036:  stelem.ref
    IL_0037:  ldloc.s    CS$0$0000
    IL_0039:  ldc.i4.3
    IL_003a:  ldloc.3
    IL_003b:  stelem.ref
    IL_003c:  ldloc.s    CS$0$0000
    IL_003e:  ldc.i4.4
    IL_003f:  ldloc.s    e
    IL_0041:  stelem.ref
    IL_0042:  ldloc.s    CS$0$0000
    IL_0044:  call       string [mscorlib]System.String::Concat(string[])
    IL_0049:  stloc.s    x
    IL_004b:  ldloc.s    x
    IL_004d:  call       void [mscorlib]System.Console::WriteLine(string)
    IL_0052:  nop
    IL_0053:  ret
  } // end of method Class3::Test

En cambio, el compilador de C# al igua que el de java, es capaz de detectar cadenas constantes "inline" y generar una cadena con el resultado en tiempo de compilacion, evitando el procesamiento en tiempo de ejecucion

01: using System;
02: using System.Collections.Generic;
03: using System.Linq;
04: using System.Text;
05: 
06: namespace ClassLibrary1
07: {
08:     public class Class4
09:     {
10:         void Test()
11:         {
12:             string x = "cadena1" + "cadena2";
13:             Console.WriteLine(x);
14:         }
15:     }
16: }
17:

Generando el siguiente codigo:

.method private hidebysig instance void  Test() cil managed
{
  // Code size       15 (0xf)
  .maxstack  1
  .locals init ([0] string x)
  IL_0000:  nop
  IL_0001:  ldstr      "cadena1cadena2"
  IL_0006:  stloc.0
  IL_0007:  ldloc.0
  IL_0008:  call       void [mscorlib]System.Console::WriteLine(string)
  IL_000d:  nop
  IL_000e:  ret
} // end of method Class4::Test

El compilador puede ayudar en el desempeño del sistema, al generar algunas de estas operaciones previamente.

cadenas en java (strings)

2010-06-02T00:05:00.003-05:00

En java, como en muchos lenguajes de programacion modernos, existe una clase que define la representacion interna de una cadena durante la ejecucion del programa. En java esta clase es String. Internamente, la clase String, esta representada por un arreglo del tipo nativo char. Derivado de esto, la maquina virtual de java, maneja las cadenas como un conjunto de caracteres codificados en Unicode en formato UTF-16 (No UTF-8, no ASCII). Una consecuencia es que cada caracter que conforma la cadena, utiliza 2 bytes.

Una situacion que se da debido a la restriccion de inmutabilidad, es que los constructores que reciben un arreglo de caracteres (char[]) deben generar un arreglo interno nuevo y copiar el original (total o parcialmente, segun sea el caso), dependiendo del constructor que se emplee.

En cambio, cuando se genera una cadena utilizando otra cadena como base, es posible compartir el arreglo internamente, pues la fuente inmutable por definicion. En algunas situaciones, se puede generar un nuevo arreglo interno, para evitar el uso de memoria.

Cuando se necesita extraer un caracter de una cadena, es preferible utilizar la funcion charAt, en vez de un substring. Dado que esta funcion regresa un valor directamente (el iesimo caracter en el arreglo) sin necesidad de crear objetos y utilizando exclusivamente el stack, en cambio substring crea un nuevo objeto String, que puede compartir la memoria empleada por la cadena original. Una prueba de esto, es ejecutar el siguiente codigo:

        String s = "test";
        long start = System.currentTimeMillis();
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            s.substring(0,1);
        }
        System.out.println(System.currentTimeMillis() - start);

Contra este codigo

        String s = "test";
        long start = System.currentTimeMillis();
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            s.charAt(0);
        }
        System.out.println(System.currentTimeMillis() - start);

El primer codigo, puede llegar a ejecutarse en unos cuantos milisegundos (30 aprox en un Centrino Duo a 1.83GHz), mientras que el segundo codigo se tarda mas de 200 veces mas tiempo (casi 1 minuto en el mismo procesador), particularmente, cuando se ejecuta la maquina virtual con la opcion -server, cuando se ejecuta con la opcion -client, los tiempos de ejecucion del primer ejemplo es de 1/3 con respecto al segundo ejemplo. Este codigo optimizado esta empleado en el post "Extraccion del nombre de una propiedad del getter respectivo en java".

La funcion concat, es optima cuando se emplea exclusivamene con 2 cadenas, pues se aloja exactamente la memoria necesaria para construir la nueva cadena, cuya longitud es la suma de ambas longitudes.

numeros constantes y el operador + en java

2010-05-28T01:15:00.000-05:00

Al igual que ocurre con las cadenas, el compilador, puede realizar calculos y utilizar el resultado, reemplazando una complicada operacion y minimizando el trabajo en tiempo de ejecucion. Esto resultando en menor uso de memoria y procesador. El ejemplo acontinuacion:

01: package test;
02: 
03: public class NumberConstantTest {
04:         public static void main(String[] args) {
05:                 int a = 1 // number or hours
06:                 * 60 // mins per hour
07:                 * 1000; // milliseconds per second
08:                 float b = (3.5f + 1.2f) / 2f;
09:                 double c = a * (1d / 3d);
10:                 System.out.println(a);
11:                 System.out.println(b);
12:                 System.out.println(c);
13:         }
14: }
15:

Explicacion
05-07: Un ejemplo de como definir el numero de segundos en una hora (60000), teniendo la posibilidad de definir el numero de horas, cuando sea necesario.
08-08: Realizando una operacion con punto flotante.
09-09: Ejemplo de una combinacion de constantes, con variables.

Compiled from "NumberConstantTest.java"
   public class test.NumberConstantTest extends java.lang.Object{
   public test.NumberConstantTest();
     Code:
      0: aload_0
      1: invokespecial #8; //Method java/lang/Object."<init>":()V
      4: return

   public static void main(java.lang.String[]);
     Code:
      0: ldc #16; //int 60000
      2: istore_1
      3: ldc #17; //float 2.35f
      5: fstore_2
      6: iload_1
      7: i2d
      8: ldc2_w #18; //double 0.3333333333333333d
      11: dmul
      12: dstore_3
      13: getstatic #20; //Field java/lang/System.out:Ljava/io/PrintStream;
      16: iload_1
      17: invokevirtual #26; //Method java/io/PrintStream.println:(I)V
      20: getstatic #20; //Field java/lang/System.out:Ljava/io/PrintStream;
      23: fload_2
      24: invokevirtual #32; //Method java/io/PrintStream.println:(F)V
      27: getstatic #20; //Field java/lang/System.out:Ljava/io/PrintStream;
      30: dload_3
      31: invokevirtual #35; //Method java/io/PrintStream.println:(D)V
      34: return
   }

Explicacion

En codigo resultante, despues de ejecutar la decompilacion, utilizando el comando "javap -c" se puede apreciar que el compilador calculo los valores y coloco los resultados donde aplica, sin embargo, cuando se trata de combinaciones de constantes, con variables (incluso siendo constantes), no se optimizas y se realiza la operacion.

generics en C#, implementando GetHashCode, Equals y Comparable

2010-05-26T01:14:00.001-05:00

A continuacion, la manera de utilizar generics en C#, para implementar las funciones GetHashCode y Equals, asi como la implementacion de IComparable. Este ejemplo es equivalente al ejemplo de java

01: using System;
02: using System.Collections.Generic;
03: 
04: namespace Test
05: {
06:     public abstract class GenericClass<T>
07:     {
08:         internal T id;
09: 
10:         public T Id
11:         {
12:             get
13:             {
14:                 return id;
15:             }
16:             set
17:             {
18:                 id = value;
19:             }
20:         }
21:         public override int GetHashCode()
22:         {
23:             return id.GetHashCode();
24:         }
25:         public override bool Equals(object obj)
26:         {
27:             return this == obj
28:                 || (((object)(id as GenericClass<T>) == null)
29:                     && Equals0((GenericClass<T>)obj));
30:         }
31:         public bool Equals(GenericClass<T> obj)
32:         {
33:             return this == obj || Equals0(obj);
34:         }
35:         private bool Equals0(GenericClass<T> obj)
36:         {
37:             return id.Equals(obj.id);
38:         }
39:     }
40: 
41:     public abstract class GenericClassComparable<T> : GenericClass<T>,
42:         IComparable<GenericClassComparable<T>> where T : IComparable<T>
43:     {
44:         public int CompareTo(GenericClassComparable<T> o)
45:         {
46:             return id.CompareTo(o.id);
47:         }
48:     }
49: }
50:

Explicacion:
06-06: Declaracion de utilizacion del uso de generics
08-08: Declaracion del id.
10-20: Declaracion de los accesors para el id.
21-24: Definicion de la funcion GetHashCode, empleando las funciones propias del atributo id.
25-38: Definicion de multiples funciones Equals.
41-42: Declaracion del uso de IComparable
44-47: Definicion de la funcion CompareTo

Optimizacion:

El uso de esta clase, permite utilizar automaticamente las funciones Sort y BinarySearch, de la clase Array, asi como la clase Hashtable

hashCode y equals funcion en Java o GetHashCode y Equals en C#

2010-05-21T01:47:00.004-05:00

¿Cual es la relacion de las funciones que obtienen el codigo hash de un objeto, la funcion que determina la igualdad entre 2 objetos?

La respuesta, la dan las tablas de hash o hashtables en ingles. Para explicar el funcionamiento de estas empleare una analogia con los diccionarios (los libros). Un diccionario es un conjunto de palabras con su respectivo significado y las tablas de hash, son un conjunto de llaves asociadas con un valor. Comparando el diccionario con la tabla de hash, las llaves son las palabras y los significados, son los valores.

Para explicar el funcionamiento de la tabla de hash en terminos del diccionario, explicare primero la organizacion de este ultimo.

Las palabras estan ordenadas en orden alfabetico estricto
Las palabras que inician con la misma letra, estan agrupadas bajo esa letra, existiendo un indice de letras (este puede ser un indice o una serie de marcas en la orilla del mismo)

Bajo estas reglas, si yo necesito buscar el significado de la palabra "idioma" primero determino donde estan las palabras que inician con la letra I y posteriormente ubico la palabra dentro de esta seccion. Como nota, si la palabra no esta dentro de esta seccion (palabras que inician con I), no continuo buscando en las palabras que inician con J o H o cualquier otra letra del abecedario (claro, si se como emplear el diccionario).

Comparado con una tabla de hash, el codigo hash se emplea de la misma manera que nosotros empleamos la primer letra de la palabra a buscar en el diccionario, es decir, se emplea, para determinar un rango de busqueda y posteriormente se emplea la funcion que determina igualdad, para determinar la misma. Cabe aclarar que es importante, tanto para la busqueda en el diccionario, como la busqueda en la tabla de hash, que el algoritmo para generar el codigo hash debe ser eficiente (minimizar el tiempo de respuesta), ademas de que dado un valor, siempre debe regresar el mismo codigo.

Con respecto a la funcion equals, se utiliza para saber cual llave del conjunto (o palabra en caso del diccionario) tiene el valor (definicion en el diccionario) que estamos buscando.

Derivado de esto, se observa, que como en la vida real, tanto la funcion para obtener el codigo hash como la funcion para validad la igualdad, deben tener tiempos de respuesta minimos, particularmente la de igualdad, dado que es la que mas se emplea cuando se busca.

Nota: No es mi intencion ahondar en el funcionamiento de las tablas de hash, dado que existen multiples referencias a su funcionamiento en internet e implica conocimiento sobre teoria de colisiones, algunas formulas y conceptos matematicos, estructuras de datos y por supuesto las variantes de cada lenguaje de programacion. En la wikipedia, asi como en las materias relacionadas con estructuras de datos de muchas carreras relacionadas a sistemas se explica ampliamente su funcionamiento e implementacion.

Si lo muesto en este blog, es precisamente por la importancia que tiene definir correctamente las funciones y que ademas, sean eficazes y eficientes (optimas), pues el uso de tablas de hash esta amplamente extendido.

En java existen 2 clases que se emplean ampliamente Hashtable y HashMap. En C# la clase que se emplea normalmente es Hashtable.

Actualmente solo he implementado esta funcionalidad en java, en estas entradas:

Pronto realizare las implementaciones respectivas para C#

operador +=, cadenas, cadenas constante y el compilador en Java

2010-05-21T00:25:00.001-05:00

Como se vio en la entrada anterior, el utilizar incorrectamente un operador, puede ser optimizado por el compilador o en su defecto, una instruccion (en apariencia) se puede convertir en un conjunto de instrucciones, que impacta negarivamente en el desempeño del sistema.

El operador += es un ejemplo de operador que nunca se debe utilizar, debido a como esta implementado, veamos este codigo.

1: package test;
2: 
3: public class StringTest {
4:         public static void main(String[] args) {
5:                 String x = "cadena1";
6:                 x += "cadena2";
7:                 System.out.println(x);
8:         }
9: }
10:

Si de compilamos el codigo java resultante (el archivo .class) con el comando "javap -c", obtenemos lo siguiente:

Compiled from "StringTest.java"
   public class test.StringTest extends java.lang.Object{
   public test.StringTest();
   Code:
   0: aload_0
   1: invokespecial #8; //Method java/lang/Object."<init>":()V
   4: return

   public static void main(java.lang.String[]);
   Code:
   0: ldc #16; //String cadena1
   2: astore_1
   3: new #18; //class java/lang/StringBuilder
   6: dup
   7: aload_1
   8: invokestatic #20; //Method java/lang/String.valueOf:(Ljava/lang/Object;)Ljava/lang/String;
   11: invokespecial #26; //Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V
   14: ldc #29; //String cadena2
   16: invokevirtual #31; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   19: invokevirtual #35; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;
   22: astore_1
   23: getstatic #39; //Field java/lang/System.out:Ljava/io/PrintStream;
   26: aload_1
   27: invokevirtual #45; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   30: return
   }

El codigo equivalente, para generar el mismo resultado, pero utilizando explicitamente la clase StringBuilder y la funcion valueOf, es el siguiente:

1: package test;
2: 
3: public class StringTest2 {
4:         public static void main(String[] args) {
5:                 String x = "cadena1";
6:                 x = new StringBuilder(String.valueOf(x)).append("cadena2").toString();
7:                 System.out.println(x);
8:         }
9: }
10:

Pero que ocurre cuando se mete la operacion += dentro de un loop? Como en el siguiente codigo:

01: package test;
02: 
03: public class StringTest3 {
04:         public static void main(String[] args) {
05:                 String x = "cadena1";
06:                 for (int i = 0; i < 10; i++) {
07:                         x += "cadena2";
08:                 }
09:         }
10: }
11:

Al decompilar, se genera el siguiente codigo:

Compiled from "StringTest3.java"
   public class test.StringTest3 extends java.lang.Object{
   public test.StringTest3();
  Code:
   0: aload_0
   1: invokespecial #8; //Method java/lang/Object."<init>":()V
   4: return

public static void main(java.lang.String[]);
  Code:
   0: ldc #16; //String cadena1
   2: astore_1
   3: iconst_0
   4: istore_2
   5: goto 31
   8: new #18; //class java/lang/StringBuilder
   11: dup
   12: aload_1
   13: invokestatic #20; //Method java/lang/String.valueOf:(Ljava/lang/Object;)Ljava/lang/String;
   16: invokespecial #26; //Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V
   19: ldc #29; //String cadena2
   21: invokevirtual #31; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   24: invokevirtual #35; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;
   27: astore_1
   28: iinc 2, 1
   31: iload_2
   32: bipush 10
   34: if_icmplt 8
   37: return

}

Es decir, el codigo equivalente es el siguiente:

01: package test;
02: 
03: public class StringTest4 {
04:         public static void main(String[] args) {
05:                 String x = "cadena1";
06:                 for (int i = 0; i < 10; i++) {
07:                         x = new StringBuilder(String.valueOf(x)).append("cadena2").toString();
08:                 }
09:         }
10: }
11:

Como se puede observar, en cada iteracion, se construye un nuevo objeto StringBuilder, con el resultado de ejecutar la funcion valueOf, que recibe como parametro la variable x, posterior mente, se agrega la cadena que "cadena2" y finalmente, se convierte en una cadena nueva, la cual se asigna a la variable x.

Derivado de esto es destacable notar que este codigo es ineficiente, en la mayoria de las situaciones, particularmente cuando se emplea dentro de loops.

Sin embargo, cuando se emplea en conjunto con el operador +, puede eficiente, pero solo si se conoce exactamente la cantidad de elemenos implicados en la operacion. Como en el siguiente ejemplo:

01: package test;
02: 
03: public class StringTest5 {
04:         public static void main(String[] args) {
05:                 String x = "cadena1";
06:                 String y = "auxiliar";
07:                 x += "cadena2" + y;
08:                 System.out.println(x);
09:         }
10: }
11:

Al de compilar se obtiene lo siguiente:

Compiled from "StringTest5.java"
   public class test.StringTest5 extends java.lang.Object{
   public test.StringTest5();
   Code:
   0: aload_0
   1: invokespecial #8; //Method java/lang/Object."<init>":()V
   4: return

public static void main(java.lang.String[]);
   Code:
   0: ldc #16; //String cadena1
   2: astore_1
   3: ldc #18; //String auxiliar
   5: astore_2
   6: new #20; //class java/lang/StringBuilder
   9: dup
   10: aload_1
   11: invokestatic #22; //Method java/lang/String.valueOf:(Ljava/lang/Object;)Ljava/lang/String;
   14: invokespecial #28; //Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V
   17: ldc #31; //String cadena2
   19: invokevirtual #33; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   22: aload_2
   23: invokevirtual #33; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   26: invokevirtual #37; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;
   29: astore_1
   30: getstatic #41; //Field java/lang/System.out:Ljava/io/PrintStream;
   33: aload_1
   34: invokevirtual #47; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   37: return
}

El codigo equivalente, es el siguiente:

01: package test;
02: 
03: public class StringTest6 {
04:         public static void main(String[] args) {
05:                 String x = "cadena1";
06:                 String y = "auxiliar";
07:                 x = new StringBuilder(String.valueOf(x)).append("cadena2").append(y)
08:                                 .toString();
09:                 System.out.println(x);
10:         }
11: }
12:

Lo cual es eficiente para en terminos de uso de los objetos creados.

operador +, cadenas, cadenas constante y el compilador en Java

2010-05-18T22:37:00.004-05:00

"Mucho ayuda el que no estorba"

El uso de cadenas, en un sistema es casi inevitable, pues las personas en general leen y escriben cadenas, independientemente de que estas representen fechas, numeros, palabras, etc.

La generacion de estas cadenas, repercute negativamente en el desempeño de una aplicacion o sistema, sobre todo, cuando se generan y utilizan de manera incorrecta o excesiva.

Un ejemplo es el operador + en el lenguaje de programacion, que cuando es correctamente empleado, puede no ser una carga excesiva, pero cuando se emplea incorrectamete o se mal interpreta su utilizacion, puede provocar que se trabaje de manera excesiva, consumiendo tiempo de procesamiento y memoria indiscriminadamente.

La mayoria de los lenguajes compilados, como Java, particularmente, los que no soportan sobrecarga de operadores por programacion, convierten las instrucciones que tienen el operador + cuando estan operando con cadenas, en objetos y/o funciones. Sin embargo, el compilador, puede tener la capacidad de manipular el codigo resultante, para minimizar el uso de los recursos (memoria y procesador)

En el siguiente codigo, se hace uso del operador +.

01: package test;
02: 
03: public class StringTest {
04:         public static void main(String[] args) {
05:                 String a = "cadena1";
06:                 String b = "cadena2";
07:                 String c = a + b;
08:                 System.out.println(c);
09:         }
10: }
11:

Posteriormente ejecutamos los siguientes comandos:

   javac test\StringBuilderTest.java

   javap -c -classpath . test.StringTest

Obteniendo el siguiente codigo:

Compiled from "StringTest.java"
   public class test.StringTest extends java.lang.Object{
   public test.StringTest();
   Code:
   0: aload_0
   1: invokespecial #8; //Method java/lang/Object."<init>":()V
   4: return

   public static void main(java.lang.String[]);
   Code:
   0: ldc #16; //String cadena1
   2: astore_1
   3: ldc #18; //String cadena2
   5: astore_2
   6: new #20; //class java/lang/StringBuilder
   9: dup
   10: aload_1
   11: invokestatic #22; //Method java/lang/String.valueOf:(Ljava/lang/Object;)Ljava/lang/String;
   14: invokespecial #28; //Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V
   17: aload_2
   18: invokevirtual #31; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   21: invokevirtual #35; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;
   24: astore_3
   25: getstatic #39; //Field java/lang/System.out:Ljava/io/PrintStream;
   28: aload_3
   29: invokevirtual #45; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   32: return
   }

Como se puede observar, el compilador, tradujo la sentencia con el operador + en el uso de la funcion valueOf, la creacion de un objeto StringBuilder, el uso de la funcion append y finalmente toString, es decir algo como esto:

01: package test;
02: 
03: public class StringTest2 {
04:         public static void main(String[] args) {
05:                 String a = "cadena1";
06:                 String b = "cadena2";
07:                 String c = new StringBuilder(String.valueOf(a)).append(b).toString();
08:                 System.out.println(c);
09:         }
10: }
11:

Nosotros conocemos que se estan empleando constantes, por lo que podemos substituir la variable por el valor.

1: package test;
2: 
3: public class StringTest3 {
4:         public static void main(String[] args) {
5:                 String c = "cadena1" + "cadena2";
6:                 System.out.println(c);
7:         }
8: }
9:

Ejecutamos la compilacion (javac) y de compilacion (javap), obteniendo lo siguiente:

Compiled from "StringTest3.java"
   public class test.StringTest3 extends java.lang.Object{
   public test.StringTest3();
   Code:
   0: aload_0
   1: invokespecial #8; //Method java/lang/Object."<init>":()V
   4: return

   public static void main(java.lang.String[]);
   Code:
   0: ldc #16; //String cadena1cadena2
   2: astore_1
   3: getstatic #18; //Field java/lang/System.out:Ljava/io/PrintStream;
   6: aload_1
   7: invokevirtual #24; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   10: return
   }

Este es el codigo equivalente, el cual genera el mismo codigo compilado, que el codigo anterior.

1: package test;
2: 
3: public class StringTest4 {
4:         public static void main(String[] args) {
5:                 String c = "cadena1cadena2";
6:                 System.out.println(c);
7:         }
8: }
9:

Como se puede notar, cuando se utilizan constantes, el operador + y el compilador, pueden optimizar el codigo, siempre y cuando la constante este "inline". De ahi, la frase inicial "mucho ayuda el que no estorba", en ocasiones hay que dejar que el compilador haga su trabajo.

binario a hexadecimal en C

2010-05-14T23:54:00.003-05:00

Funcion que genera una cadena hexadecimal en base a una cadena binaria. Esta funcionalidad es util, para tranportar o almacenar informacion binaria y posteriormente recuperarla

01: #include <stdlib.h>
02: #include <string.h>
03: 
04: static const char *base="0123456789abcdef";
05: 
06: static const unsigned int ibase[]={
07:         0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
08:         0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
09:         0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
10:         0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
11:         0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
12:         2, 3, 4, 5, 6, 7, 8, 9, 0, 0,
13:         0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
14:         0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
15:         0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
16:         0, 0, 0, 0, 0, 0, 0, 10, 11, 12,
17:         13, 14, 15};
18: 
19: char *uchar2hex(const unsigned char *in, size_t len)
20: {
21:         char *out;
22:         int i;
23:         int l;
24: 
25:         l=sizeof(char)*len*2+1;
26:         out=malloc(l);
27:         out[l]='\0';
28:         for(i=0;i<len;i++)
29:         {
30:                 int p;
31:                 int t;
32: 
33:                 p=i*2;
34:                 t=in[i];
35:                 out[p]=base[(t>>4)&0x0F];
36:                 out[p+1]=base[t&0x0F];
37:         }
38:         return out;
39: }
40: 
41: unsigned char *hex2uchar(char *hexstr, size_t *len)
42: {
43:         unsigned char *out;
44:         int i;
45:         int l;
46: 
47:         l=strlen(hexstr)/2;
48:         out=malloc(sizeof(unsigned char)*l);
49:         for(i=0;i<l;i++)
50:         {
51:                 int p;
52: 
53:                 p=i*2;
54:                 out[i]=(unsigned char)((ibase[hexstr[p]&0xEF]<<4)|(ibase[hexstr[p+1]&0xEF]&0xFF));
55:         }
56:         *len=l;
57:         return out;
58: }
59:

Explicacion:

04-04: Caracteres validos en hexadecimal, ordenados convenientemente
06-17: Arreglo que sirve para invertir el proceso, convirtiendo un caracter hexadeximal en binario
19-39: Funcion que codifica la informacion binaria en una cadena hexadecimal, la longitud de la informacion binaria, esta indicada por len.
41-58: Funcion que extrae la informacion binaria de una cadena hexadecimal, la longitud resultante se almacenara en la direccion de len.

Optimizacion:

Se construye el arreglo resultante con la logitud exacta necesaria
Se emplean arreglos, para minimizar el numero de operaciones

Notas:

Los valores regresados por estas funciones, se deben liberar con la funcion free, pues se aloja memoria con malloc
En esta version, solo es posible usar minusculas

Extraccion del nombre de una propiedad del getter respectivo en java

2010-05-12T13:21:00.005-05:00

Extraccion del nombre de una propiedad del getter respectivo

Esta funcionalidad es requerida, para obtener dinamicamente el nombre de la propiedad asociada al methodo getter, sin embargo, puede complicarse, debido a que el estandard puede aceptar el prefijo is o el prefijo get

01: package test;
02: 
03: public class Test {
04:         public String getProperty(String methodName) {
05:                 assert methodName.startsWith("get") || methodName.startsWith("is");
06:                 int index = methodName.charAt(0) == 'i' ? 2 : 3;// cache
07:                 char c = Character.toLowerCase(methodName.charAt(index));// cache
08:                 int l = methodName.length();
09:                 if ((index == 3 && l > 4) || (index == 2 && l > 3)) {
10:                         return new StringBuilder(l-index).append(c).append(
11:                                         methodName.substring(index + 1)).toString();
12:                 } else {
13:                         return new String(new char[] { c });
14:                 }
15:         }
16: }
17:

Explicacion:
06-06: Determinar donde inicia el nombre de la propiedad.
07-07: El primer caracter del nombre de la propiedad, lo convertimos a minuscula
09-14: Determinamos si el nombre de la propiedad, esta formado por 1 o mas letras.

Optimizacion:

Se realiza cache de variables, como el indice, para evitar calcularlo en cada ocasion
Cuando el nombre de la propiedad esta formado por un solo caracter se construye una cadena formada por ese caracter exclusivamente, en caso contrario, se forma la cadena correspondiente.
Cuando el nombre de la propiedad esta formado por mas de un caracter, se crea un StringBuilder de longitud exacta.