Ben Listbelirli bir değeri olan bir alana sahip bir nesne içerip içermediğini kontrol etmek istiyorum . Şimdi, geçmek ve kontrol etmek için bir döngü kullanabilirsiniz, ancak daha kod verimli bir şey olup olmadığını merak ettim.

Gibi bir şey;

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

Yukarıdaki kod hiçbir şey yapmadığını biliyorum, sadece kabaca ne elde etmeye çalışıyorum göstermek için.

Ayrıca, sadece açıklığa kavuşturmak için, basit bir döngü kullanmak istemememin nedeni, bu kod şu anda bir döngü içinde bir döngü içinde bir döngü içine girecek olmasıdır. Okunabilirlik için bu döngülere döngü eklemeye devam etmek istemiyorum. Bu yüzden basit (ish) alternatifler olup olmadığını merak ettim.

Canlı Yayınlar

Java 8 kullanıyorsanız, belki böyle bir şey deneyebilirsiniz:

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

Veya alternatif olarak, şöyle bir şey deneyebilirsiniz:

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

Bu yöntem döndürür trueeğer List<MyObject>bir içeren MyObjectadıyla name. Her MyObjects üzerinde bir işlem yapmak istiyorsanız getName().equals(name), böyle bir şey deneyebilirsiniz:

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

Burada obir MyObjectörneği temsil eder .

Alternatif olarak, yorumların önerdiği gibi (Teşekkürler MK10), Stream#anyMatchyöntemi kullanabilirsiniz :

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

İki seçeneğiniz var.

1. Tercih edilen ilk seçenek, Object sınıfınızdaki `equals ()` yöntemini geçersiz kılmaktır.

Diyelim ki, bu Object sınıfına sahipsiniz:

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

Şimdi diyelim ki MyObject ismini önemsiyorsunuz, benzersiz olmalı ki iki `` MyObject` 'aynı ada sahipse, eşit kabul edilmelidir. Bu durumda, eşitliği belirlemek için adları karşılaştırmak için `equals ()` yöntemini (ve ayrıca `hashcode ()` yöntemini) geçersiz kılmak istersiniz.

Bunu yaptıktan sonra, Koleksiyonda "foo" adında bir MyObject içerip içermediğini kontrol edebilirsiniz:

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

Ancak, aşağıdaki durumlarda bu sizin için bir seçenek olmayabilir:

• Eşitliği kontrol etmek için hem adı hem de konumu kullanıyorsunuz, ancak yalnızca Koleksiyonda belirli bir konuma sahip herhangi bir `` MyObject` 'olup olmadığını kontrol etmek istiyorsunuz. Bu durumda, zaten `` equals () '' değerini geçersiz kıldınız.
• "MyObject", değiştirme özgürlüğünüz olmayan bir API'nın parçasıdır.

Bunlardan herhangi biri söz konusuysa 2. seçenek istersiniz:

2. Kendi yardımcı programınızı yazın:

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

Alternatif olarak, ArrayList'i (veya başka bir koleksiyonu) genişletebilir ve ardından kendi yönteminizi ekleyebilirsiniz:

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

Ne yazık ki daha iyi bir yol yok.

Google Guava

Guava kullanıyorsanız , fonksiyonel bir yaklaşım izleyebilir ve aşağıdakileri yapabilirsiniz

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

Bu biraz ayrıntılı görünüyor. Ancak yüklem bir nesnedir ve farklı aramalar için farklı varyantlar sağlayabilirsiniz. Kitaplığın kendisinin koleksiyonun yinelemesini ve uygulamak istediğiniz işlevi nasıl ayırdığını not edin. equals()Belirli bir davranış için geçersiz kılmanız gerekmez .

Aşağıda belirtildiği gibi, Java 8 ve daha sonra yerleşik java.util.Stream çerçevesi benzer bir şey sağlar.

Java 8+ kullanarak şu şekilde yapabilirsiniz:

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

Collection.contains()equals()biri dönünceye kadar her nesne çağrılarak uygulanır true.

Yani bunu uygulamanın bir yolu geçersiz kılmaktır equals()ama elbette, sadece bir tanesine eşit olabilirsiniz.

Bu nedenle Guava gibi çerçeveler bunun için tahminleri kullanır. İle Iterables.find(list, predicate)testi yüklemine girerek rastgele alanları arayabilirsiniz.

VM'nin üzerine inşa edilmiş diğer diller de buna sahiptir. Örneğin, Groovy'de şunları yazmanız yeterlidir:

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

Java 8 de tüm hayatımızı kolaylaştırdı:

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

Böyle şeyleri önemsiyorsanız, "Java'nın Ötesinde" kitabını öneriyorum. Java'nın sayısız eksiklikleri ve diğer dillerin nasıl daha iyi performans gösterdiğine dair birçok örnek içermektedir.

Ikili arama

Listenizdeki bir öğeyi aramak için Collections.binarySearch komutunu kullanabilirsiniz (listenin sıralandığı varsayılarak):

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

nesne koleksiyonda yoksa negatif sayı döndürür, yoksa nesnenin değerini döndürür index. Bununla farklı arama stratejilerine sahip nesneleri arayabilirsiniz.

Harita

Hashmap<String, Object>Değerlerden birini anahtar olarak kullanarak oluşturabilir ve sonra yourHashMap.keySet().contains(yourValue)doğru döndürüp döndürmediğini görebilirsiniz.

Eclipse Koleksiyonları

Eğer kullanıyorsanız Eclipse Koleksiyonlar kullanabileceğiniz anySatisfy()yöntemi. Ya uyum Listbir de ListAdapterulaşabilir veya değiştirmek Listbir içine ListIterablemümkünse.

ListIterable<MyObject> list = ...;

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

Bunun gibi işlemleri sık sık yaparsanız, türün özelliğe sahip olup olmadığını yanıtlayan bir yöntem ayıklamak daha iyidir.

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

Alternatif formu anySatisfyWith()bir yöntem başvurusuyla birlikte kullanabilirsiniz .

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

Para üstünü yapamıyorsanız Listbir içine ListIterable, burada bütçeyi nasıl ListAdapter.

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

Not: Eclipse ödemeleri için bir komisyoncuyum.

Predicate

Koleksiyonlarla uğraşmak için size daha fazla işlevsellik kazandıran Java 8 veya kitaplığı kullanmazsanız, çözümünüzden daha fazla kullanılabilecek bir şey uygulayabilirsiniz.

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    
    }

Ben böyle bir şey kullanıyorum, yüklem arayüzü var, ve benim util sınıfına uygulama geçiriyorum.

Bunu kendi tarzımda yapmanın avantajı nedir? herhangi bir tür koleksiyonunda arama ile ilgilenen bir yönteminiz var. ve farklı bir alana göre arama yapmak istiyorsanız ayrı yöntemler oluşturmanız gerekmez. Yapmanız gereken tek şey, artık yararlı olmadığı anda yok edilebilecek farklı yüklem sağlamaktır /

kullanmak istiyorsanız, yapmanız gereken tek şey yöntemi çağırmak ve yükleminizi tanımlamaktır.

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

İşte Guava kullanan bir çözüm

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

containsyöntem equalsdahili olarak kullanır . Bu yüzden equalssınıfınıza göre ihtiyaca göre yöntemi geçersiz kılmanız gerekir.

Ancak bu sözdizimsel olarak doğru görünmüyor:

new Object().setName("John")

Bunu List.contains(Object with field value equal to x)tekrar tekrar yapmanız gerekirse , basit ve etkili bir çözüm şöyle olacaktır:

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

O zaman List.contains(Object with field value equal to x)aynı sonuç olurdufieldOfInterestValues.contains(x);

ayrıca şunları anyMatch()kullanabilirsiniz:

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

JAVA 8 SDK'ya rağmen, kütüphanelerin çalışmanıza yardımcı olabilecek birçok toplama aracı vardır, örneğin: 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 );