Filter Java Stream ke 1 dan hanya 1 elemen

Saya mencoba menggunakan Java 8 Streams untuk menemukan elemen dalam aLinkedList . Namun saya ingin menjamin bahwa hanya ada satu dan hanya satu yang cocok dengan kriteria filter.

Ambil kode ini:

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

Kode ini menemukan Userberdasarkan ID mereka. Tetapi tidak ada jaminan berapa banyakUser yang cocok dengan filter.

Mengubah garis filter ke:

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

Akan melempar NoSuchElementException (bagus!)

Saya ingin melontarkan kesalahan jika ada beberapa pertandingan. Apakah ada cara untuk melakukan ini?

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

Kami menggunakan Collectors.collectingAndThenuntuk membangun yang diinginkan Collectoroleh

1. Mengumpulkan benda-benda kita ListdenganCollectors.toList() kolektor.
2. Menerapkan finisher tambahan di akhir, yang mengembalikan elemen tunggal - atau melempar IllegalStateExceptionif list.size != 1.

Digunakan sebagai:

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

Anda kemudian dapat menyesuaikan ini Collector sebanyak yang Anda inginkan, misalnya memberikan pengecualian sebagai argumen dalam konstruktor, menyesuaikannya untuk memungkinkan dua nilai, dan banyak lagi.

Alternatif - solusi yang bisa dibilang kurang elegan:

Anda dapat menggunakan 'solusi' yang melibatkan peek()danAtomicInteger , tetapi sebenarnya Anda seharusnya tidak menggunakannya.

Apa yang bisa Anda lakukan hanya mengumpulkan itu dalam List, seperti ini:

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

Demi kelengkapan, berikut adalah 'one-liner' yang sesuai dengan jawaban istimewa @ prunge:

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

Ini mendapatkan elemen pencocokan tunggal dari aliran, melempar

• NoSuchElementException dalam kasus aliran kosong, atau
• IllegalStateException dalam hal aliran mengandung lebih dari satu elemen yang cocok.

Variasi dari pendekatan ini menghindari melemparkan pengecualian lebih awal dan sebagai gantinya menyatakan hasilnya sebagai Optionalmengandung elemen tunggal, atau tidak ada (kosong) jika ada nol atau beberapa elemen:

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

Jawaban lain yang melibatkan penulisan kebiasaan Collectormungkin lebih efisien (seperti jawaban Louis Wasserman , +1), tetapi jika Anda ingin singkatnya, saya sarankan yang berikut:

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

Kemudian verifikasi ukuran daftar hasil.

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

Jambu memberikan MoreCollectors.onlyElement()yang melakukan hal yang benar di sini. Tetapi jika Anda harus melakukannya sendiri, Anda bisa melakukannya sendiri 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);
}

... atau menggunakan Holdertipe Anda sendiri, bukan AtomicReference. Anda dapat menggunakannya kembali Collectorsebanyak yang Anda suka.

Gunakan Guava's MoreCollectors.onlyElement()( JavaDoc ).

Itu melakukan apa yang Anda inginkan dan melempar IllegalArgumentExceptionjika aliran terdiri dari dua atau lebih elemen, dan NoSuchElementExceptionjika aliran kosong.

Pemakaian:

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

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

Operasi "escape hatch" yang memungkinkan Anda melakukan hal-hal aneh yang tidak didukung oleh stream adalah meminta 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();
}

Jambu biji memiliki metode kenyamanan untuk mengambil Iteratordan mendapatkan satu-satunya elemen, melempar jika ada nol atau beberapa elemen, yang bisa menggantikan garis n-1 bawah di sini.

Memperbarui

Saran bagus dalam komentar dari @ Holger:

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

Jawaban asli

Pengecualian dilemparkan oleh Optional#get, tetapi jika Anda memiliki lebih dari satu elemen yang tidak akan membantu. Anda dapat mengumpulkan pengguna dalam koleksi yang hanya menerima satu item, misalnya:

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

yang melempar java.lang.IllegalStateException: Queue full, tapi itu terasa terlalu gila.

Atau Anda dapat menggunakan pengurangan yang dikombinasikan dengan opsional:

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

Pengurangan pada dasarnya mengembalikan:

• null jika tidak ada pengguna yang ditemukan
• pengguna jika hanya satu yang ditemukan
• melempar pengecualian jika lebih dari satu ditemukan

Hasilnya kemudian dibungkus dalam opsional.

Tetapi solusi paling sederhana mungkin hanya dengan mengumpulkan ke koleksi, periksa bahwa ukurannya adalah 1 dan dapatkan satu-satunya elemen.

Alternatifnya adalah menggunakan reduksi: (contoh ini menggunakan string tetapi bisa dengan mudah diterapkan ke semua jenis objek termasuk 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);};
}

Jadi untuk kasus dengan UserAnda akan memiliki:

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

Menggunakan mengurangi

Ini adalah cara sederhana dan fleksibel yang saya temukan (berdasarkan jawaban @prunge)

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

Dengan cara ini Anda memperoleh:

• Opsional - seperti biasa dengan objek Anda atau Optional.empty()jika tidak ada
• Pengecualian (dengan akhirnya jenis / pesan khusus ANDA) jika ada lebih dari satu elemen

Saya pikir cara ini lebih sederhana:

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

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

Pemakaian:

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

Kami mengembalikan sebuah Optional, karena kami biasanya tidak dapat menganggap Collectionmengandung persis satu elemen. Jika Anda sudah tahu ini masalahnya, hubungi:

User user = result.orElseThrow();

Ini menempatkan beban menangani kesalahan pada penelepon - sebagaimana mestinya.

Jambu memiliki Collectoruntuk ini disebut MoreCollectors.onlyElement().

Kita dapat menggunakan RxJava ( perpustakaan ekstensi reaktif yang sangat kuat )

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

The tunggal Operator melempar pengecualian jika tidak ada pengguna atau lebih dari satu pengguna ditemukan.

Karena Collectors.toMap(keyMapper, valueMapper)menggunakan merger pelemparan untuk menangani banyak entri dengan kunci yang sama, mudah:

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

Anda akan mendapatkan IllegalStateExceptionkunci duplikat. Tetapi pada akhirnya saya tidak yakin apakah kodenya tidak akan lebih mudah dibaca menggunakan if.

Saya menggunakan dua pengumpul tersebut:

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

Jika Anda tidak keberatan menggunakan perpustakaan pihak ke-3, SequenceMdari cyclops-stream (dan LazyFutureStreamdari reaksi sederhana ), keduanya memiliki operator tunggal & tunggal.

singleOptional()melempar pengecualian jika ada 0atau lebih dari 1elemen dalam Stream, jika tidak mengembalikan nilai tunggal.

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()mengembalikan Optional.empty()jika tidak ada nilai atau lebih dari satu nilai di 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

Pengungkapan - Saya adalah penulis dari kedua perpustakaan.

Saya pergi dengan pendekatan langsung dan hanya mengimplementasikannya:

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


} 

dengan tes JUnit:

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

}

Implementasi ini bukan threadsafe.

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

Sudahkah Anda mencoba ini?

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.

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