Qué son buenos patrones/técnicas para reducir la verbosidad de Java

Question

Una de las cosas que pueden ser un poco molestas acerca de Java es la cantidad de código que necesita para expresar conceptos. Creo en la filosofía de "menos código es mejor", y me gustaría saber cómo puedo escribir Java sin ser tan frustrantemente prolijo. Recientemente, leí la pregunta Hidden Features of Java y fui introducido usando double-brace initialization para simular un literal de Lista o Mapa. Por supuesto, existen inconvenientes en el uso de este método, pero le permite hacer ciertas cosas con un número significativamente menor de caracteres y (si lo formatea correctamente) hacer que el código sea mucho más claro y claro. Me pregunto si no hay otros trucos ingeniosos y características de lenguaje menos conocidas que podrían hacer que mi código sea más conciso.

Me gustaría ver las respuestas con una explicación de la técnica, la manera más detallada que reemplaza, y los posibles inconvenientes de usar la técnica.

Answer 1

A una similar que probablemente ya sabe acerca, a través del "varargs" característica:

String[] array = new String[] {"stack", "over", "flow"}; 
List<String> list = Arrays.asList(array); 

puede abreviarse

List<String> list = Arrays.asList("stack", "over", "flow"); 

Es cierto que no

un ahorro enorme, pero sí reduce el nivel de detalle de una un poco. Como señala Thomas, la lista será inmutable, así que ten cuidado con eso. En realidad, puede modificar la lista, simplemente no puede cambiar su longitud. Gracias a pimlottc por señalar eso.

Answer 2

Antes de la introducción del diamond operator en Java 7, los métodos de fábrica estáticos para crear tipos genéricos podrían usarse para reducir la verbosidad al reducir la necesidad de repetir el parámetro de tipo. (Esto es porque sin el operador de diamantes, Java nunca se infiere el parámetro de tipo de constructores, pero lo hará en los métodos de llamadas.) Google Collections utiliza esta técnica, por lo que puede escribir:

Set<MyClassWithALongName> set = Sets.newHashSet(); 

en lugar de:

Set<MyClassWithALongName> set = new HashSet<MyClassWithALongName>(); 

Busque en las clases Lists, Sets y Maps de Google Collections para los métodos que comienzan con "nuevo" para obtener más ejemplos de esto.

A menos que esté escribiendo para una versión anterior de Java, a partir de Java 7 es mejor usar el operador de diamante.

Answer 3

inicializadores estáticos

Ejemplo 1 (mapa):

Map<String, String> myMap = new HashMap<String, String>() {{ 
    put ("a", "b"); 
    put ("c", "d"); 
}}; 

Ejemplo 2 (Lista):

List<String> myList = new ArrayList<String>() {{ 
    add("a"); 
    add("b"); 
    add("c"); 
}}; 

Answer 4

Fluent interfaces pueden ayudar - con ayuda de los constructores y método de encadenamiento de hacer algo parecido a una DSL en java. El código con el que termina puede ser un poco más difícil de leer, ya que rompe las convenciones de codificación normales de Java, como eliminar el conjunto/obtener de las propiedades.

Así en una interfaz fluida falsa oscilación es posible definir un botón así:

JButton button = Factory.button().icon(anIcon).tooltip("Wow").swing(); 

Otro enfoque es utilizar otro idioma hay muchos que se integra bien con la JVM, tales como:

• JRuby
• Scala
• Cal

Answer 5

Utilice un marco de inyección de dependencia como la primavera. Casi siempre estoy sorprendido de cómo se produce mucho lógica de construcción de código.

Answer 6

Un método "closeQuietly" se puede utilizar en bloques try/finally en situaciones donde las excepciones IO al cerrar son poco interesantes (o imposibles).

Closeable c = null; 
try { 
    ... 
    c = openIt(...); 
    ... 
} finally { 
    closeQuietly(c); 
} 

donde:

/** Close 'c' if it is not null, squashing IOExceptions */ 
public void closeQuietly(Closeable c) { 
    if (c != null) { 
     try { 
      c.close(); 
     } catch (IOException ex) { 
      // log error 
     } 
    } 
} 

---

Tenga en cuenta que con Java 7 y versiones posteriores, el nuevo "intento con recursos" sintaxis hace que este ejemplo particular redundante.

Answer 7

He descubierto que la forma más efectiva (¿única?) De escribir conciso java es no escribir java en absoluto. En los casos en que necesitaba escribir algo rápidamente que todavía funciona con Java, he descubierto que Groovy es una excelente opción. El uso de un lenguaje más conciso que aún compila en bytecode JVM puede ser una excelente solución. Si bien no tengo experiencias personales con él, he escuchado que Scala es una opción aún mejor que Groovy en muchos casos.

Answer 8

Echa un vistazo lambdaj. Tiene muchas características que pueden ayudarlo a hacer que su código sea más conciso y legible.

Answer 9

me encontré con un post dando una técnica interesante que permite escribir un mapa literal en Java como si sería capaz de hacerlo en Perl, Python, Ruby, etc: Building your own literals in Java - Tuples and Maps Me gusta mucho este enfoque! Lo resumiré aquí.

La idea básica es crear una clase de par genérica y definir funciones estáticas que construirán un par, y un mapa de una matriz de pares varargs. Esto permite que el siguiente mapa concisa definición literal:

Map(o("height", 3), o("width", 15), o("weight", 27)); 

Dónde o es el nombre de la función estática para construir un par de objetos T1 y T2, para cualquier tipo de objeto T1 y T2, y Map es el nombre de la función estática para construir un Mapa. No estoy seguro de que me guste la elección de Map como el nombre de la función de construcción del mapa porque es lo mismo que el nombre de la interfaz de Java, pero el concepto sigue siendo bueno.

Answer 10

Más Guave bondad para inicializar mapas inmutables (que me está resultando ser un caso más común forma de inicializar mapas mutables): el ImmutableMap.of(...) variants

Map<Service, Long> timeouts = ImmutableMap.of(
    orderService, 1500, 
    itemService, 500); 

Answer 11

vez tiene que recorrer una colección, sólo para mapear sus elementos por una de sus propiedades?No más, gracias a Maps.uniqueIndex():

private void process(List<Module> modules) { 

    Map<String, Module> byName = Maps.uniqueIndex(modules, new Function<Module, String>() { 
      @Override public String apply(Module input) { 
       return input.getName(); 
      } 
     }); 

o si esto es lo suficientemente frecuentes, que la función de un miembro de public static finalModule modo que lo anterior se reduce a:

Map<String, Module> byName = Maps.uniqueIndex(modules, Module.KEY_FUNCTION);