Quero verificar se a Listcontém um objeto que possui um campo com um determinado valor. Agora, eu poderia usar um loop para passar e verificar, mas fiquei curioso se havia algo mais eficiente em termos de código.

Algo como;

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

Eu sei que o código acima não faz nada, é apenas para demonstrar aproximadamente o que estou tentando alcançar.

Além disso, apenas para esclarecer, a razão pela qual não quero usar um loop simples é porque esse código atualmente está dentro de um loop que está dentro de um loop que está dentro de um loop. Para facilitar a leitura, não quero continuar adicionando loops a esses loops. Então, eu me perguntava se havia alguma alternativa simples (ish).

Streams

Se você estiver usando o Java 8, talvez você possa tentar algo como isto:

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

Ou, como alternativa, você pode tentar algo como isto:

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

Este método irá retornar truese o List<MyObject>contém uma MyObjectcom o nome name. Se você deseja executar uma operação em cada um dos MyObjects que getName().equals(name), então você pode tentar algo como isto:

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

Onde orepresenta uma MyObjectinstância.

Como alternativa, como sugerem os comentários (Obrigado MK10), você pode usar o Stream#anyMatchmétodo:

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

Você tem duas escolhas.

1. A primeira opção, que é preferível, é substituir o método `equals ()` na sua classe Object.

Digamos, por exemplo, você tem esta classe Object:

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

Agora, digamos que você se preocupa apenas com o nome do MyObject, que deve ser único; portanto, se dois `MyObject`s tiverem o mesmo nome, devem ser considerados iguais. Nesse caso, você deseja substituir o método `equals ()` (e também o método `hashcode ()`) para que ele compare os nomes para determinar a igualdade.

Depois de fazer isso, você pode verificar se uma coleção contém um MyObject com o nome "foo" da seguinte maneira:

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

No entanto, isso pode não ser uma opção para você se:

• Você está usando o nome e o local para verificar a igualdade, mas deseja verificar apenas se uma coleção possui algum `MyObject` com um determinado local. Neste caso, você já substituiu `equals ()`.
• O `MyObject` faz parte de uma API que você não tem liberdade para alterar.

Se um desses for o caso, você desejará a opção 2:

2. Escreva seu próprio método utilitário:

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

Como alternativa, você pode estender o ArrayList (ou alguma outra coleção) e adicionar seu próprio método a ele:

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

Infelizmente, não há uma maneira melhor de contornar isso.

Google Guava

Se você estiver usando o Guava , poderá adotar uma abordagem funcional e fazer o seguinte

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

que parece um pouco detalhado. No entanto, o predicado é um objeto e você pode fornecer variantes diferentes para pesquisas diferentes. Observe como a própria biblioteca separa a iteração da coleção e a função que você deseja aplicar. Você não precisa substituir equals()por um comportamento específico.

Conforme observado abaixo, a estrutura java.util.Stream integrada ao Java 8 e posterior fornece algo semelhante.

É assim que se faz usando o Java 8+:

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

Collection.contains()é implementado chamando equals()cada objeto até que um retorne true.

Portanto, uma maneira de implementar isso é substituir, equals()mas é claro, você pode ter apenas um igual.

Estruturas como o Guava, portanto, usam predicados para isso. Com Iterables.find(list, predicate), você pode procurar campos arbitrários colocando o teste no predicado.

Outros idiomas criados na parte superior da VM têm isso incorporado. No Groovy , por exemplo, você simplesmente escreve:

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

O Java 8 também facilitou todas as nossas vidas:

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

Se você se importa com coisas assim, sugiro o livro "Além do Java". Ele contém muitos exemplos para as inúmeras deficiências do Java e como outras linguagens se saem melhor.

Pesquisa binária

Você pode usar o Collections.binarySearch para pesquisar um elemento na sua lista (supondo que a lista esteja classificada):

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 retornará um número negativo se o objeto não estiver presente na coleção ou retornará indexo objeto. Com isso, você pode procurar objetos com diferentes estratégias de pesquisa.

Mapa

Você pode criar um Hashmap<String, Object>usando um dos valores como chave e ver se yourHashMap.keySet().contains(yourValue)retorna verdadeiro.

Coleções Eclipse

Se você estiver usando o Eclipse Collections , poderá usar o anySatisfy()método Adapte o seu Listem um ListAdapterou troque-o Listpara um, ListIterablese possível.

ListIterable<MyObject> list = ...;

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

Se você realizar operações como essa com frequência, é melhor extrair um método que responda se o tipo tem o 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);
    }
}

Você pode usar o formulário alternativo anySatisfyWith()junto com uma referência de método.

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

Se você não pode transformar seu Listem um ListIterable, veja como você usaria ListAdapter.

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

Nota: Sou um colaborador das coleções do Eclipse.

Predicate

Se você não usa o Java 8 ou a biblioteca que oferece mais funcionalidades para lidar com coleções, você pode implementar algo que pode ser mais reutilizável que a sua solução.

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    
    }

Estou usando algo assim, tenho interface de predicado e estou passando a implementação para minha classe util.

Qual é a vantagem de fazer isso no meu caminho? você tem um método que trata da pesquisa em qualquer coleção de tipos. e você não precisa criar métodos separados se quiser pesquisar por campos diferentes. Tudo o que você precisa fazer é fornecer um predicado diferente que possa ser destruído assim que não for mais útil /

se você quiser usá-lo, tudo o que você precisa fazer é chamar o método e definir seu predicado

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

Aqui está uma solução usando o Goiaba

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

containsO método usa equalsinternamente. Portanto, você precisa substituir o equalsmétodo da sua classe, conforme sua necessidade.

Btw isso não parece sintaticamente correto:

new Object().setName("John")

Se você precisar executar isso List.contains(Object with field value equal to x)repetidamente, uma solução simples e eficiente seria:

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

Então o resultado List.contains(Object with field value equal to x)seria o mesmo quefieldOfInterestValues.contains(x);

você também pode anyMatch()usar:

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

Apesar do JAVA 8 SDK, existem muitas ferramentas de coleção nas quais as bibliotecas podem ajudá-lo a trabalhar, por exemplo: 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 );