Empecemos con los lenguajes más utilizados. Estos podrían ser los lenguajes cuyas sintaxis y características gustan más, o, simplemente, aquellos con los que están más familiarizados los participantes. Como vemos, C++ es, con mucha diferencia, el lenguaje más popular, seguido a larga distancia de Java y Python.

Pasamos a continuación a los lenguajes con mayor porcentaje de programadores capaces. Vemos que el porcentaje de programadores que consiguieron la puntuación suficiente para pasar de fase es altísimo en el caso de C++ y Haskell (90,8% y 90,68%), mientras que el porcentaje de programadores aprobados en el caso de PHP (lenguaje con el que yo me gano las lentejas actualmente) es alarmantemente bajo en comparación (76,5%).

Por último, veamos el porcentaje de programadores que consiguieron la puntuación perfecta, agrupados por lenguaje de programación. Aquí Haskell se distancia bastante de C++, y mucho más del resto de lenguajes, quizás por la llamada paradoja Python. PHP, por su parte, se mantiene con el dudoso honor de ser el lenguaje con peor porcentaje de programadores con puntuaciones perfectas.

Este tipo de programas que se imprimen a sí mismos como salida (aunque en este caso, con una peculiaridad extra) se conocen con el nombre de quines, en honor al filósofo estadounidense Willard Van Orman Quine.

import Data.List

langs = [Haskell, Perl, Python, Ruby, C, Java]

data Languages = Haskell | Ruby | Perl | C | Python | Java

sequenceFromString Haskell s = "map toEnum[" ++ (intercalate "," $
    map (\c -> show (fromEnum c)) s) ++ "]"
sequenceFromString Perl s    = (intercalate "," $
    map (\c -> "chr(" ++ show (fromEnum c) ++ ")") s)
sequenceFromString Python s  = (intercalate "+" $
    map (\c -> "chr(" ++ show (fromEnum c) ++ ")") s)
sequenceFromString Ruby s    = (intercalate "+" $
    map (\c -> show (fromEnum c) ++ ".chr") s)
sequenceFromString C s       = concatMap
    (\c -> "putchar(" ++ show (fromEnum c) ++ ");") s
sequenceFromString Java s    = concatMap
    (\c -> "o.write(" ++ show (fromEnum c) ++ ");") s

paramList' Haskell = intercalate " " . map (\n -> "a" ++ show n)
paramList' C       = intercalate "," . map (\n -> "char *a" ++ show n)
paramList' Python  = intercalate "," . map (\n -> "a" ++ show n)
paramList' Ruby    = intercalate "," . map (\n -> "a" ++ show n)
paramList' Java    = intercalate "," . map (\n -> "String a" ++ show n)

paramList Perl    _ = ""
paramList lang n = paramList' lang [0..n-1]

driver l args = defn l ++ intercalate (divider l) args ++ endDefn l

divider C       = "\",\""
divider Perl    = "','"
divider Ruby    = "\",\""
divider Python  = "\",\""
divider Haskell = "\" \""
divider Java    = "\",\""

defn C       = "main(){q(\""
defn Perl    = "&q('"
defn Python  = "q(\""
defn Ruby    = "q(\""
defn Haskell = "main=q \""
defn Java    = "public static void main(String[]args){q(\""

endDefn C       = "\");}"
endDefn Perl    = "')"
endDefn Python  = "\")"
endDefn Ruby    = "\")"
endDefn Haskell = "\""
endDefn Java    = "\");}}"

arg Haskell n = "a" ++ show n
arg Perl n    = "$_[" ++ show n ++ "]"
arg C n       = "printf(a" ++ show n ++ ");"
arg Python n  = "a" ++ show n
arg Ruby n    = "a" ++ show n
arg Java n    = "o.print(a" ++ show n ++ ");"

argDivide Haskell l = "++" ++ sequenceFromString Haskell (divider l) ++ "++"
argDivide Perl l    = ","    ++ sequenceFromString Perl (divider l) ++ ","
argDivide C l       = sequenceFromString C (divider l)
argDivide Python l  = "+" ++ sequenceFromString Python (divider l) ++ "+"
argDivide Ruby l    = "+" ++ sequenceFromString Ruby (divider l) ++ "+"
argDivide Java l    = sequenceFromString Java (divider l)

argList lang1 lang2 n = intercalate (argDivide lang1 lang2) $
    map (arg lang1) ([1..n-1] ++ [0])

fromTo Haskell l n = "q " ++ paramList Haskell n ++ "=putStrLn$a0++" ++
    sequenceFromString Haskell ("\n" ++ defn l) ++ "++" ++
    argList Haskell l n ++ "++" ++ sequenceFromString Haskell (endDefn l)
fromTo Perl    l n = "sub q {" ++ "print $_[0]," ++
    sequenceFromString Perl ("\n" ++ defn l) ++ "," ++ argList Perl l n ++ "," ++
    sequenceFromString Perl (endDefn l ++ "\n") ++ "}"
fromTo Python  l n = "def q(" ++ paramList Python n ++
    "): print a0+" ++ sequenceFromString Python ("\n" ++ defn l) ++
    "+" ++ argList Python l n ++ "+" ++ sequenceFromString Python (endDefn l)
fromTo Ruby    l n = "def q(" ++ paramList Ruby n ++
    ") print a0+" ++ sequenceFromString Ruby ("\n" ++ defn l) ++
    "+" ++ argList Ruby l n ++ "+" ++ sequenceFromString Ruby (endDefn l ++ "\n") ++ " end"
fromTo C       l n = "q(" ++ paramList C n ++ "){" ++ "printf(a0);" ++
    sequenceFromString C ("\n" ++ defn l) ++ argList C l n ++
    sequenceFromString C (endDefn l ++ "\n") ++ "}"
fromTo Java    l n = "public class quine{public static void q(" ++
    paramList Java n ++ "){java.io.PrintStream o=System.out;o.print(a0);" ++
    sequenceFromString Java ("\n" ++ defn l) ++ argList Java l n ++
    sequenceFromString Java (endDefn l ++ "\n") ++ "}"

main = do
    let n = length langs
    let langs' = cycle langs
    putStrLn $ fromTo (head langs') (head (tail langs')) n
    putStrLn $ driver (head langs') $ zipWith (\lang1 lang2 -> fromTo lang1 lang2 n)
        (take n (tail langs')) (tail (tail langs'))

Vía Hacker News

Tengo la impresión de que Java fue diseñado para hacer que fuera difícil escribir mal código, mientras que Python está diseñado para hacer que sea sencillo escribir buen código.

– Magnus Lycka

Un ejemplo de este tipo de herramientas es la aplicación GPL ProGuard que permite, además de ofuscar nuestras clases Java, optimizarlas, comprimirlas y añadirles información de preverificación, de forma que la carga de las clases en Java SE 6 y Java ME 6 sea más rápida y más eficiente.

La herramienta funciona buscando primeramente clases, campos, métodos y atributos no utilizados, los cuáles elimina; pasa entonces a optimizar el bytecode y eliminar instrucciones innecesarias; y, por último, elimina la información de depuración y renombra las clases, campos y métodos restantes utilizando nombres cortos y poco legibles.

Supongamos, por ejemplo, que quisiéramos mostrar en pantalla un número en coma flotante, con la peculiaridad de que necesitáramos que sólo se mostraran 2 decimales. Podríamos, por ejemplo, convertir el número en una cadena y manipularla para quedarnos con 2 caracteres después de la coma, pero existen mejores formas de lidiar con este problema.

String.format()

La primera solución es hacer uso del método estático format de la clase String para crear una cadena que se adapte a nuestras necesidades y que más tarde imprimiremos con el consabido System.out.println() o System.out.print().

Este método toma como parámetros una cadena con uno o más especificadores de conversión y una lista de argumentos. En el siguiente fragmento de código, por ejemplo, se sustituirían los especificadores %s por el valor de las variables usuario y mensajes respectivamente.

public class Ejemplo {
	public static void main(String[] args) {
		String usuario = "zootropo";
		int mensajes = 36;

		String s = String.format("%s escribió %s mensajes", usuario, mensajes);
		System.out.println(s);
	}
}

Los distintos especificadores de conversión que podemos utilizar son los siguientes:

A estos caracteres que indican cómo se debe formatear los distintos valores de la lista de parámetros se les puede añadir caracteres opcionales siguiendo el siguiente formato:

%[índice$][opciones][ancho][.precisión]conversión

donde índice se puede utilizar para indicar especificamente el valor de la lista de valores por el que sustituirlo

public class Ejemplo {
	public static void main(String[] args) {
    int numero = 42;

    String s = String.format("%1$d en hexadecimal es %1$x", numero);
		System.out.println(s);
	}
}

ancho es un entero no negativo que indica el número de caracteres mínimo que debe ocupar ese valor al mostrarse en pantalla. Si el valor tiene menos caracteres que los indicados se rellenará el vacío con espacios.

precisión es un entero no negativo que indica el número de decimales a utilizar para un número en coma flotante (la misma función se encarga de redondear) o el número de caracteres a mostrar para una cadena.

public class Ejemplo {
	public static void main(String[] args) {
		float numero = 3.14159f;

    String s = String.format("PI es %.3f", numero);
		System.out.println(s);
	}
}

System.out.printf()

Pero como decíamos al principio del artículo existe otra forma más para mostrar cadenas formateadas en la consola, y es el método System.out.printf(). Este método funciona de forma similar a una combinación de String.format() y System.out.print() ya que podemos pasar directamente la cadena con los especificadores de conversión y la lista de argumentos para imprimirse, de forma similar a la función sprintf de C.

El fragmento de código anterior, por ejemplo, tendría este aspecto al reescribirlo con un System.out.printf():

public class Ejemplo {
	public static void main(String[] args) {
		float numero = 3.14159f;

		System.out.printf("PI es %.3f", numero);
	}
}

En todo caso C# y Java también tienen muchas e importantes diferencias. C# cuenta, por ejemplo, con características tan interesantes como closures, funciones lambda, generadores, preprocesador, punteros, etc. Este artículo tiene como objetivo servir a modo de pequeña introducción a C# a los programadores Java.

La última versión disponible de C# es la 3.5, de Noviembre de 2007, aunque se está trabajando en importantes e interesantes mejoras para el próximo C# 4.0.

Para poder programar en C# necesitaremos instalar, al menos, el framework .NET, aunque es muy probable que ya lo tengas instalado. De ser así tendrás una carpeta C:\WINDOWS\Microsoft.NET\Framework\v3.5 donde podrás encontrar, entre otras cosas, el compilador de C#, csc.exe (de C Sharp Compiler).

Compilar una clase usando csc es de lo más sencillo. Funciona de forma similar a javac, pasando como argumento los archivos con las clases a compilar. En este caso, no obstante, la extensión de los ficheros es cs, de C Sharp. Para compilar un archivo de código fuente:

csc Ejemplo.cs

Para compilar varios archivos:

csc *.cs

Otra opción a la hora de programar y compilar nuestras aplicaciones es utilizar Visual Studio, el popular entorno de desarrollo de Microsoft. Es posible descargar una versión trial de 90 días del entorno desde la web de Microsoft, así como una versión gratuita recortada llamada Express Edition, ideal para estudiantes y para personas que estén empezando con el lenguaje.

Por último también podemos recurrir a alternativas libres, como es el caso de #develop (SharpDevelop), un IDE muy similar a Visual Studio, salvando las distancias.

En todo caso una vez compilemos nuestro programa el resultado será un exe o una dll, que, como las clases de Java, no contendrá código máquina, sino un lenguaje intermedio para una máquina virtual llamado CIL (Common Intermediate Language). Este código intermedio se compilará a código máquina usando un compilador JIT cuando sea necesario.

El punto de entrada a una aplicación de consola en C# es el método Main. Por convención los nombres de los miembros, las clases, interfaces y espacios de nombres utilizan pascal casing, es decir, la primera letra de cada palabra en mayúsculas.

class Ejemplo {
  static void Main(string[] args) {
  }
}

Main puede devolver void o un int a modo de estado de retorno.

class Ejemplo {
  static void Main(string[] args) {
    return 0;
  }
}

Podemos obviar los argumentos si no vamos a pasar ningún parámetro por línea de comandos, cosa que no podemos hacer en Java.

class Ejemplo {
  static void Main() {
  }
}

Para imprimir un texto en la consola se utilizan los métodos System.Console.Write() y System.Console.WriteLine()

class Ejemplo {
  static void Main() {
    System.Console.WriteLine("Hola mundo");
  }
}

Estos métodos son más parecidos al System.out.printf de Java que a System.out.print y System.out.println, ya que permiten formatear las cadenas.

class Ejemplo {
  static void Main() {
    string usuario = "juan";
    System.Console.WriteLine("Bienvenido {0}", usuario);
  }
}

Para ejecutar el programa en Visual Studio podemos utilizar la combinación de teclas Ctrl + F5, o bien F5 si queremos iniciar el programa con el depurador.

Dependiendo del IDE que utilices puede que te interese añadir una llamada a System.Console.Read() o System.Console.ReadLine() para leer un carácter o una línea de texto desde el teclado antes de terminar la ejecución del programa, y así poder ver el resultado tranquilamente.

class Ejemplo {
  static void Main() {
    System.Console.WriteLine("Hola mundo");
    System.Console.Read();
  }
}

Los tipos predefinidos son similares a Java, a excepción de que existen tipos enteros sin signo, además de un tipo de punto flotante decimal que ofrece mayor precisión que float y double y es similar a la clase BigDecimal de Java. Es posible que en Java 7 BigDecimal soporte operadores, reduciendo así las diferencias con decimal.

Todos los literales con punto se consideran valores de tipo double. Si queremos asignar un literal con coma a una variable de tipo float o decimal tendremos que añadir obligatoriamente el sufijo F o M respectivamente para indicar que el literal es de ese tipo. En caso contrario no compilará.

Esto no compilaría:

class Ejemplo {
  public static void Main() {
    float f = 1.23;
  }
}

Esto si:

class Ejemplo {
  public static void Main() {
    float f = 1.23F;
  }
}

string es en realidad un simple alias de la clase System.String. No existe, por tanto, ninguna diferencia entre las siguientes formas de crear un objeto cadena. string se sustituye por System.String al compilar.

class Ejemplo {
  public static void Main() {
    string cadena1 = "hola";
    System.String cadena2 = "adios";
  }
}

De igual forma int, long, byte, … son en realidad alias de las clases System.Int32, System.Int64, System.Byte, …

En C# todos los objetos derivan de System.Object, de forma análoga a los objetos de Java que derivan de java.lang.Object. también existe un alias de System.Object que es object.

Los operadores son similares a los de Java: +, -, *, /, %, ==, !=, &, ^, …

La instrucción if-else funciona igual que en Java, así como los bucles for, while y do-while. Tenemos también sentencias break y continue, igual que en Java.

Un ejemplo del uso del bucle for:

class Ejemplo {
  public static void Main() {
    int[] numeros = new int[]{1, 2, 3, 4,};
    for (int i = 0; i < numeros.Length; i++)
      System.Console.WriteLine(numeros[i]);
  }
}

Como vemos los arrays también son similares a los de Java.

El bucle foreach tiene una palabra clave propia, a diferencia de Java, que utiliza for. La sintaxis es parecida, sustituyendo los dos puntos (:) de Java por la palabra clave in.

class Ejemplo {
  public static void Main() {
    int[] numeros = {1, 2, 3, 4};
    foreach (int numero in numeros)
      System.Console.WriteLine(numero);
  }
}

Ambos lenguajes tienen en común varios modificadores.

De entre los modificadores de acceso coinciden public (acceso no restringido), private (acceso restringido a la clase contenedora) y protected (acceso restringido a la clase contenedora y a las que la extienden). C# añade un par de modificadores nuevos: internal que indica que un miembro o tipo sólo se puede acceder desde tipos del mismo proyecto o assembly y protected internal que limita el acceso a las clases del proyecto actual y a las clases que extiendan la clase actual.

Por defecto las clases son internal y los miembros de las clases, private.

Otros modificadores en común son abstract, volatile y static. En C# static también se puede utilizar sobre clases para indicar que la clase se compone exclusivamente de miembros estáticos y que no se puede instanciar. En C# también existe un equivalente al inicializador o bloque estático de Java en forma de constructor estático.

public class Reunion {
  public string Nombre;
  public static int ZonaHoraria;

  static Reunion() {
    System.Console.WriteLine("Constructor estático");
    ZonaHoraria = System.TimeZoneInfo.Local.BaseUtcOffset.Hours;
  }

  public Reunion(string nombre) {
    System.Console.WriteLine("Constructor");
    this.Nombre = nombre;
  }
}

class Ejemplo {
  static void Main() {
    Reunion r = new Reunion("Reunión de desarrollo");
    System.Console.WriteLine(r.Nombre);
    System.Console.WriteLine(Reunion.ZonaHoraria);
    System.Console.ReadLine();
  }
}

const se utiliza para crear constantes, convirtiendo una variable en estática e inmutable de forma similar a static final en Java. En Java const es, de hecho, una palabra clave, aunque no se utiliza, por lo que no podemos crear variables o métodos con dicho nombre.

sealed es parecido al final de Java. Al aplicarse sobre una clase, indica que la clase no se puede extender. Al aplicarse a un método, indicada que no se puede sobreescribir. Sin embargo, a diferencia de final, sealed no se puede aplicar sobre variables y sólo es válido para métodos si este reemplaza un método de una clase padre a su vez. Para variables se puede utilizar const o readonly (sólo lectura), que se diferencia del primero en que se puede inicializar tanto en la declaración de la variable como en un constructor, además de no convertirse en estática.

extern es parecido al native de Java. Indica que el método está implementado externamente, posiblemente en otro lenguaje.

El equivalente del modificador transient de Java sería el atributo [NonSerialized]. Los atributos son el equivalente en C# de las anotaciones Java.

[Serializable()]
class MiClase {
  public int Serializable1;
  public string Serializable2;

  [NonSerialized()]
  public int NoSerializable;
}

C# cuenta con muchos otros modificadores que no tienen equivalente directo en Java como override, partial, ref, ...

El modificador ref, por ejemplo, hace que el parámetro indicado se pase por referencia en lugar de por valor, que es el comportamiento estándar de C#. De esta forma las modificaciones que se realicen dentro de la función afectarán a la variable y no serán locales al método. Esto, sin embargo, no es una buena práctica.

class Ejemplo {
  public static void Main() {
    int numero = 10;
    sumar(ref numero);
    System.Console.WriteLine(numero);
  }

  static void sumar(ref int num) {
    num = num + 1;
    System.Console.WriteLine(num);
  }
}

El modificador params se utiliza para crear métodos con número de parámetros variable de forma similar a los varargs en Java.

class Ejemplo {
  public static void Main() {
    imprimir("Uno", "Dos", "Tres");
    System.Console.ReadLine();
  }

  public static void imprimir(params string[] cadenas) {
    foreach (string cadena in cadenas)
      System.Console.WriteLine(cadena);
  }
}

En C# las clases se organizan en namespaces o espacios de nombre, un concepto similar al de los paquetes en Java.

namespace Aplicacion {
  namespace Interfaz {
    class VentanaPrincipal {
    }
  }
}

Para importar un espacio de nombres se utiliza la palabra clave using, que sería algo parecido al import de Java. Comparemos el siguiente código:

class Ejemplo {
  public static void Main() {
    System.Console.WriteLine(System.Math.Sqrt(16));
  }
}

con este otro en el que importamos el espacio de nombres System:

using System;

class Ejemplo {
  public static void Main() {
    Console.WriteLine(Math.Sqrt(16));
  }
}

Las clases y las interfaces tienen el mismo aspecto que en Java.

class Ejemplo {
  int atributo = 10;

  public Ejemplo() {
    Console.WriteLine("Constructor");
  }

  public void saludar() {
    Console.WriteLine("Un método");
  }
}

interface Instrumento {
  public void Tocar();
}

Lo que no existe en Java, a pesar de que sea pan de cada día en muchos lenguajes modernos y no tan modernos, son las propiedades, que ofrecen una forma más elegante de trabajar con getters y setters y que se descartaron para Java 7.

Para utilizar las propiedades creamos por un lado un atributo privado al que se accederá a través de una propiedad, y por otro la propiedad en si misma, que tiene el aspecto de la definición de un atributo seguido de un bloque get y un bloque set (o bien sólo un bloque get si queremos una propiedad de sólo lectura, o sólo un bloque set si queremos una propiedad de sólo escritura).

class Usuario {
  private string nombre;

  public string Nombre {
    get { return nombre; }
    set { nombre = value; }
  }
}

La única peculiaridad a tener en cuenta es el uso de la palabra clave value para referirnos al valor que se está intentando asignar al atributo.

Desde C# 3.0 existe una forma aún más sencilla de definir las propiedades, y es que si la funcionalidad del get o el set va a consistir tan solo en leer o modificar el valor, podemos ahorrarnos el código del bloque y escribir algo así:

class Usuario {
  private string nombre;

  public string Nombre {
    get;
    set;
  }
}

Una vez definida nuestra propiedad podemos acceder o modificar el atributo como si de un atributo cualquiera se tratase, aunque sabemos que por debajo estamos utilizando un método, con todo lo que ello conlleva (podríamos haber hecho, por ejemplo, que se impidiera que se asignara un valor a nombre que tuviera más de 15 letras).

class Usuario {
  private string nombre;

  public string Nombre {
    get; set;
  }
}

class Ejemplo {
  static void Main() {
    Usuario u = new Usuario();
    u.Nombre = "Raúl";
    System.Console.WriteLine("Hola " + u.Nombre);
  }
}

Otro mecanismo parecido a las propiedades del que también carece Java son los indizadores. Estos funcionan igual que las propiedades, con la excepción de que se acceden utilizando un índice en lugar del nombre de la propiedad. Son adecuados por tanto para colecciones.

class Departamento {
  private string[] trabajadores = new string[100];

  public string this[int indice] {
    get { return trabajadores[indice]; }
    set { trabajadores[indice] = value; }
  }
}

class Ejemplo {
  static void Main() {
    Departamento d = new Departamento();
    d[0] = "Raúl González";
    System.Console.WriteLine(d[0]);
  }
}

Los indizadores no están limitados a índices de tipo int, ni a un solo índice.

Otro tipo de método interesante son los destructores, que se declaran de la misma forma que los constructores añadiendo un ~ antes del nombre de la clase.

class BaseDatos {
  ~BaseDatos() {
    System.Console.WriteLine("Cerrando conexión");
  }
}

Como ya hemos comentado las clases pueden extender otras clases, pero en lugar de utilizar la palabra clave extends se utiliza el operador :.

class Persona {
  }

  class Usuario : Persona {
  }
}

También se utiliza el mismo operador para indicar las interfaces que implementa una clase.

class Clase : Interfaz1, Interfaz2 {
}

• En General marcar “Show heap status” para mostrar un pequeño indicador en la esquina inferior derecha con el uso de Java de la memoria dinámica.
• En General -> Appearance, marcamos “Override presentation settings” para poder modificar la posición de las pestañas y el selector de perspectivas. Desmarcamos “Show text on the perspective bar” para no mostrar el nombre de la perspectiva actual en la barra de perspectivas, para lograr más espacio. Marcamos “Show traditional style tabs” para usar pestañas normales y desmarcamos “Enable animations” para desactivar las animaciones y que el entorno vaya más fluido.
• En General -> Appearance -> Colors and Fonts, expandimos Basic, seleccionamos Text Font, pulsamos Change, y seleccionamos la fuente que queramos utilizar para los editores. En mi caso suelo utilizar Bitstream Vera Sans Mono o Consolas.
• En General -> Editors -> Structured Text Editors marcamos Enable folding para contar con la característica de code folding en los editores de HTML, JSP, XML, …
• En General -> Editors -> Text Editors marcamos Insert spaces for tabs para que el editor introduzca espacios al pulsar la tecla de tabulación en lugar de caracteres de tabulación. Marcamos Show print margin para que el editor muestre una línea en la columna 80. Marcamos show line numbers para mostrar los números de línea.
• En General -> Editors -> Text Editors -> Spelling desmarcamos “Enable spell checking” para que no compruebe la ortografía, cosa que en un editor de código molesta más de lo que ayuda.
• En General -> Workspace seleccionamos Other, UTF-8 para Text file encoding para usar Unicode como juego de caracteres para los archivos que creemos y Other, Unix en New text file line delimiter para usar el caracter de fin de línea de Unix.
• En Java -> Code Style -> Formatter pulsamos “Edit…” para modificar la forma de comportarse del formateo de código automático de Eclipse. En la pestaña “Identation” del nuevo diálogo seleccionamos “Spaces only” para “Tab policy” para que utilice siempre espacios y no tabuladores. Marcamos Statements within ‘switch’ body para que indente las sentencias del switch. Cambiamos el nombre del perfil al que queramos en “Profile name” y pulsamos Ok.
• En Java -> Editor -> Save Actions marcamos Perform the selected actions on save y marcamos Format source code para que use el formateo de código automático al guardar el archivo, Organize imports para que organice los imports según el paquete y Additional actions para otras acciones. Pulsamos Configure para configurar estas otras acciones y en Code Style marcamos Convert for loops to enhanced para que sustituya los bucles que recorren colecciones por la versión for-each y desmarcamos Use modificer ‘final’ where possible para que no declare las variables que no modificamos como final. En Unnecessary Code marcamos Remove unused imports para que se eliminen los imports que no utilizamos. En Code Organizing marcamos Correct indentation y Sort members.
• Cerramos la vista de Outline, que podemos sustituir con el breadcumb, haciendo clic sobre el botón de la barra de herramientas Toggle Breadcumb, o con la vista de outline rápida, pulsando Ctrl + O.

Eclipse guarda la configuración del entorno en una carpeta .metadata dentro del directorio del espacio de trabajo. Una vez configurado basta conservar esta carpeta.