Tienes dos opciones.

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

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

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

Ahora digamos que solo le importa el nombre del miObjeto, que debe ser único, por lo que si dos `miObjeto ' tienen el mismo nombre deberían considerarse iguales. En ese caso, querrás anular el método` equals () ' (y también el método` hashcode ()') para que compara los nombres para determinar la igualdad.

Una vez hecho esto, puedes comprobar 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 ' con una ubicación determinada. En este caso, ya has anulado `equals()`.
• 'myObject' es parte de una API que no tienes libertad para cambiar.

Si cualquiera de estos es el caso, usted querrá 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 agregar 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 está utilizando Guayaba , puede tomar 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 parece un poco prolijo. Sin embargo, el predicado es un objeto y puede proporcionar diferentes variantes para diferentes búsquedas. Observe cómo la propia biblioteca separa la iteración de la colección y la función que desea aplicar. No tienes que anular equals() para un comportamiento en particular.

Como se indica a continuación, el java.útil.Stream framework integrado en Java 8 y posteriores proporciona algo similar.

Búsqueda binaria

Puede usar Colecciones.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 bien devolverá el index del objeto. Con esto puedes buscar objetos con diferentes estrategias de búsqueda.

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

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

Frameworks como Guava por lo tanto usan predicados para esto. Con Iterables.find(list, predicate), puede buscar campos arbitrarios poniendo la prueba en el predicado.

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

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

Java 8 hizo todas nuestras vidas más fáciles, también:

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

Si te importan cosas como esta, te sugiero el libro "Beyond Java". Contiene muchos ejemplos de las numerosas deficiencias de Java y cómo otros lenguajes hacen mejor.

Colecciones de eclipses

Si estás usando Colecciones de eclipse, puedes usar el método anySatisfy(). Puede adaptar su List en un ListAdapter o cambiar su List en un ListIterable si es posible.

ListIterable<MyObject> list = ...;

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

Si va a hacer 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 utilizar la forma alternativa anySatisfyWith() junto con una referencia de método.

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

Si no puede cambiar su List en a ListIterable, así es como usarías ListAdapter.

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

Nota: Soy un committer para ollections de Eclipse.

Mapa

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

Predicate

Si no utiliza Java 8, o biblioteca que le da más funcionalidad para tratar con colecciones, podría implementar algo que puede ser 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 interfaz de predicado, y estoy pasando la implementación a mi clase util.

¿Cuál es la ventaja de hacer esto a mi manera? usted tiene un método que se ocupa de la búsqueda en cualquier tipo de colección. y no tienes que crear separado métodos si desea buscar por campo diferente. todo lo que hay que hacer es proporcionar predicado diferente que puede ser destruido tan pronto como ya no es ú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());
     }
});

contains el método utiliza equals internamente. Por lo tanto, necesita anular el método equals para su clase según su necesidad.

Por cierto esto no parece sintáticamente 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 que fieldOfInterestValues.contains(x);

A pesar de JAVA 8 SDK hay una gran cantidad de bibliotecas de herramientas de colección que 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 );

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