Lọc Java Stream thành 1 và chỉ 1 phần tử

Tôi đang cố gắng sử dụng Java 8 Streamđể tìm các phần tử trong a LinkedList. Tôi muốn đảm bảo, tuy nhiên, có một và chỉ một phù hợp với tiêu chí lọc.

Lấy mã này:

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

Mã này tìm thấy Userdựa trên ID của họ. Nhưng không có gì đảm bảo có bao nhiêu Users khớp với bộ lọc.

Thay đổi dòng bộ lọc thành:

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

Sẽ ném một NoSuchElementException(tốt!)

Tôi muốn nó ném một lỗi nếu có nhiều trận đấu, mặc dù. Có cách nào để làm việc này không?

Tạo một tùy chỉnh 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);
            }
    );
}

Chúng tôi sử dụng Collectors.collectingAndThenđể xây dựng mong muốn của chúng tôi Collectorbằng cách

1. Thu thập các đối tượng của chúng tôi trong một Listvới các Collectors.toList()nhà sưu tập.
2. Áp dụng một bộ hoàn thiện bổ sung vào cuối, trả về phần tử đơn - hoặc ném IllegalStateExceptionif list.size != 1.

Được dùng như:

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

Sau đó, bạn có thể tùy chỉnh điều này Collectornhiều như bạn muốn, ví dụ đưa ra ngoại lệ làm đối số trong hàm tạo, điều chỉnh nó để cho phép hai giá trị và hơn thế nữa.

Một giải pháp thay thế - được cho là kém thanh lịch -:

Bạn có thể sử dụng một 'cách giải quyết' liên quan peek()và một AtomicInteger, nhưng thực sự bạn không nên sử dụng nó.

Những gì bạn có thể làm istead chỉ là thu thập nó trong một List, như thế này:

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

Để hoàn thiện, đây là 'một lớp lót' tương ứng với câu trả lời xuất sắc của @ prunge:

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

Điều này có được yếu tố phù hợp duy nhất từ ​​luồng, ném

• NoSuchElementException trong trường hợp luồng trống, hoặc
• IllegalStateException trong trường hợp luồng chứa nhiều phần tử khớp.

Một biến thể của phương pháp này sẽ tránh đưa ra một ngoại lệ sớm và thay vào đó biểu thị kết quả là một Optionalphần tử duy nhất hoặc không có gì (trống) nếu không có hoặc có nhiều phần tử:

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

Các câu trả lời khác liên quan đến việc viết một tùy chỉnh Collectorcó thể hiệu quả hơn (chẳng hạn như Louis Wasserman , +1), nhưng nếu bạn muốn ngắn gọn, tôi đề nghị như sau:

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

Sau đó xác minh kích thước của danh sách kết quả.

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

Quả ổi cung cấp MoreCollectors.onlyElement()những gì đúng ở đây. Nhưng nếu bạn phải tự làm điều đó, bạn có thể tự mình Collectorlàm điều này:

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

... hoặc sử dụng Holderloại của riêng bạn thay vì AtomicReference. Bạn có thể tái sử dụng Collectorbao nhiêu tùy thích.

Sử dụng ổi MoreCollectors.onlyElement()( JavaDoc ).

Nó thực hiện những gì bạn muốn và ném IllegalArgumentExceptionnếu luồng bao gồm hai hoặc nhiều phần tử và NoSuchElementExceptionnếu luồng trống.

Sử dụng:

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

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

Hoạt động "thoát nở" cho phép bạn thực hiện những điều kỳ lạ không được luồng hỗ trợ khác là yêu cầu 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();
}

Quả ổi có một phương pháp tiện lợi để lấy Iteratorvà lấy phần tử duy nhất, ném nếu có 0 hoặc nhiều phần tử, có thể thay thế các dòng n-1 dưới cùng ở đây.

Cập nhật

Đề xuất đẹp trong nhận xét từ @Holger:

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

Câu trả lời gốc

Ngoại lệ được đưa ra Optional#get, nhưng nếu bạn có nhiều hơn một yếu tố sẽ không giúp ích. Bạn có thể thu thập người dùng trong một bộ sưu tập chỉ chấp nhận một mục, ví dụ:

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

Nó ném một java.lang.IllegalStateException: Queue full, nhưng điều đó cảm thấy quá hack.

Hoặc bạn có thể sử dụng giảm kết hợp với tùy chọn:

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

Việc giảm về cơ bản trả về:

• null nếu không tìm thấy người dùng
• người dùng nếu chỉ tìm thấy một
• ném một ngoại lệ nếu tìm thấy nhiều hơn một

Kết quả sau đó được bọc trong một tùy chọn.

Nhưng giải pháp đơn giản nhất có lẽ là chỉ thu thập vào một bộ sưu tập, kiểm tra xem kích thước của nó là 1 và lấy phần tử duy nhất.

Một cách khác là sử dụng rút gọn: (ví dụ này sử dụng chuỗi nhưng có thể dễ dàng áp dụng cho bất kỳ loại đối tượng nào bao gồm 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);};
}

Vì vậy, đối với trường hợp với Userbạn sẽ có:

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

Sử dụng giảm

Đây là cách đơn giản và linh hoạt hơn mà tôi tìm thấy (dựa trên câu trả lời @prunge)

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

Bằng cách này bạn có được:

• Tùy chọn - như mọi khi với đối tượng của bạn hoặc Optional.empty() nếu không có
• Ngoại lệ (cuối cùng là loại / thông báo tùy chỉnh CỦA BẠN) nếu có nhiều hơn một yếu tố

Tôi nghĩ cách này đơn giản hơn:

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

Sử dụng một 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()
    );
}

Sử dụng:

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

Chúng tôi trả lại một Optional, vì chúng tôi thường không thể giả sử Collectioncó chứa chính xác một yếu tố. Nếu bạn đã biết đây là trường hợp, hãy gọi:

User user = result.orElseThrow();

Điều này đặt gánh nặng xử lý lỗi lên người gọi - như thường lệ.

Quả ổi có cái Collectornày gọi là MoreCollectors.onlyElement().

Chúng tôi có thể sử dụng RxJava ( thư viện mở rộng phản ứng rất mạnh )

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

Các đơn điều hành ném một ngoại lệ nếu không có người dùng hoặc sau đó thêm một người dùng được tìm thấy.

Vì Collectors.toMap(keyMapper, valueMapper)sử dụng một sự hợp nhất ném để xử lý nhiều mục với cùng một khóa, thật dễ dàng:

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

Bạn sẽ nhận được một IllegalStateExceptionkhóa trùng lặp. Nhưng cuối cùng, tôi không chắc liệu mã có thể dễ đọc hơn nữa hay không if.

Tôi đang sử dụng hai bộ sưu tập đó:

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

Nếu bạn không phiền khi sử dụng thư viện của bên thứ 3, SequenceMtừ các luồng cyclops (và LazyFutureStreamtừ phản ứng đơn giản ), cả hai đều có các toán tử đơn & đơn lẻ.

singleOptional()ném một ngoại lệ nếu có 0hoặc nhiều hơn 1các phần tử trong Stream, nếu không, nó sẽ trả về giá trị đơn.

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()trả về Optional.empty()nếu không có giá trị hoặc nhiều hơn một giá trị trong 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

Tiết lộ - Tôi là tác giả của cả hai thư viện.

Tôi đã đi với cách tiếp cận trực tiếp và chỉ thực hiện điều:

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


} 

với bài kiểm tra 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<>());
}

}

Việc thực hiện này không an toàn.

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

Bạn đã thử cái này chưa

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.

Nguồn: https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html