Filtrar una lista de JavaBeans con Google Guava

Question

En un programa Java, tengo una lista de beans que deseo filtrar en función de una propiedad específica.

Por ejemplo, supongo que tengo una lista de Persona, un JavaBean, donde Person tiene muchas propiedades, entre ellas 'nombre'.

También tengo una lista de nombres.

Ahora quiero encontrar todas las personas cuyo nombre está en la lista de nombres.

¿Cuál es la mejor manera de ejecutar este filtro con Google Guava?

Hasta ahora, he pensado en combinar guayaba con beanutils Apache, pero eso no parece elegante.

También encontré una biblioteca de extensiones de reflexión aquí: http://code.google.com/p/guava-reflection/, pero no estoy seguro de cómo usarla (hay poca documentación).

¿Alguna idea?

p.s. ¿Puedes decir que realmente extraño la comprensión de la lista de Python?

Answer 1

Hazlo a la vieja usanza, sin guayaba. (Hablando como desarrollador de guayaba.)

List<Person> filtered = Lists.newArrayList(); 
for(Person p : allPersons) { 
    if(acceptedNames.contains(p.getName())) { 
     filtered.add(p); 
    } 
} 

Usted puede hacer esto con guayaba, pero Java no es Python, y tratando de hacerlo en Python es sólo va a perpetuar el código torpe e ilegible. Las utilidades funcionales de Guava se deben usar con moderación, y solo cuando proporcionan un beneficio concreto y mensurable a las líneas de código o al rendimiento.

Answer 2

Iterable<Person> filtered = Iterables.filter(allPersons, new Predicate<Person>() { 
    @Override 
    public boolean apply(Person p) { 
     return acceptedNames.contains(p.getName()); 
    } 
}); 

Si su lista de nombres es grande, es mejor que lo transforman en un conjunto (HashSet, preferentemente) y llamadas contiene en este conjunto, en lugar de la lista, ya que contiene es O (1) para una HashSet y O (n) para una lista.

Answer 3

No puedo estar tan de acuerdo con las respuestas de Louis y JB. No sabía guayaba-reflexión, tal vez LambdaJ podría ser lo que buscas:

// set up 
Person me = new Person("Favio"); 
Person luca = new Person("Luca"); 
Person biagio = new Person("Biagio"); 
Person celestino = new Person("Celestino"); 
Collection<Person> meAndMyFriends = asList(me, luca, biagio, celestino); 

// magic 
Collection<Person> filtered = filter(having(on(Person.class).getName(), 
              isOneOf("Favio", "Luca")), 
            meAndMyFriends); 

// test 
assertThat(filtered, hasItems(me, luca)); 
assertEquals(2, filtered.size()); 

O tal Scala, Clojure o maravilloso de lo que se está buscando ...

Answer 4

Al explicar sus dudas de la oración:

Hasta ahora, he pensado en combinar guayaba con beanutils Apache, pero que no parece elegante.

Java, a pesar de ser tan popular, carece de apoyo first-class function^*, lo que es subject to change in Java 8, donde usted será capaz de hacer:

Iterable <Person> filtered = filter(allPersons, (Person p) -> acceptedNames.contains(p.getName())); 

Con lambdas y será elegante.

Hasta entonces has de elegir entre:

• manera pasada de la escuela (como @Louis escribió)
• filtro detallado de guayaba (@ respuesta de JB)
otras bibliotecas Java funcionales
• o (@ respuesta de superfav)

También me gustaría añadir a @ respuesta de Lois que Guava-way would be to create immutable collection, porque they are better than unmodifiable, que también se describe en el artículo 15 , Minimizar la mutabilidad en Effective Java por Joshua Bloch ^**:

ImmutableList.Builder<Person> builder = ImmutableList.builder(); 
for (final Person p : allPersons) { 
    if (acceptedNames.contains(p.getName())) { 
     builder.add(p); 
    } 
} 
ImmutableList<Person> filtered = builder.build(); 

(Es el detalle de implementación que ImmutableList.Builder crea ArrayList temporal debajo del capó).

_{*: me molesta mucho, vine de mundos Python, JavaScript y Perl, where functions are treated better}

_{**: Guayaba y Bloch son fuertemente acoplado de muchas maneras;)}

Answer 5

Hablando como desarrollador de guava-reflexión, lamento haber abandonado este proyecto en una etapa tan temprana (tengo un trabajo diario y una esposa & niños :-)). Mi visión era algo así como:

Iterable<Object> thingsWithNames = 
    Iterables.filter(someData, 
        // this is a Predicate, obviously 
        BeanProperties.hasBeanProperty("name", String.class)); 

El código existente es de un 60%, así que si usted está interesado, póngase en contacto conmigo y tal vez podemos conseguir este terminó juntos.

Answer 6

Si utiliza un LinkedList (o cualquier otra colección que eliminar elaboraciones no es muy laborioso) en la aplicación de un solo subproceso la solución más eficaz es:

final Iterator<User> userIterator = users.iterator(); 
while (userIterator.hasNext()) { 
    if (/* your condition for exclusion */) { 
     userIterator.remove(); 
    } 
} 

Answer 7

Con estilo Java8 puede utilizar corriente + filtrar para lograr su objetivo.

persons.stream() 
      .filter(p -> names.contains(p.getName())) 
      .collect(Collectors.toList()); 

Answer 8

Con Java8 puede utilizar Collection.removeIf()

List<Person> theList = ...; 
theList.removeIf(
    (Person p)->"paul".equals(p.getName()) 
); 

Esto, por supuesto modificar la lista actual.

Answer 9

Aquí es un ejemplo del uso de genéricos usando la guayaba, BeanUtils para filtrar cualquier lista con partido solicitado

/** 
* Filter List 
* 
* @param inputList 
* @param requestMatch 
* @param invokeMethod 
* @return 
*/ 
public static <T> Iterable<T> predicateFilterList(List<T> inputList, final String requestMatch, 
     final String invokeMethod) { 
    Predicate<T> filtered = new Predicate<T>() { 
     @Override 
     public boolean apply(T input) { 
      boolean ok = false; 
      try { 
       ok = BeanUtils.getProperty(input, invokeMethod).equalsIgnoreCase(requestMatch); 
      } 
      catch (Exception e) { 
       e.printStackTrace(); 
      } 
      return ok; 
     } 
    }; 
    return Iterables.filter(inputList, filtered); 
}