Código a continuación:

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.TimeZone;

/**
 * Simple Java program to convert local time into GMT or any other TimeZone in Java
 * SimpleDateFormat in Java can be used to convert Date from one timezone to other
 * @author Javin
 */
public class TimeZoneConverter {

    public static void main(String args[]) {

     //Date will return local time in Java
     Date localTime = new Date(); 

     //creating DateFormat for converting time from local timezone to GMT
     DateFormat converter = new SimpleDateFormat("dd/MM/yyyy:HH:mm:ss");

     //getting GMT timezone, you can get any timezone e.g. UTC
     converter.setTimeZone(TimeZone.getTimeZone("GMT"));

     System.out.println("local time : " + localTime);;
     System.out.println("time in GMT : " + converter.format(localTime));

    }   

}

Si ejecutamos, la salida es:

local time : Wed Apr 11 05:48:16 VET 2012
time in GMT : 11/04/2012:10:18:16

La clase TimeZone por su parte permite especificar el huso horario en varios formatos diferentes, que podemos ver en este enlace.

Vía | Java Revisited

Las condiciones a cumplir son las siguientes:

1. Los parámetros variables tienen todos el mismo tipo (o son instancias del mismo objeto).
2. Hay cero o más parámetros variables.
3. Sólo hay un conjunto de parámetros variables.
4. El conjunto de parámetros variables viene al final de la definición del método.

Como ejemplo, la definición del método java.io.PrintStream.printf():

public PrintStream printf(String format,
                          Object... args)

Uso

Veamos un ejemplo sencillo: un método que devuelve la suma de un número variable de enteros:

public static int sum(int... args)
{
   int result=0;
   for(int a:args)
   {
      result+=a;
   }
   return result;
}

Ejemplo de uso del método:

System.out.printf("0 %d\n", sum()); // prints "0 0"
System.out.printf("1 %d\n", sum(1)); // prints "1 1"
System.out.printf("2 %d\n", sum(1, 2)); // prints "2 3"
System.out.printf("3 %d\n", sum(1, 2, 3)); // prints "3 6"
System.out.printf("4 %d\n", sum(1, 2, 3, 4)); // prints "4 10"

Supongamos que queremos forzar a que haya, al menos, dos enteros (no tiene sentido la suma de 0 ó 1 enteros):

public static int sum(int arg0, int arg1, int... args)
{
   int result=arg0+arg1;
   for(int a:args)
   {
      result+=a;
   }
   return result;
}

Ahora no podemos llamar a la rutina sin argumentos. Un ejemplo de llamada:

System.out.printf("6 %d\n", sum(1, 2, new int[]{2, 3, 4, 5})); // prints "5 17"

Object

Uso básico con objetos:

public static int objector(Object... args)
{
   return args.length;
}

Probamos con unas cadenas (String):

String[] strings = new String[]{"one", "two", "three"};
Object[] objects = new Object[]{Integer.valueOf(1), Boolean.TRUE, "three"};
System.out.printf("strings %d\n", objector(strings)); // prints "strings 3"
System.out.printf("objects %d\n", objector(objects)); // prints "objects 3"

De la misma manera, si requerimos al menos un objeto:

public static int objector(Object arg0, Object... args)
{
   return args.length;
}

Si ejecutamos los printf del ejemplo de código anterior, utilizando la nueva versión de la rutina objector, veremos que devuelve una longitud cero. Esto se debe a que el array es un objeto en sí, y está siendo pasado a la rutina como primer argumento.

En un caso como este, podemos manejar el caso en que el número de argumentos es igual a cero de esta manera:

public static void objector(Object... args)
{
   if(args.length==0)
   {
      // special case
   }
   else
   {
      // handle arguments
   }
}

En este caso, un mal uso quedaría de manifiesto en tiempo de compilación. Esto te da la opción de cambiar la interfaz.

Conclusión

Ya que los objetos pasados como argumentos van a ser tratados como un array de tipo Object[] (utilizando reflexión), parece sólo tiene sentido utilizar la versión Object… varargs si el método forma parte de un API y va a ser utilizado por otros.

Autoboxing

Otra cuestión a tener en cuenta es que podemos utilizar el Autoboxing, también introducido en la versión 5 de Java. Esto permite la conversión automática entre tipos y sus objetos correspondientes. Esto funciona si, por ejemplo, pasamos varios objetos Integer a una rutina con argumentos int… args. Sin embargo, no funciona si pasamos un Integer[], pues Java no puede convertirlo automáticamente a int[].

public static int inter(int... args)
{
   return args.length;
}

int[] ints = new int[]{ 1, 2, 3, 4, 5 };
Integer[] integers = new Integer[]{ 1, 2, 3, 4, 5 };
System.out.printf("ints %d\n", inter(ints)); // prints "ints 5"
System.out.printf("Integer %d\n", inter(Integer.valueOf(1), Integer.valueOf(2))); // prints Integer 2"
System.out.printf("Integer[] %d\n", inter(integers)); // compiler error

Si que funcionaría si lo hiciéramos al revés. Es decir, si el argumento esperado es de tipo Integer… args, podemos pasar un int[].

Vía | javaranch

Podemos recorrer el árbol de objetos, sin utilizar llamadas recursivas, utilizando el código que se muestra a continuación:

/**
* Returns a {@link Stack} having a Tree ordered in Depth First whose root is passed as the Parameter
*
* @param The implementation of {@link Node}
* @param treeRoot The root of the tree
* @return The {@link Stack} of T
*/
public static Stack depthFirstOrder(final T treeRoot)
{
   // Main stack, where the important stuff go
   Stack mainStack = new Stack();

   // Temp child stack, where we store children of before it gets put to the mainStack
   Stack tempChildStack = new Stack();

   mainStack.push(treeRoot);   // Put the tree root
   tempChildStack.addAll(treeRoot.getChildren()); // Put the children to the temp

   // Loop until no more children in the temp stack
   while (!tempChildStack.isEmpty())
   {
      T node = (T) tempChildStack.pop();   // Keep popping from the temp stack..
      mainStack.push(node);   // .. and Push to the main stack..
      tempChildStack.addAll(node.getChildren()); // .. while adding children to temp
   }

   // Now temp stack is empty and mainStack has things in DFS order!
   return mainStack;
}

Vía | gunith

view.setPadding(int, int, int, int);

Sin embargo, sabemos que, sobre todo al diseñar interfaces, es muy conveniente utilizar dip (density independent pixel) a la hora de especificar tamaños, para evitar variaciones entre dispositivos con resoluciones diferentes.

De manera que, para ejecutar código como el de arriba (cambios en runtime), podemos hacer lo siguiente:

float sizeInDip = 10f;
int padding = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, sizeInDip, getResources().getDisplayMetrics());

Vía | James Elsey Blog

public static  T[] reverse(T[] array) {
    Collections.reverse(Arrays.asList(array));
    return array;
}

Como indica el autor del post original, la ejecución no implica copia de arrays, de manera que resulta rápido y sin efectos laterales (se devuelve el mismo array recibido, con el orden modificado.

Nota acerca de Arrays.asList()

La documentación de esta API muestra que la lista que devuelve es de tamaño fijo. Esto implica que cualquier llamada a add() o remove() devolverá una excepción de tipo UnsupportedOperationException. Si se pasa a través de la interfaz java.util.List el resultado es indefinido, ya que cualquier programador esperaría que un objeto de ese tipo fuera modificable, en el sentido de poder añadir/eliminar elementos.

Vía | http://schneide.wordpress.com

La solución me parece muy buena, así que la dejo aquí para que no se me olvide…

Partimos del hecho de que implementar una tabla por cada tipo de enum que queremos almacenar conlleva habitualmente un mantenimiento complicado y tedioso. Lo normal es tener varias tablas, con unas cuantas filas cada una, sin “foreign keys”.

La solución que propone Ben incluye dos tablas, una llamada Lookup y la otra Value, independientemente de los enums que se necesite utilizar. Así el mantenimiento es más sencillo.

Los campos de la tabla Lookup serían:

+------+
|id
|lookup
|name
+------+

Esto es la representación del nombre de un tipo enum. El campo “id” es de tipo “autoincrement” y la clave principal (“primary key”) es “lookup”. Una entrada en esta tabla, entonces, equivale a un tipo de enum, no a sus valores.

Los valores se añaden en la tabla Value, cuyos campos serían:

+---------+
|id
|lookupid
|name
|sortorder
|deleted
+---------+

De esta manera se pueden obtener los valores de un tipo enum con un “join” bastante sencillo:

SELECT * FROM Value v INNER JOIN Lookup l ON l.id = v.lookupid WHERE l.name = '?';

Si además añadimos un índice sobre los campos id y lookupid, el acceso es muy rápido. Tienes todos tus enums en una única tabla, resulta sencillo añadirles información adicional, y evitas el problema de mantenimiento de N tablas, una por cada enum.

Vía | http://searchco.de

Ahí van los trucos (añadiré encantado todos los que queráis aportar):

1. Utilizar los operadores a nivel de bit para realizar multiplicaciones y divisiones por 2 (esto siempre que se quiera realizar una multiplicación/división entera, por supuesto). Ej: 20 >> 1 = 10; 10 << 1 = 20;
2. Utilizar StringBuffer en lugar de String cuando sea necesario realizar operaciones sobre las cadenas. Podemos utilizar String en caso de cadenas “estáticas”. A partir de java 5 se puede considerar también el uso de StringBuilder.
3. Hacer que las variables, clases y/o métodos sean “final”, siempre que esto sea posible. Esto favorece la optimización por parte del compilador (compile time binding), y el bytecode resultante se ejecuta más rápido.
4. Los métodos estáticos también se resuelven en tiempo de compilación, mientras el resto se resuelven en tiempo de ejecución. Esto favorece a la performance de la aplicación. Pero ojo, que esto podría implicar una penalización en cuanto a uso de memoria.
5. No utilizar llamadas a métodos en los bucles for. Por ejemplo, para un bucle

   for(int i=0; i
   Utilizar:
   int size = vector.size();
   for(int i=0; i
   

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

En cualquier caso, allá va el código que permite hacerlo:

public class LogTest extends Activity {
  @Override
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);
    try {
      Process process = Runtime.getRuntime().exec("logcat -d");
      BufferedReader bufferedReader = new BufferedReader(
      new InputStreamReader(process.getInputStream()));

      StringBuilder log=new StringBuilder();
      String line;
      while ((line = bufferedReader.readLine()) != null) {
        log.append(line);
      }
      TextView tv = (TextView)findViewById(R.id.textView1);
      tv.setText(log.toString());
    } catch (IOException e) {
    }
  }
}

Y es cierto que, a priori, cabría pensar que se requieren permisos de superusuario para que funcione, pues el código ejecuta un proceso directamente en el terminal (proceso “logcat”). Sin embargo, se puede conseguir mediante el mecanismo de concesión de permisos de las aplicaciones Android:

Podéis consultar la documentación para ver qué otras opciones se pueden añadir al comando logcat.

Vía | http://www.helloandroid.com/tutorials/

A continuación se muestra el código para evitar que el gestor de energía pasa el terminal a reposo. Primero creamos una instancia de WakeLock:

PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
PowerManager.WakeLock wakeLock = pm.newWakeLock(
        pm.SCREEN_DIM_WAKE_LOCK, "My wakelook");
// Esto hará que no se apague la pantalla y el teléfono no pase a reposo.

A continuación tenemos dos opciones. La primera evitar el bloqueo durante un periodo de tiempo determinado:

// Esto hará que se libere el wakeLock después de 1000 ms
wakeLock.acquire(1000);

La segunda “adquirir” el wakeLock y liberarlo cuando lo consideremos oportuno:

// La alternativa es adquirir y liberar el wakeLock cuando sea conveniente:
wakeLock.acquire();
...
wakeLock.release();

Vía | http://www.vogella.de

La clase es BreakIterator forma parte del paquete java.text. Esta clase está preparada incluso para funcionar con diferentes “locales”, y soporta cuatro tipos diferentes de “límites”, a la hora de determinar cómo “trocear” un texto:

• Líneas: getLineInstance()
• Frases: getSentenceInstance()
• Palabras: getWordInstance()
• Caracteres: getCharacterInstance()

Además tiene métodos como next() y previous() que puede dar la sensación de estar utilizando un iterador. Sin embargo, estos métodos realmente devuelven un entero que permite localizar dentro de la cadena el comienzo del siguiente item.

Ahí van algunos ejemplos de código:

Crear y utilizar esta clase:

public static void main(String args[]) {
   if (args.length == 1) {
      String stringToExamine = args[0];
      //print each word in order
      BreakIterator boundary = BreakIterator.getWordInstance();
      boundary.setText(stringToExamine);
      printEachForward(boundary, stringToExamine);
      //print each sentence in reverse order
      boundary = BreakIterator.getSentenceInstance(Locale.US);
      boundary.setText(stringToExamine);
      printEachBackward(boundary, stringToExamine);
      printFirst(boundary, stringToExamine);
      printLast(boundary, stringToExamine);
   }
}

Ordenar y mostrar los elementos:

public static void printEachForward(BreakIterator boundary, String source) {
      int start = boundary.first();
      for (int end = boundary.next();
         end != BreakIterator.DONE;
         start = end, end = boundary.next()) {
         System.out.println(source.substring(start,end));
      }
}

Mostrar los elementos en orden inverso:

public static void printEachBackward(BreakIterator boundary, String source) {
   int end = boundary.last();
   for (int start = boundary.previous();
      start != BreakIterator.DONE;
      end = start, start = boundary.previous()) {
      System.out.println(source.substring(start,end));
   }
}

Primer elemento:

public static void printFirst(BreakIterator boundary, String source) {
   int start = boundary.first();
   int end = boundary.next();
   System.out.println(source.substring(start,end));
}

Último elemento:

public static void printLast(BreakIterator boundary, String source) {
   int end = boundary.last();
   int start = boundary.previous();
   System.out.println(source.substring(start,end));
}

Elemento en una posición determinada:

public static void printAt(BreakIterator boundary, int pos, String source) {
   int end = boundary.following(pos);
   int start = boundary.previous();
   System.out.println(source.substring(start,end));
}

Encontrar la siguiente palabra:

public static int nextWordStartAfter(int pos, String text) {
   BreakIterator wb = BreakIterator.getWordInstance();
   wb.setText(text);
   int last = wb.following(pos);
   int current = wb.next();
   while (current != BreakIterator.DONE) {
      for (int p = last; p < current; p++) {
      if (Character.isLetter(text.codePointAt(p)))
         return last;
      }
      last = current;
      current = wb.next();
   }
   return BreakIterator.DONE;
}

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

Vía | http://download.oracle.com/javase/6/docs/api/java/text/BreakIterator.html