Xử lý các ngoại lệ với các luồng

Tôi có một Map<String,List<String>>và muốn nó biến thành Map<String,List<Long>>vì mỗi Stringtrong danh sách đại diện cho một Long:

Map<String,List<String>> input = ...;
Map<String,List<Long>> output= 
input.entrySet()
       .stream()
       .collect(toMap(Entry::getKey, e -> e.getValue().stream()
                                                      .map(Long::valueOf)
                                                      .collect(toList()))
               );

Vấn đề chính của tôi là mỗi Stringcó thể không đại diện chính xác a Long; có thể có một số vấn đề. Long::valueOfcó thể đưa ra ngoại lệ. Nếu đây là trường hợp, tôi muốn trả về null hoặc rỗngMap<String,List<Long>>

Bởi vì tôi muốn lặp đi lặp lại sau outputbản đồ này . Nhưng tôi không thể chấp nhận bất kỳ chuyển đổi lỗi nào; thậm chí không một ai Bất kỳ ý tưởng nào về cách tôi có thể trả về một đầu ra trống trong trường hợp Chuỗi không chính xác -> Chuyển đổi dài?

Làm thế nào về một rõ ràng catchvề ngoại lệ:

private Map<String, List<Long>> transformInput(Map<String, List<String>> input) {
    try {
        return input.entrySet()
                .stream()
                .collect(Collectors.toMap(Map.Entry::getKey, e -> e.getValue().stream()
                        .map(Long::valueOf)
                        .collect(Collectors.toList())));
    } catch (NumberFormatException nfe) {
        // log the cause
        return Collections.emptyMap();
    }
}

Cá nhân tôi muốn cung cấp một Optionalđầu vào xung quanh phân tích số:

public static Optional<Long> parseLong(String input) {
    try {
        return Optional.of(Long.parseLong(input));
    } catch (NumberFormatException ex) {
        return Optional.empty();
    }
}

Sau đó, sử dụng mã của riêng bạn (và bỏ qua đầu vào xấu):

Map<String,List<String>> input = ...;
Map<String,List<Long>> output= 
input.entrySet()
       .stream()
       .collect(toMap(Entry::getKey, e -> e.getValue().stream()
                                                      .map(MyClass::parseLong)
                                                      .filter(Optional::isPresent)
                                                      .map(Optional::get)
                                                      .collect(toList()))
               );

Ngoài ra, hãy xem xét một phương pháp trợ giúp để làm cho điều này ngắn gọn hơn:

public static List<Long> convertList(List<String> input) {
    return input.stream()
        .map(MyClass::parseLong).filter(Optional::isPresent).map(Optional::get)
        .collect(Collectors.toList());
}

public static List<Long> convertEntry(Map.Entry<String, List<String>> entry) {
    return MyClass.convertList(entry.getValue());
}

Sau đó, bạn có thể lọc kết quả trong trình thu thập luồng của mình:

Map<String, List<Long>> converted = input.entrySet().stream()
    .collect(Collectors.toMap(Entry::getKey, MyClass::convertEntry));

Bạn cũng có thể giữ các Optionalđối tượng trống trong danh sách của mình và sau đó bằng cách so sánh chỉ mục của chúng trong mới List<Optional<Long>>(thay vì List<Long>) với bản gốc List<String>, bạn có thể tìm thấy chuỗi gây ra bất kỳ đầu vào sai lầm nào. Bạn cũng có thể chỉ cần đăng nhập những thất bại này trongMyClass#parseLong

Tuy nhiên, nếu mong muốn của bạn là không hoạt động trên bất kỳ đầu vào xấu nào , thì xung quanh toàn bộ luồng trong những gì bạn đang cố gắng nắm bắt (theo câu trả lời của Naman) là con đường tôi sẽ đi.

Bạn có thể tạo một StringBuilderkhóa for với ngoại lệ và kiểm tra xem có phải elelà số như dưới đây không,

 public static Map<String, List<Long>> transformInput(Map<String, List<String>> input) {
    StringBuilder sb = new StringBuilder();
    try {
    return input.entrySet()
            .stream()
            .collect(Collectors.toMap(Map.Entry::getKey, e -> e.getValue().stream()
                    .map(ele->{
                        if (!StringUtils.isNumeric(ele)) {
                            sb.append(e.getKey()); //add exception key
                            throw new NumberFormatException();
                        }
                        return Long.valueOf(ele);
                    })
                    .collect(Collectors.toList())));
} catch (NumberFormatException nfe) {
    System.out.println("Exception key "+sb);
    return Collections.emptyMap();
}
}

Hy vọng nó giúp.

Có thể bạn có thể viết một phương thức trợ giúp có thể kiểm tra số trong chuỗi và lọc chúng ra khỏi luồng và cả các giá trị null sau đó cuối cùng thu thập vào Bản đồ.

// StringUtils.java
public static boolean isNumeric(String string) {
    try {
        Long.parseLong(string);
        return true;
    } catch(NumberFormatException e) {
        return false;
    }
}

Điều này sẽ chăm sóc tất cả mọi thứ.

Và sử dụng điều này trong luồng của bạn.

Map<String, List<Long>> newMap = map.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, entry -> mapToLongValues(entry.getValue())));

public List<Long> mapToLongValues(List<String> strs) {
    return strs.stream()
        .filter(Objects::nonNull)
        .filter(StringUtils::isNumeric)
        .map(Long::valueOf)
        .collect(Collectors.toList());
}