Quiero verificar si a Listcontiene un objeto que tiene un campo con un cierto valor. Ahora, podría usar un bucle para pasar y verificar, pero tenía curiosidad por saber si había algo más eficiente en el código.

Algo como;

if(list.contains(new Object().setName("John"))){
    //Do some stuff
}

Sé que el código anterior no hace nada, es solo para demostrar aproximadamente lo que estoy tratando de lograr.

Además, solo para aclarar, la razón por la que no quiero usar un bucle simple es porque este código irá actualmente dentro de un bucle que está dentro de un bucle que está dentro de un bucle. Para facilitar la lectura, no quiero seguir agregando bucles a estos bucles. Entonces me pregunté si había alternativas simples (ish).

Corrientes

Si está utilizando Java 8, quizás podría intentar algo como esto:

public boolean containsName(final List<MyObject> list, final String name){
    return list.stream().filter(o -> o.getName().equals(name)).findFirst().isPresent();
}

O, alternativamente, podría intentar algo como esto:

public boolean containsName(final List<MyObject> list, final String name){
    return list.stream().map(MyObject::getName).filter(name::equals).findFirst().isPresent();
}

Este método devolverá truesi List<MyObject>contiene un MyObjectcon el nombre name. Si desea realizar una operación en cada uno de los MyObjects getName().equals(name), puede intentar algo como esto:

public void perform(final List<MyObject> list, final String name){
    list.stream().filter(o -> o.getName().equals(name)).forEach(
            o -> {
                //...
            }
    );
}

Donde orepresenta una MyObjectinstancia.

Alternativamente, como sugieren los comentarios (Gracias MK10), puede usar el Stream#anyMatchmétodo:

public boolean containsName(final List<MyObject> list, final String name){
    return list.stream().anyMatch(o -> o.getName().equals(name));
}

Tienes dos opciones.

1. La primera opción, que es preferible, es anular el método `equals ()` en su clase Object.

Digamos, por ejemplo, que tiene esta clase de objeto:

public class MyObject {
    private String name;
    private String location;
    //getters and setters
}

Ahora digamos que solo le importa el nombre de MyObject, que debería ser único, por lo que si dos `MyObject`s tienen el mismo nombre, deberían considerarse iguales. En ese caso, desearía anular el método `equals ()` (y también el método `hashcode ()`) para que compare los nombres para determinar la igualdad.

Una vez que haya hecho esto, puede verificar si una Colección contiene un MyObject con el nombre "foo" de la siguiente manera:

MyObject object = new MyObject();
object.setName("foo");
collection.contains(object);

Sin embargo, esto podría no ser una opción para usted si:

• Está utilizando tanto el nombre como la ubicación para verificar la igualdad, pero solo desea verificar si una Colección tiene algún `MyObject`s con una determinada ubicación. En este caso, ya ha anulado `equals ()`.
• `MyObject` es parte de una API que no tiene libertad para cambiar.

Si cualquiera de estos es el caso, querrá la opción 2:

2. Escriba su propio método de utilidad:

public static boolean containsLocation(Collection<MyObject> c, String location) {
    for(MyObject o : c) {
        if(o != null && o.getLocation.equals(location)) {
            return true;
        }
    }
    return false;
}

Alternativamente, puede extender ArrayList (o alguna otra colección) y luego agregarle su propio método:

public boolean containsLocation(String location) {
    for(MyObject o : this) {
        if(o != null && o.getLocation.equals(location)) {
                return true;
            }
        }
        return false;
    }

Desafortunadamente no hay una mejor manera de evitarlo.

Google guayaba

Si usa Guava , puede adoptar un enfoque funcional y hacer lo siguiente

FluentIterable.from(list).find(new Predicate<MyObject>() {
   public boolean apply(MyObject input) {
      return "John".equals(input.getName());
   }
}).Any();

que se ve un poco detallado. Sin embargo, el predicado es un objeto y puede proporcionar diferentes variantes para diferentes búsquedas. Observe cómo la biblioteca misma separa la iteración de la colección y la función que desea aplicar. No tiene que anular equals()un comportamiento particular.

Como se indica a continuación, el marco java.util.Stream integrado en Java 8 y posterior proporciona algo similar.

Así es como se hace usando Java 8+:

boolean isJohnAlive = list.stream().anyMatch(o -> o.getName().equals("John"));

Collection.contains()se implementa llamando equals()a cada objeto hasta que uno regrese true.

Entonces, una forma de implementar esto es anular, equals()pero por supuesto, solo puede tener uno igual.

Los marcos como la guayaba, por lo tanto, utilizan predicados para esto. Con Iterables.find(list, predicate), puede buscar campos arbitrarios poniendo la prueba en el predicado.

Otros lenguajes construidos sobre la VM tienen esto incorporado. En Groovy , por ejemplo, simplemente escribe:

def result = list.find{ it.name == 'John' }

Java 8 también nos facilitó la vida:

List<Foo> result = list.stream()
    .filter(it -> "John".equals(it.getName())
    .collect(Collectors.toList());

Si te importan cosas como esta, te sugiero el libro "Más allá de Java". Contiene muchos ejemplos de las numerosas deficiencias de Java y de cómo otros idiomas funcionan mejor.

Búsqueda binaria

Puede usar Collections.binarySearch para buscar un elemento en su lista (suponiendo que la lista esté ordenada):

Collections.binarySearch(list, new YourObject("a1", "b",
                "c"), new Comparator<YourObject>() {

            @Override
            public int compare(YourObject o1, YourObject o2) {
                return o1.getName().compareTo(o2.getName());
            }
        });

que devolverá un número negativo si el objeto no está presente en la colección o devolverá el indexdel objeto. Con esto puede buscar objetos con diferentes estrategias de búsqueda.

Mapa

Puede crear un Hashmap<String, Object>utilizando uno de los valores como clave y luego ver si yourHashMap.keySet().contains(yourValue)devuelve verdadero.

Colecciones Eclipse

Si está usando Eclipse Collections , puede usar el anySatisfy()método. Adapta tu Listen ListAdaptero cambia tu Lista ListIterablesi es posible.

ListIterable<MyObject> list = ...;

boolean result =
    list.anySatisfy(myObject -> myObject.getName().equals("John"));

Si realiza operaciones como esta con frecuencia, es mejor extraer un método que responda si el tipo tiene el atributo.

public class MyObject
{
    private final String name;

    public MyObject(String name)
    {
        this.name = name;
    }

    public boolean named(String name)
    {
        return Objects.equals(this.name, name);
    }
}

Puede usar la forma alternativa anySatisfyWith()junto con una referencia de método.

boolean result = list.anySatisfyWith(MyObject::named, "John");

Si no puede cambiarlo Listpor uno ListIterable, así es como lo usaría ListAdapter.

boolean result = 
    ListAdapter.adapt(list).anySatisfyWith(MyObject::named, "John");

Nota: Soy un committer para las selecciones de Eclipse.

Predicate

Si no utiliza Java 8, o una biblioteca que le brinda más funcionalidad para manejar colecciones, podría implementar algo que sea más reutilizable que su solución.

interface Predicate<T>{
        boolean contains(T item);
    }

    static class CollectionUtil{

        public static <T> T find(final Collection<T> collection,final  Predicate<T> predicate){
            for (T item : collection){
                if (predicate.contains(item)){
                    return item;
                }
            }
            return null;
        }
    // and many more methods to deal with collection    
    }

Estoy usando algo así, tengo una interfaz de predicado y la paso a mi clase de utilidad.

¿Cuál es la ventaja de hacer esto a mi manera? tiene un método que se ocupa de buscar en cualquier tipo de colección. y no tiene que crear métodos separados si desea buscar por un campo diferente. Todo lo que necesita hacer es proporcionar un predicado diferente que se pueda destruir tan pronto como ya no sea útil.

si desea usarlo, todo lo que necesita hacer es llamar al método y definir su predicado

CollectionUtil.find(list, new Predicate<MyObject>{
    public boolean contains(T item){
        return "John".equals(item.getName());
     }
});

Aquí hay una solución usando guayaba

private boolean checkUserListContainName(List<User> userList, final String targetName){

    return FluentIterable.from(userList).anyMatch(new Predicate<User>() {
        @Override
        public boolean apply(@Nullable User input) {
            return input.getName().equals(targetName);
        }
    });
}

containsEl método se utiliza equalsinternamente. Por lo tanto, debe anular elequals método para su clase según su necesidad.

Por cierto, esto no parece sintácticamente correcto:

new Object().setName("John")

Si necesita realizar esto List.contains(Object with field value equal to x)repetidamente, una solución simple y eficiente sería:

List<field obj type> fieldOfInterestValues = new ArrayList<field obj type>;
for(Object obj : List) {
    fieldOfInterestValues.add(obj.getFieldOfInterest());
}

Entonces el List.contains(Object with field value equal to x)tendría el mismo resultado quefieldOfInterestValues.contains(x);

también puedes anyMatch()usar:

public boolean containsName(final List<MyObject> list, final String name){
    return list.stream().anyMatch(o -> o.getName().contains(name));
}

A pesar de JAVA 8 SDK, hay muchas herramientas de colección que las bibliotecas pueden ayudarlo a trabajar, por ejemplo: http://commons.apache.org/proper/commons-collections/

Predicate condition = new Predicate() {
   boolean evaluate(Object obj) {
        return ((Sample)obj).myField.equals("myVal");
   }
};
List result = CollectionUtils.select( list, condition );