Kiểu chức năng của Java 8. Tùy chọn.ifPftime và if-not-Present?

Trong Java 8, tôi muốn làm một cái gì đó cho một Optionalđối tượng nếu nó có mặt và làm một điều khác nếu nó không có mặt.

if (opt.isPresent()) {
  System.out.println("found");
} else {
  System.out.println("Not found");
}

Đây không phải là một "phong cách chức năng", mặc dù.

Optionalcó một ifPresent()phương thức, nhưng tôi không thể xâu chuỗi một orElse()phương thức.

Vì vậy, tôi không thể viết:

opt.ifPresent( x -> System.out.println("found " + x))
   .orElse( System.out.println("NOT FOUND"));

Trả lời @assylias, tôi không nghĩ sẽ Optional.map()hoạt động cho trường hợp sau:

opt.map( o -> {
  System.out.println("while opt is present...");
  o.setProperty(xxx);
  dao.update(o);
  return null;
}).orElseGet( () -> {
  System.out.println("create new obj");
  dao.save(new obj);
  return null;
});

Trong trường hợp này, khi optcó mặt, tôi cập nhật thuộc tính của nó và lưu vào cơ sở dữ liệu. Khi nó không có sẵn, tôi tạo một cái mới objvà lưu vào cơ sở dữ liệu.

Lưu ý trong hai lambdas tôi phải trở lại null.

Nhưng khi optcó mặt, cả hai lambdas sẽ bị xử tử. objsẽ được cập nhật và một đối tượng mới sẽ được lưu vào cơ sở dữ liệu. Điều này là do return nulltrong lambda đầu tiên. Và orElseGet()sẽ tiếp tục thực thi.

Đối với tôi câu trả lời của @Dane White là OK, đầu tiên tôi không thích sử dụng Runnable nhưng tôi không thể tìm thấy bất kỳ lựa chọn thay thế nào, ở đây một triển khai khác tôi thích hơn

public class OptionalConsumer<T> {
    private Optional<T> optional;

    private OptionalConsumer(Optional<T> optional) {
        this.optional = optional;
    }

    public static <T> OptionalConsumer<T> of(Optional<T> optional) {
        return new OptionalConsumer<>(optional);
    }

    public OptionalConsumer<T> ifPresent(Consumer<T> c) {
        optional.ifPresent(c);
        return this;
    }

    public OptionalConsumer<T> ifNotPresent(Runnable r) {
        if (!optional.isPresent()) {
            r.run();
        }
        return this;
    }
}

Sau đó :

Optional<Any> o = Optional.of(...);
OptionalConsumer.of(o).ifPresent(s ->System.out.println("isPresent "+s))
            .ifNotPresent(() -> System.out.println("! isPresent"));

Cập nhật 1:

giải pháp trên cho cách phát triển truyền thống khi bạn có giá trị và muốn xử lý nó, nhưng nếu tôi muốn xác định chức năng và thực thi thì sẽ thế nào, hãy kiểm tra nâng cao bên dưới;

public class OptionalConsumer<T> implements Consumer<Optional<T>> {
private final Consumer<T> c;
private final Runnable r;

public OptionalConsumer(Consumer<T> c, Runnable r) {
    super();
    this.c = c;
    this.r = r;
}

public static <T> OptionalConsumer<T> of(Consumer<T> c, Runnable r) {
    return new OptionalConsumer(c, r);
}

@Override
public void accept(Optional<T> t) {
    if (t.isPresent()) {
        c.accept(t.get());
    }
    else {
        r.run();
    }
}

Sau đó có thể được sử dụng như:

    Consumer<Optional<Integer>> c=OptionalConsumer.of(System.out::println, ()->{System.out.println("Not fit");});
    IntStream.range(0, 100).boxed().map(i->Optional.of(i).filter(j->j%2==0)).forEach(c);

Trong mã mới này, bạn có 3 điều:

1. có thể xác định chức năng trước khi tồn tại của đối tượng dễ dàng.
2. không tạo sự điều chỉnh đối tượng cho mỗi Tùy chọn, chỉ có một, bạn có ít bộ nhớ hơn nên ít GC hơn.
3. nó đang thực hiện cho người tiêu dùng để sử dụng tốt hơn với các thành phần khác.

bằng cách bây giờ tên của nó được mô tả nhiều hơn nó thực sự là người tiêu dùng>

Nếu bạn đang sử dụng Java 9+, bạn có thể sử dụng ifPresentOrElse()phương thức:

opt.ifPresentOrElse(
   value -> System.out.println("Found: " + value),
   () -> System.out.println("Not found")
);

Giới thiệu Java 9

ifPftimeOrElse nếu có một giá trị, thực hiện hành động đã cho với giá trị, nếu không thì thực hiện hành động dựa trên trống đã cho.

Xem tùy chọn tuyệt vời trong bảng cheat Java 8 .

Nó cung cấp tất cả các câu trả lời cho hầu hết các trường hợp sử dụng.

Tóm tắt ngắn gọn dưới đây

ifPftime () - làm một cái gì đó khi Tùy chọn được đặt

opt.ifPresent(x -> print(x)); 
opt.ifPresent(this::print);

bộ lọc () - từ chối (lọc ra) một số giá trị tùy chọn.

opt.filter(x -> x.contains("ab")).ifPresent(this::print);

map () - biến đổi giá trị nếu có

opt.map(String::trim).filter(t -> t.length() > 1).ifPresent(this::print);

orElse () / orElseGet () - biến trống Tùy chọn thành T mặc định

int len = opt.map(String::length).orElse(-1);
int len = opt.
    map(String::length).
    orElseGet(() -> slowDefault());     //orElseGet(this::slowDefault)

orElseThrow () - ném ngoại lệ một cách lười biếng vào tùy chọn trống

opt.
filter(s -> !s.isEmpty()).
map(s -> s.charAt(0)).
orElseThrow(IllegalArgumentException::new);

Một thay thế là:

System.out.println(opt.map(o -> "Found")
                      .orElse("Not found"));

Tôi không nghĩ rằng nó cải thiện khả năng đọc mặc dù.

Hoặc như Marko đề xuất, hãy sử dụng toán tử ternary:

System.out.println(opt.isPresent() ? "Found" : "Not found");

Một giải pháp khác là sử dụng các hàm bậc cao hơn như sau

opt.<Runnable>map(value -> () -> System.out.println("Found " + value))
   .orElse(() -> System.out.println("Not Found"))
   .run();

Không có cách nào hay để làm điều đó. Nếu bạn muốn sử dụng cú pháp sạch hơn một cách thường xuyên, thì bạn có thể tạo một lớp tiện ích để trợ giúp:

public class OptionalEx {
    private boolean isPresent;

    private OptionalEx(boolean isPresent) {
        this.isPresent = isPresent;
    }

    public void orElse(Runnable runner) {
        if (!isPresent) {
            runner.run();
        }
    }

    public static <T> OptionalEx ifPresent(Optional<T> opt, Consumer<? super T> consumer) {
        if (opt.isPresent()) {
            consumer.accept(opt.get());
            return new OptionalEx(true);
        }
        return new OptionalEx(false);
    }
}

Sau đó, bạn có thể sử dụng nhập tĩnh ở nơi khác để nhận cú pháp gần với nội dung bạn đang theo sau:

import static com.example.OptionalEx.ifPresent;

ifPresent(opt, x -> System.out.println("found " + x))
    .orElse(() -> System.out.println("NOT FOUND"));

Nếu bạn chỉ có thể sử dụng Java 8 trở xuống:

1) nếu bạn không có spring-datacách tốt nhất cho đến nay là:

opt.<Runnable>map(param -> () -> System.out.println(param))
      .orElse(() -> System.out.println("no-param-specified"))
      .run();

Bây giờ tôi biết nó không dễ đọc và thậm chí khó hiểu đối với ai đó, nhưng cá nhân tôi có vẻ ổn và tôi không thấy một cách trôi chảy tốt đẹp nào khác cho trường hợp này.

2) nếu bạn đủ may mắn và bạn có thể sử dụng spring-datacách tốt nhất là Tùy chọn # ifPftimeOrElse :

Optionals.ifPresentOrElse(opt, System.out::println,
      () -> System.out.println("no-param-specified"));

Nếu bạn có thể sử dụng Java 9, bạn chắc chắn nên sử dụng:

opt.ifPresentOrElse(System.out::println,
      () -> System.out.println("no-param-specified"));

Hành vi được mô tả có thể đạt được bằng cách sử dụng Vavr (trước đây gọi là Javaslang), một thư viện chức năng đối tượng cho Java 8+, thực hiện hầu hết các cấu trúc Scala (là Scala một ngôn ngữ biểu cảm hơn với hệ thống kiểu giàu hơn được xây dựng trên JVM). Đây là một thư viện rất tốt để thêm vào các dự án Java của bạn để viết mã chức năng thuần túy.

Vavr cung cấp các Optionđơn vị cung cấp các chức năng để làm việc với loại Tùy chọn, chẳng hạn như:

• fold: để ánh xạ giá trị của tùy chọn trên cả hai trường hợp (được xác định / trống)
• onEmpty: cho phép thực thi Runnabletùy chọn khi trống
• peek: cho phép tiêu thụ giá trị của tùy chọn (khi được xác định).
• và nó cũng Serializabletrái ngược với Optionalđiều đó có nghĩa là bạn có thể sử dụng nó một cách an toàn như là đối số phương thức và thành viên thể hiện.

Tùy chọn tuân theo các luật đơn nguyên khác với "giả đơn nguyên" tùy chọn của Java và cung cấp API phong phú hơn. Và tất nhiên, bạn có thể làm cho nó từ Tùy chọn của Java (và theo cách khác): Option.ofOptional(javaOptional)EDVavr tập trung vào khả năng tương tác.

Đi đến ví dụ:

// AWESOME Vavr functional collections (immutable for the gread good :)
// fully convertible to Java's counterparts.
final Map<String, String> map = Map("key1", "value1", "key2", "value2");

final Option<String> opt = map.get("nonExistentKey"); // you're safe of null refs!

final String result = opt.fold(
        () -> "Not found!!!",                // Option is None
        val -> "Found the value: " + val     // Option is Some(val)
);

đọc thêm

Tài liệu tham khảo vô nghĩa, sai lầm tỷ đô

NB Đây chỉ là một ví dụ rất nhỏ về những gì Vavr cung cấp (khớp mẫu, các luồng hay các danh sách đánh giá lười biếng, các loại đơn âm, các bộ sưu tập không thay đổi, ...).

Một giải pháp khác có thể là sau:

Đây là cách bạn sử dụng nó:

    final Opt<String> opt = Opt.of("I'm a cool text");
    opt.ifPresent()
        .apply(s -> System.out.printf("Text is: %s\n", s))
        .elseApply(() -> System.out.println("no text available"));

Hoặc trong trường hợp bạn trong trường hợp sử dụng ngược lại là đúng:

    final Opt<String> opt = Opt.of("This is the text");
    opt.ifNotPresent()
        .apply(() -> System.out.println("Not present"))
        .elseApply(t -> /*do something here*/);

Đây là thành phần:

1. Giao diện hàm ít được sửa đổi, chỉ dành cho phương thức "otherApply"
2. Tăng cường tùy chọn
3. Một chút dòng chảy :-)

Giao diện Chức năng nâng cao "thẩm mỹ".

@FunctionalInterface
public interface Fkt<T, R> extends Function<T, R> {

    default R elseApply(final T t) {
        return this.apply(t);
    }

}

Và lớp bao bọc tùy chọn để tăng cường:

public class Opt<T> {

    private final Optional<T> optional;

    private Opt(final Optional<T> theOptional) {
        this.optional = theOptional;
    }

    public static <T> Opt<T> of(final T value) {
        return new Opt<>(Optional.of(value));
    }

    public static <T> Opt<T> of(final Optional<T> optional) {
        return new Opt<>(optional);
    }

    public static <T> Opt<T> ofNullable(final T value) {
        return new Opt<>(Optional.ofNullable(value));
    }

    public static <T> Opt<T> empty() {
        return new Opt<>(Optional.empty());
    }

    private final BiFunction<Consumer<T>, Runnable, Void> ifPresent = (present, notPresent) -> {
        if (this.optional.isPresent()) {
            present.accept(this.optional.get());
        } else {
            notPresent.run();
        }
        return null;
    };

   private final BiFunction<Runnable, Consumer<T>, Void> ifNotPresent = (notPresent, present) -> {
        if (!this.optional.isPresent()) {
            notPresent.run();
        } else {
            present.accept(this.optional.get());
        }
        return null;
    };

    public Fkt<Consumer<T>, Fkt<Runnable, Void>> ifPresent() {
        return Opt.curry(this.ifPresent);
    }

    public Fkt<Runnable, Fkt<Consumer<T>, Void>> ifNotPresent() {
        return Opt.curry(this.ifNotPresent);
    }

    private static <X, Y, Z> Fkt<X, Fkt<Y, Z>> curry(final BiFunction<X, Y, Z> function) {
        return (final X x) -> (final Y y) -> function.apply(x, y);
    }
}

Điều này sẽ thực hiện các mẹo và có thể phục vụ như một khuôn mẫu cơ bản để đối phó với các yêu cầu như vậy.

Ý tưởng cơ bản ở đây là sau đây. Trong một thế giới lập trình kiểu không có chức năng, có lẽ bạn sẽ thực hiện một phương thức lấy hai tham số trong đó đầu tiên là một loại mã có thể chạy được nên được thực thi trong trường hợp giá trị có sẵn và tham số khác là mã có thể chạy được trong trường hợp giá trị không có sẵn. Để dễ đọc hơn, bạn có thể sử dụng dòng điện để phân chia chức năng của hai tham số trong hai chức năng của một tham số. Đây là những gì tôi về cơ bản đã làm ở đây.

Gợi ý: Opt cũng cung cấp trường hợp sử dụng khác trong đó bạn muốn thực thi một đoạn mã chỉ trong trường hợp giá trị không có sẵn. Điều này cũng có thể được thực hiện thông qua Options.filter. Ware nhưng tôi thấy điều này dễ đọc hơn nhiều.

Mong rằng sẽ giúp!

Lập trình tốt :-)

Trong trường hợp bạn muốn lưu trữ giá trị:

Pair.of<List<>, List<>> output = opt.map(details -> Pair.of(details.a, details.b))).orElseGet(() -> Pair.of(Collections.emptyList(), Collections.emptyList()));

Giả sử rằng bạn có một danh sách và tránh isPresent() (liên quan đến các tùy chọn) bạn có thể sử dụng .iterator().hasNext()để kiểm tra nếu không có mặt.