Filtrar una lista de JavaBeans con Google Guava

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, será mejor que la transforme en un Conjunto (HashSet, preferrably) y llame a contains en este conjunto, en lugar de la lista, porque contains es O(1) para un HashSet, y O(n) para una Lista.

Explicando sus dudas de la oración:

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

Java, a pesar de ser tan popular, carece de soporte para funciones de primera clase ^*, lo que es sujeto a cambios en 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 tienes que elegir entre:

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

También me gustaría añadir a la respuesta de @Lois que Guava-way sería crear colección inmutable , porque son mejores que inmodificables , que también se describe en Punto 15, Minimizar la mutabilidad en Java Eficaz 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 detalle de implementación que ImmutableList.Builder crea ArrayList temporal bajo el capó).

_{*: me molesta mucho, vengo de los mundos de Python, JavaScript y Perl, donde las funciones se tratan mejor}

_{**: La guayaba y el Bloch están estrechamente unidos de muchas maneras ;)}

No puedo estar lo suficientemente de acuerdo con las respuestas de Louis y JB. Yo no sabía guayaba-reflexión, tal vez LambdaJ podría ser lo que usted está buscando:

// 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 vez Scala, Clojure o Groovy son lo que estás buscando...

Hablando como desarrollador de guava-reflection, lamento haber abandonado este proyecto en una etapa tan temprana (tengo un trabajo diurno y una esposa e hijos :-)). Mi visión fue algo como:

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

El código existente está alrededor del 60% allí, así que si estás interesado, contáctame y tal vez podamos terminar esto juntos.

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

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

Con el estilo Java8 puedes usar stream + filter para lograr tu objetivo.

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

Con Java8 puedes usar la Colección.removeIf ()

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

Esto por supuesto modificará la lista actual.

Aquí hay un ejemplo de uso de genéricos usando guayaba, beanutils para filtrar cualquier lista usando coincidencia solicitada

/**
 * 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);
}