ilikeblues

En C++ podemos utilizar la librería boost para tener una funcionalidad similar al “garbage collector” de Java o .NET.

En concreto, podemos usar los smart pointers provistos por esta librería para “automatizar” la liberación de memoria en nuestra aplicación, ayudando a evitar los memory leaks.

Veamos un ejemplo de código:

#include <boost/shared_ptr.hpp>
#include <iostream>
#include <vector>

// Just a simple class
class Foo{
public:
        Foo(){ }
        ~Foo(){
                std::cout << "Destructing. " << (int)this << std::endl;
        }
};

// Make shorthand to cut some typing
typedef boost::shared_ptr<Foo> FooPtr;

// this functions allocates memory for an object, return a shared_ptr to it and forgets about it.
FooPtr CreateFoo(){
        FooPtr fp(new Foo);
        return fp;
}

int main(int argc, char** argv){

        std::vector<FooPtr> foos;

        foos.push_back(CreateFoo());
        foos.push_back(CreateFoo());

        FooPtr temp = foos[1]; // extract the second object
        std::cout << "clearing vector.." << std::endl;
        foos.clear(); // the first object will be deleted here, but not the second, since it has a reference still in scope.
        std::cout << "ending program.." << std::endl;
        // main returns and the final object goes out of scope and is automatically destroyed.
        return 0;
}

El código muestra cómo usar boost::shared_ptr, junto con los contenedores de la STL. Nótese que no se ha utilizado ningún “delete”.

Este objeto, shared_ptr, puede ser utilizado como “envoltorio” de los punteros a objetos, de manera que se haga un seguimiento de los referencias a estos. Una vez que todas las referencias al objeto han sido eliminadas, o han salido de su ámbito, se libera automáticamente la memoria reservada para el objeto.

Por supuesto, esta “recolección de basura” sólo es válida para los objetos creados en nuestro código usando el puntero inteligente. Cualquier objeto creado en librerías de terceros, debe ser convenientemente manejado para evitar las fugas de memoria.

Vía | http://www.libzter.com

El siguiente código muestra los pasos más sencillos para un ordenar un mapa (java.util.Map) en Java:

public class SortMapExample{

   public static void main(String[] args) {

	System.out.println("Unsort Map......");
	Map<String,String> unsortMap = new HashMap<String,String>();
	unsortMap.put("1", "1");
	unsortMap.put("2", "A");
	unsortMap.put("3", "2");
	unsortMap.put("4", "B");
	unsortMap.put("5", "C");
	unsortMap.put("6", "c");
	unsortMap.put("7", "b");
	unsortMap.put("8", "a");

	Iterator iterator=unsortMap.entrySet().iterator();

        for (Map.Entry entry : unsortMap.entrySet()) {
        	System.out.println("Key : " + entry.getKey()
       			+ " Value : " + entry.getValue());
        }

        System.out.println("Sorted Map......");
        Map<String,String> sortedMap =  sortByComparator(unsortMap);

        for (Map.Entry entry : sortedMap.entrySet()) {
        	System.out.println("Key : " + entry.getKey()
       			+ " Value : " + entry.getValue());
        }
   }

   private static Map sortByComparator(Map unsortMap) {

        List list = new LinkedList(unsortMap.entrySet());

        //sort list based on comparator
        Collections.sort(list, new Comparator() {
             public int compare(Object o1, Object o2) {
	           return ((Comparable) ((Map.Entry) (o1)).getValue())
	           .compareTo(((Map.Entry) (o2)).getValue());
             }
	});

        //put sorted list into map again
	Map sortedMap = new LinkedHashMap();
	for (Iterator it = list.iterator(); it.hasNext();) {
	     Map.Entry entry = (Map.Entry)it.next();
	     sortedMap.put(entry.getKey(), entry.getValue());
	}
	return sortedMap;
   }
}

El algoritmo implica las siguientes transformaciones:

Map –> List –> Order List –> Map

A priori, no parece que sea un algoritmo muy optimizado. ¿Alguna sugerencia para mejorar el rendimiento?

Vía | http://www.mkyong.com

A menudo resulta útil guardar ficheros (por ejemplo, de configuración) en el bundle y leerlos durante la ejecución de ciertas tareas de nuestro plugin. Para ello podemos utilizar el siguiente código (reemplazando el nombre del bundle, claro):

Bundle bundle = Platform.getBundle("com.ilikeblues.example.readfile");
URL fileURL = bundle.getEntry("files/test.txt");
File file = null;
try {
	file = new File(FileLocator.resolve(fileURL).toURI());
} catch (URISyntaxException e1) {
	e1.printStackTrace();
} catch (IOException e1) {
	e1.printStackTrace();
}

Otra opción es utilizar la URL directamente:

(more…)

Como continuación de una entrada en la que comentaba como añadir un constructor y métodos a un enum Java, veamos cómo utilizar esta tipo de objetos en un switch:

private void processGender(Gender gender) {
   switch (gender) {
      case Male:
         // Código para el caso masculino
         break;
      case Female:
         // Código para el caso femenino
         break;
      default:
         // Esto es código inalcanzable, ya que
         // el switch lanzará una NullPointerException si gender == null
   }
}

Si utilizamos enums, más tarde o más temprano tendremos que usar una estructura de este tipo en la toma de decisiones.

Vía | http://javafact.com

El código que se muestra a continuación, lee el contenido de un fichero de propiedades y devuelve el valor de una de ellas:

Properties properties = new Properties();
FileInputStream in;
try {
   in = new FileInputStream("app.properties");
   properties.load(in);
   in.close();
} catch (Exception e) {
   System.out.println(e.getMessage());
}
return properties.getProperty("appcode");

Un ejemplo del fichero de propiedades:

appcode=50
email=admin@yahoo.com

Vía | http://seguide.blogspot.com

En un post en DZONE, Daniel Schneller describe una situación que pone de manifiesto un comportamiento un tanto extraño, relacionado con el orden de inicialización de los objetos Java.

Daniel muestra el siguiente código Java:

package com.ds.test;

public class Upper {
   String upperString;

   public Upper() {
      Initializer.initialize(this);
   }
}

package com.ds.test;

public class Lower extends Upper {

   String lowerString = null;

   public Lower() {
      super();
      System.out.println("Upper:  " + upperString);
      System.out.println("Lower:  " + lowerString);
   }

   public static void main(final String[] args) {
      new Lower();
   }
}

package com.ds.test;
public class Initializer {
   static void initialize(final Upper anUpper) {
      if (anUpper instanceof Lower) {
         Lower lower = (Lower) anUpper;
         lower.lowerString = "lowerInited";
      }
      anUpper.upperString = "upperInited";
   }
}

Este código, en contra de lo que podría parecer, produce esta salida:
(more…)

En Java, los enums representan objetos con un conjunto discreto de posibles valores.

Estos valores pueden ser de cualquier tipo, enteros, cadenas, etc., pero en Java tenemos mecanismos que nos permiten representar estos valores de varias formas, de manera que se ajusten a la necesidad de cada caso.

La manera más sencilla de especificar un enum en Java:

public enum Gender{
   Male, Female;
}

Pero es que, además de sus posibles valores, un enum puede tener constructores y métodos:

public enum Gender{
   Male("Masculino"), Female("Femenino");

   private String spanish;

   // the constructor
   Gender(String spanish){
      this.spanish = spanish;
   }

   // a method
   public String toSpanish(){
      return this.spanish;
   }
}

De manera que podríamos usar este enum de la siguiente manera:

Person p = new Person();
p.setGender(Gender.Male);

String text = "The person's gender in Spanish is: " + p.getGender().toSpanish();

Con esto un enum es similar a una colección (Collection) en Java, con las siguientes diferencias:

1. La máquina virtual inicializa todos los valores.
2. No se permite añadir o eliminar elementos en runtime.
3. Se accede a los objetos estáticamente.

En el ejemplo, Gender representa a la colección, y se puede acceder a sus elementos sin necesidad de crear una instancia.

Vía | http://javafact.com

Como comentan en la vía, la documentación de jQuery en la web oficial no siempre es tan completa como debería. Así que ahí van algunos de trozos de código que puede ayudar al maneja de los checkboxes:

Seleccionar/deseleccionar un checkbox:

// Seleccionar un checkbox
$('input[name=acheckbox]').attr('checked', true);

// Deseleccionar un checkbox
$('input[name=acheckbox]').attr('checked', false);

Seleccionar/deseleccionar todos los checkbox:

// Seleccionar todos los checkboxes
$("input:checkbox").attr('checked', true);

// Deseleccionar todos los checkboxes
$("input:checkbox").attr('checked', false);

Comprobar si un checkbox está seleccionado:
(more…)

La siguiente hoja CSS permite resetear los estilos por defecto del navegador que estés usando. Con esto podemos evitar las inconsistencias en la presentación del sitio web en distintos navegadores.

html, body, div, span, applet, object, iframe,
h1, h2, h3, h4, h5, h6, p, blockquote, pre,
a, abbr, acronym, address, big, cite, code,
del, dfn, em, font, img, ins, kbd, q, s, samp,
small, strike, strong, sub, sup, tt, var,
b, u, i, center,
dl, dt, dd, ol, ul, li,
fieldset, form, label, legend,
table, caption, tbody, tfoot, thead, tr, th, td {
margin: 0;
padding: 0;
border: 0;
outline: 0;
font-size: 100%;
vertical-align: baseline;
background: transparent;
}
body {
line-height: 1;
}
ol, ul {
list-style: none;
}
blockquote, q {
quotes: none;
}
blockquote:before, blockquote:after,
q:before, q:after {
content: '';
content: none;
}

/* remember to define focus styles! */
:focus {
outline: 0;
}

/* remember to highlight inserts somehow! */
ins {
text-decoration: none;
}
del {
text-decoration: line-through;
}

/* tables still need 'cellspacing="0"' in the markup */
table {
border-collapse: collapse;
border-spacing: 0;
}

Vía | http://www.webspeaks.in

Es muy común confundir las excepciones ClassNotFoundException y NoClassDefFoundError en Java.

Yo personalmente, las he confundido muy a menudo. Así que agradezco sinceramente a Zen in the Art of IT la entrada al respecto.

Esto es, básicamente, lo que dice:

(more…)