Java Akışını 1 ve yalnızca 1 öğeye filtreleme

Bir Streamöğeleri bulmak için Java 8 s kullanmaya çalışıyorum LinkedList. Bununla birlikte, filtre kriterlerine bir ve tek bir eşleşme olduğunu garanti etmek istiyorum.

Bu kodu al:

public static void main(String[] args) {

    LinkedList<User> users = new LinkedList<>();
    users.add(new User(1, "User1"));
    users.add(new User(2, "User2"));
    users.add(new User(3, "User3"));

    User match = users.stream().filter((user) -> user.getId() == 1).findAny().get();
    System.out.println(match.toString());
}

static class User {

    @Override
    public String toString() {
        return id + " - " + username;
    }

    int id;
    String username;

    public User() {
    }

    public User(int id, String username) {
        this.id = id;
        this.username = username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public int getId() {
        return id;
    }
}

Bu kod User, kimlikleri temel alınarak bulunur. Ancak Userfiltrenin kaç tane ile eşleştiğinin garantisi yoktur .

Filtre hattını şu şekilde değiştirme:

User match = users.stream().filter((user) -> user.getId() < 0).findAny().get();

Bir firlatirmisiniz NoSuchElementException(iyi!)

Yine de birden fazla eşleşme varsa bir hata atmasını istiyorum. Bunu yapmanın bir yolu var mı?

Özel oluştur Collector

public static <T> Collector<T, ?, T> toSingleton() {
    return Collectors.collectingAndThen(
            Collectors.toList(),
            list -> {
                if (list.size() != 1) {
                    throw new IllegalStateException();
                }
                return list.get(0);
            }
    );
}

Biz kullanmak Collectors.collectingAndThenbizim istenilen inşa etmek Collectoryoluyla

1. Toplayıcı Listile nesnelerimizi Collectors.toList()toplamak.
2. Sonunda tek bir öğeyi döndüren - veya bir IllegalStateExceptionif atar list.size != 1.

Olarak kullanılır:

User resultUser = users.stream()
        .filter(user -> user.getId() > 0)
        .collect(toSingleton());

Daha sonra Collectorbunu istediğiniz kadar özelleştirebilirsiniz ; örneğin, istisnayı yapıcıda argüman olarak verin, iki değere izin vermek için değiştirin ve daha fazlasını yapabilirsiniz.

Alternatif - tartışmasız daha az zarif - bir çözüm:

Bir 'geçici çözüm' kullanabilirsiniz peek()ve bir AtomicInteger, ama gerçekten bunu kullanmamalısınız.

Yapabileceğiniz şey onu sadece a'da toplamaktır List, şöyle:

LinkedList<User> users = new LinkedList<>();
users.add(new User(1, "User1"));
users.add(new User(2, "User2"));
users.add(new User(3, "User3"));
List<User> resultUserList = users.stream()
        .filter(user -> user.getId() == 1)
        .collect(Collectors.toList());
if (resultUserList.size() != 1) {
    throw new IllegalStateException();
}
User resultUser = resultUserList.get(0);

Tamlık uğruna, @ prunge'nin mükemmel cevabına karşılık gelen 'tek astar':

User user1 = users.stream()
        .filter(user -> user.getId() == 1)
        .reduce((a, b) -> {
            throw new IllegalStateException("Multiple elements: " + a + ", " + b);
        })
        .get();

Bu, tek eşleme elemanını akıştan alır,

• NoSuchElementException akışın boş olması durumunda veya
• IllegalStateException akışın birden fazla eşleşen öğe içermesi durumunda.

Bu yaklaşımın bir varyasyonu, bir istisnayı erkenden atmaktan kaçınır ve bunun yerine sonucu Optional, tek öğeyi içeren veya sıfır veya birden çok öğe varsa hiçbir şey (boş) olarak temsil eder :

Optional<User> user1 = users.stream()
        .filter(user -> user.getId() == 1)
        .collect(Collectors.reducing((a, b) -> null));

Bir gelenek yazmayı içeren diğer cevaplar Collectormuhtemelen daha verimlidir ( Louis Wasserman , +1 gibi), ancak kısalık istiyorsanız, aşağıdakileri öneririm:

List<User> result = users.stream()
    .filter(user -> user.getId() == 1)
    .limit(2)
    .collect(Collectors.toList());

Ardından sonuç listesinin boyutunu doğrulayın.

if (result.size() != 1) {
  throw new IllegalStateException("Expected exactly one user but got " + result);
User user = result.get(0);
}

Guava sağlar MoreCollectors.onlyElement()Burada doğru şeyi yapan. Ancak bunu kendiniz yapmanız gerekiyorsa, bunun için kendiniz yapabilirsiniz Collector:

<E> Collector<E, ?, Optional<E>> getOnly() {
  return Collector.of(
    AtomicReference::new,
    (ref, e) -> {
      if (!ref.compareAndSet(null, e)) {
         throw new IllegalArgumentException("Multiple values");
      }
    },
    (ref1, ref2) -> {
      if (ref1.get() == null) {
        return ref2;
      } else if (ref2.get() != null) {
        throw new IllegalArgumentException("Multiple values");
      } else {
        return ref1;
      }
    },
    ref -> Optional.ofNullable(ref.get()),
    Collector.Characteristics.UNORDERED);
}

... veya Holderyerine kendi türünüzü kullanarak AtomicReference. Bunu Collectoristediğiniz kadar tekrar kullanabilirsiniz .

Guava MoreCollectors.onlyElement()( JavaDoc ) kullanın .

İstediğinizi yapar ve IllegalArgumentExceptionakış iki veya daha fazla öğeden oluşuyorsa NoSuchElementExceptionve akış boşsa a atar .

Kullanımı:

import static com.google.common.collect.MoreCollectors.onlyElement;

User match =
    users.stream().filter((user) -> user.getId() < 0).collect(onlyElement());

Akımlar tarafından başka şekilde desteklenmeyen garip şeyler yapmanızı sağlayan "kaçış kapağı" işlemi aşağıdakileri istemektir Iterator:

Iterator<T> it = users.stream().filter((user) -> user.getId() < 0).iterator();
if (!it.hasNext()) 
    throw new NoSuchElementException();
else {
    result = it.next();
    if (it.hasNext())
        throw new TooManyElementsException();
}

Guava'nın, Iteratortek n öğeyi almak ve almak için uygun bir yöntemi vardır, sıfır veya birden fazla öğe varsa, buradaki alt n-1 çizgilerinin yerini alabilir.

Güncelleme

@Holger tarafından yapılan yorumda güzel öneri:

Optional<User> match = users.stream()
              .filter((user) -> user.getId() > 1)
              .reduce((u, v) -> { throw new IllegalStateException("More than one ID found") });

Orijinal cevap

İstisna atılır Optional#get, ancak yardımcı olmayacak birden fazla öğeniz varsa. Kullanıcıları yalnızca bir öğeyi kabul eden bir koleksiyonda toplayabilirsiniz, örneğin:

User match = users.stream().filter((user) -> user.getId() > 1)
                  .collect(toCollection(() -> new ArrayBlockingQueue<User>(1)))
                  .poll();

ki bu atar java.lang.IllegalStateException: Queue full, ama bu çok acayip geliyor.

Veya isteğe bağlı olarak birleştirilmiş bir azaltma kullanabilirsiniz:

User match = Optional.ofNullable(users.stream().filter((user) -> user.getId() > 1)
                .reduce(null, (u, v) -> {
                    if (u != null && v != null)
                        throw new IllegalStateException("More than one ID found");
                    else return u == null ? v : u;
                })).get();

Azaltma esasen şunu döndürür:

• hiçbir kullanıcı bulunamazsa null
• yalnızca bir tane bulunursa kullanıcı
• birden fazla bulunursa istisna atar

Sonuç daha sonra isteğe bağlı olarak sarılır.

Ancak en basit çözüm muhtemelen bir koleksiyona toplamak, boyutunun 1 olup olmadığını kontrol etmek ve tek öğeyi almak olacaktır.

Bir alternatif, redüksiyon kullanmaktır: (bu örnek, dizeleri kullanır ancak aşağıdakiler dahil herhangi bir nesne türüne kolayca uygulanabilir User)

List<String> list = ImmutableList.of("one", "two", "three", "four", "five", "two");
String match = list.stream().filter("two"::equals).reduce(thereCanBeOnlyOne()).get();
//throws NoSuchElementException if there are no matching elements - "zero"
//throws RuntimeException if duplicates are found - "two"
//otherwise returns the match - "one"
...

//Reduction operator that throws RuntimeException if there are duplicates
private static <T> BinaryOperator<T> thereCanBeOnlyOne()
{
    return (a, b) -> {throw new RuntimeException("Duplicate elements found: " + a + " and " + b);};
}

Yani Usersenin için dava olurdu:

User match = users.stream().filter((user) -> user.getId() < 0).reduce(thereCanBeOnlyOne()).get();

Azaltma kullanma

Bu bulduğum daha basit ve esnek bir yol (@ prunge yanıtına dayanarak)

Optional<User> user = users.stream()
        .filter(user -> user.getId() == 1)
        .reduce((a, b) -> {
            throw new IllegalStateException("Multiple elements: " + a + ", " + b);
        })

Bu şekilde elde edersiniz:

• İsteğe bağlı - her zaman nesnenizle olduğu gibi veya Optional.empty()yoksa
• Birden fazla öğe varsa İstisna (sonunda SİZİN özel türünüz / iletinizle birlikte)

Bu şekilde daha basit olduğunu düşünüyorum:

User resultUser = users.stream()
    .filter(user -> user.getId() > 0)
    .findFirst().get();

Kullanarak Collector:

public static <T> Collector<T, ?, Optional<T>> toSingleton() {
    return Collectors.collectingAndThen(
            Collectors.toList(),
            list -> list.size() == 1 ? Optional.of(list.get(0)) : Optional.empty()
    );
}

Kullanımı:

Optional<User> result = users.stream()
        .filter((user) -> user.getId() < 0)
        .collect(toSingleton());

OptionalGenellikle Collectionbir öğeyi içerdiğini varsayamayacağımız için bir döndürüriz . Durumun bu olduğunu zaten biliyorsanız, arayın:

User user = result.orElseThrow();

Bu, arayana hatayı elden çıkarma yükünü getirir - olması gerektiği gibi.

Guava bir vardır Collectordenir bunun için MoreCollectors.onlyElement().

Biz kullanabilirsiniz RxJava (çok güçlü reaktif uzatma kütüphanesi)

LinkedList<User> users = new LinkedList<>();
users.add(new User(1, "User1"));
users.add(new User(2, "User2"));
users.add(new User(3, "User3"));

User userFound =  Observable.from(users)
                  .filter((user) -> user.getId() == 1)
                  .single().toBlocking().first();

Tek operatör Kullanıcı ya da daha sonra bir kullanıcı bulunursa bir istisna atar.

Gibi Collectors.toMap(keyMapper, valueMapper)aynı anahtarla birden fazla giriş işlemek için kullanımlara bir atma birleşme kolaydır:

List<User> users = new LinkedList<>();
users.add(new User(1, "User1"));
users.add(new User(2, "User2"));
users.add(new User(3, "User3"));

int id = 1;
User match = Optional.ofNullable(users.stream()
  .filter(user -> user.getId() == id)
  .collect(Collectors.toMap(User::getId, Function.identity()))
  .get(id)).get();

IllegalStateExceptionYinelenen anahtarlar için bir alacaksınız . Ama sonunda kod kullanarak bir daha okunabilir olmaz emin değilim if.

Bu iki toplayıcıyı kullanıyorum:

public static <T> Collector<T, ?, Optional<T>> zeroOrOne() {
    return Collectors.reducing((a, b) -> {
        throw new IllegalStateException("More than one value was returned");
    });
}

public static <T> Collector<T, ?, T> onlyOne() {
    return Collectors.collectingAndThen(zeroOrOne(), Optional::get);
}

Eğer, bir 3. parti kitaplığı kullanarak sakıncası yoksa SequenceMgelen Tepegöz-akışları (ve LazyFutureStreamgelen basit-tepki ) hem tek ve singleOptional operatörümüz var.

singleOptional()öğesinde 0veya daha fazla 1öğe varsa bir istisna atar Stream, aksi takdirde tek değeri döndürür.

String result = SequenceM.of("x")
                          .single();

SequenceM.of().single(); // NoSuchElementException

SequenceM.of(1, 2, 3).single(); // NoSuchElementException

String result = LazyFutureStream.fromStream(Stream.of("x"))
                          .single();

singleOptional()Optional.empty()değerinde veya birden fazla değer yoksa döndürür Stream.

Optional<String> result = SequenceM.fromStream(Stream.of("x"))
                          .singleOptional(); 
//Optional["x"]

Optional<String> result = SequenceM.of().singleOptional(); 
// Optional.empty

Optional<String> result =  SequenceM.of(1, 2, 3).singleOptional(); 
// Optional.empty

Açıklama - Her iki kütüphanenin de yazarıyım.

Doğrudan yaklaşımla gittim ve sadece şeyi uyguladım:

public class CollectSingle<T> implements Collector<T, T, T>, BiConsumer<T, T>, Function<T, T>, Supplier<T> {
T value;

@Override
public Supplier<T> supplier() {
    return this;
}

@Override
public BiConsumer<T, T> accumulator() {
    return this;
}

@Override
public BinaryOperator<T> combiner() {
    return null;
}

@Override
public Function<T, T> finisher() {
    return this;
}

@Override
public Set<Characteristics> characteristics() {
    return Collections.emptySet();
}

@Override //accumulator
public void accept(T ignore, T nvalue) {
    if (value != null) {
        throw new UnsupportedOperationException("Collect single only supports single element, "
                + value + " and " + nvalue + " found.");
    }
    value = nvalue;
}

@Override //supplier
public T get() {
    value = null; //reset for reuse
    return value;
}

@Override //finisher
public T apply(T t) {
    return value;
}


} 

JUnit testi ile:

public class CollectSingleTest {

@Test
public void collectOne( ) {
    List<Integer> lst = new ArrayList<>();
    lst.add(7);
    Integer o = lst.stream().collect( new CollectSingle<>());
    System.out.println(o);
}

@Test(expected = UnsupportedOperationException.class)
public void failOnTwo( ) {
    List<Integer> lst = new ArrayList<>();
    lst.add(7);
    lst.add(8);
    Integer o = lst.stream().collect( new CollectSingle<>());
}

}

Bu uygulama threadsafe değildir .

User match = users.stream().filter((user) -> user.getId()== 1).findAny().orElseThrow(()-> new IllegalArgumentException());

Bunu denedin mi

long c = users.stream().filter((user) -> user.getId() == 1).count();
if(c > 1){
    throw new IllegalStateException();
}

long count()
Returns the count of elements in this stream. This is a special case of a reduction and is equivalent to:

     return mapToLong(e -> 1L).sum();

This is a terminal operation.

Kaynak: https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html