Je veux vérifier si a Listcontient un objet qui a un champ avec une certaine valeur. Maintenant, je pouvais utiliser une boucle pour parcourir et vérifier, mais j'étais curieux de savoir s'il y avait quelque chose de plus efficace.

Quelque chose comme;

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

Je sais que le code ci-dessus ne fait rien, c'est juste pour montrer à peu près ce que j'essaie de réaliser.

Aussi, juste pour clarifier, la raison pour laquelle je ne veux pas utiliser une simple boucle est parce que ce code va actuellement à l'intérieur d'une boucle qui est à l'intérieur d'une boucle qui est à l'intérieur d'une boucle. Pour plus de lisibilité, je ne veux pas continuer à ajouter des boucles à ces boucles. Je me suis donc demandé s'il existait des alternatives simples (ish).

Ruisseaux

Si vous utilisez Java 8, vous pouvez peut-être essayer quelque chose comme ceci:

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

Ou bien, vous pouvez essayer quelque chose comme ceci:

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

Cette méthode retournera truesi le List<MyObject>contient un MyObjectavec le nom name. Si vous souhaitez effectuer une opération sur chacun des MyObjects que getName().equals(name)vous pourriez essayer quelque chose comme ceci:

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

Où o représente une MyObjectinstance.

Alternativement, comme le suggèrent les commentaires (Merci MK10), vous pouvez utiliser la Stream#anyMatchméthode:

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

Vous avez deux choix.

1. Le premier choix, qui est préférable, est de remplacer la méthode `equals ()` dans votre classe Object.

Disons, par exemple, que vous avez cette classe Object:

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

Supposons maintenant que vous vous souciez uniquement du nom de MyObject, qu'il doit être unique, donc si deux `MyObject`s ont le même nom, ils doivent être considérés comme égaux. Dans ce cas, vous voudrez remplacer la méthode `equals ()` (et aussi la méthode `hashcode ()`) afin qu'elle compare les noms pour déterminer l'égalité.

Une fois que vous avez fait cela, vous pouvez vérifier si une collection contient un MyObject avec le nom "foo" comme ceci:

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

Cependant, cela pourrait ne pas être une option pour vous si:

• Vous utilisez à la fois le nom et l'emplacement pour vérifier l'égalité, mais vous voulez uniquement vérifier si une collection a des `MyObject`s avec un certain emplacement. Dans ce cas, vous avez déjà remplacé `equals ()`.
• `MyObject` fait partie d'une API que vous n'avez pas la liberté de modifier.

Si l'un ou l'autre est le cas, vous aurez besoin de l'option 2:

2. Écrivez votre propre méthode utilitaire:

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

Alternativement, vous pouvez étendre ArrayList (ou une autre collection), puis y ajouter votre propre méthode:

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

Malheureusement, il n'y a pas de meilleure solution.

Google Guava

Si vous utilisez Guava , vous pouvez adopter une approche fonctionnelle et effectuer les opérations suivantes

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

qui a l'air un peu bavard. Cependant, le prédicat est un objet et vous pouvez fournir différentes variantes pour différentes recherches. Notez comment la bibliothèque elle-même sépare l'itération de la collection et la fonction que vous souhaitez appliquer. Vous n'avez pas à remplacer equals()un comportement particulier.

Comme indiqué ci-dessous, le cadre java.util.Stream intégré à Java 8 et versions ultérieures fournit quelque chose de similaire.

Voici comment le faire en utilisant Java 8+:

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

Collection.contains()est implémenté en appelant equals()chaque objet jusqu'à ce qu'un retourne true.

Donc, une façon de l'implémenter est de remplacer, equals()mais bien sûr, vous ne pouvez avoir qu'un seul égal.

Les cadres comme Guava utilisent donc des prédicats pour cela. AvecIterables.find(list, predicate) , vous pouvez rechercher des champs arbitraires en plaçant le test dans le prédicat.

D'autres langages construits au-dessus de la VM ont ceci intégré. Dans Groovy , par exemple, vous écrivez simplement:

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

Java 8 nous a aussi facilité la vie:

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

Si vous vous souciez de choses comme ça, je suggère le livre "Beyond Java". Il contient de nombreux exemples des nombreuses lacunes de Java et de la façon dont d'autres langages fonctionnent mieux.

Recherche binaire

Vous pouvez utiliser Collections.binarySearch pour rechercher un élément dans votre liste (en supposant que la liste est triée):

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

qui renverra un nombre négatif si l'objet n'est pas présent dans la collection ou bien il renverra le indexde l'objet. Avec cela, vous pouvez rechercher des objets avec différentes stratégies de recherche.

Carte

Vous pouvez créer un en Hashmap<String, Object>utilisant l'une des valeurs comme clé, puis voir si yourHashMap.keySet().contains(yourValue)renvoie true.

Collections Eclipse

Si vous utilisez des collections Eclipse , vous pouvez utiliser la anySatisfy()méthode. Soit adapter votre Listen a ListAdapterou changer votre Listen ListIterablesi possible.

ListIterable<MyObject> list = ...;

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

Si vous effectuez fréquemment des opérations comme celle-ci, il est préférable d'extraire une méthode qui indique si le type possède l'attribut.

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

Vous pouvez utiliser le formulaire alternatif anySatisfyWith()avec une référence de méthode.

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

Si vous ne pouvez pas changer votre Listen un ListIterable, voici comment vous l'utiliseriez ListAdapter.

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

Remarque: je suis un committer pour les ollections Eclipse.

Predicate

Si vous n'utilisez pas Java 8, ou une bibliothèque qui vous offre plus de fonctionnalités pour gérer les collections, vous pouvez implémenter quelque chose qui peut être plus réutilisable que votre solution.

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    
    }

j'utilise quelque chose comme ça, j'ai une interface de prédicat, et je passe l'implémentation à ma classe util.

Quel est l'avantage de faire cela à ma façon? vous avez une méthode qui traite de la recherche dans n'importe quelle collection de types. et vous n'avez pas à créer de méthodes distinctes si vous souhaitez effectuer une recherche par champ différent. tout ce que vous devez faire est de fournir un prédicat différent qui peut être détruit dès qu'il ne sert plus /

si vous voulez l'utiliser, il vous suffit d'appeler la méthode et de définir votre prédicat

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

Voici une solution utilisant Guava

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

containsutilise en equalsinterne. Vous devez donc remplacer leequals méthode de votre classe selon vos besoins.

Btw cela ne semble pas correct sur le plan statistique:

new Object().setName("John")

Si vous devez effectuer cette opération à List.contains(Object with field value equal to x)plusieurs reprises, une solution de contournement simple et efficace serait:

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

Ensuite, le List.contains(Object with field value equal to x)serait le même résultat quefieldOfInterestValues.contains(x);

vous pouvez également anyMatch()utiliser:

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

Malgré JAVA 8 SDK, de nombreuses bibliothèques d'outils de collecte peuvent vous aider à travailler, par exemple: 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 );