En Option avec des Flux en Java

J'essayais de revoir un vieux code à utiliser les flux, et ma première approche a été ceci:

public void run() throws IOException {
   Files.list(this.source)
        .filter(Images::isImage)
        .map(Image::new)
        .filter(image -> image.isProportional(this.height, this.width))
        .map(image -> image.resize(this.height, this.width))
        .forEach(image -> Images.write(image, this.destination));
}

Ce n'est pas la compilation depuis new Image() et des Images.write() throws IOExceptions.

Emballage de ces exceptions avec UncheckedIOException ne ferais pas le truc que je ne veux pas arrêter d'autres images à traiter si l'un d'entre eux tombe en panne.

Alors j'ai fini l'écriture de 2 méthodes privées:

private Optional<Image> createImage(Path imagePath) {
    try {
        return Optional.of(new Image(imagePath));
    } catch (IOException e) {
        return Optional.empty();
    }
}

private void write(Image image) {
    try {
        Images.write(image, this.destination);
    } catch (IOException e) {
        //log error
    }
}

createImage() retourne une Option puisque cela semble raisonnable. Cependant, après ce que mon code s'est vraiment laid:

public void run() throws IOException {
    Files.list(source)
         .filter(Images::isImage)
         .map(this::createImage)
         .filter(image -> image.isPresent() && image.get().isProportional(this.height, this.width))
         .map(image -> image.get().resize(this.height, this.width))
         .forEach(this::write);
}

Est-il un moyen d'éviter l'utilisation de get() et isPresent() sur ce code?

Merci!

OriginalL'auteur gaijinco | 2014-06-17

  1. 16

    Une des belles choses sur les Options c'est que l'application du filtrage, de la cartographie et de la plate-fonctions de cartographie sur eux ne se déclenchera que lorsque Facultatif::isPresent est vrai, donc:

    public void run() throws IOException {
    Files.list(source)
         .filter(Images::isImage)
         .map(this::createImage)
         //turns every non-proportional Optional<Image> into empty optionals
         .map(image -> image.filter(i -> i.isProportional(this.height, this.width)))
         //resizes every proportional Optional<Image>, while doing nothing on the empties
         .map(image -> image.map(i -> i.resize(this.height, this.width)))
         //applies the writing consumer for each non-empty Optional<Image>
         .forEach(image -> image.ifPresent(this::write));
}

    Une autre façon est d'appeler uniquement en Option::isPresent et Facultatif::séparer les Flux de transformations:

    public void run() throws IOException {
    Files.list(source)
         .filter(Images::isImage)
         .map(this::createImage)
         //filter out the empty optionals
         .filter(Optional::isPresent)
         //replace every optional with its contained value
         .map(Optional::get)
         .filter(image -> image.isProportional(this.height, this.width))
         .map(image -> image.resize(this.height, this.width))
         .forEach(this::write);
}

    Encore une autre façon (que je me refuse à le recommander comme une solution de premier choix en raison de sa relative étrangeté) est de changer l'image statique méthode de création dans un générateur de Flux, au lieu d'une Option de générateur, afin de profiter de flatMap:

    private Stream<Image> createImage(Path imagePath) {
    try {
        return Stream.of(new Image(imagePath));
    } catch (IOException e) {
        return Stream.empty();
    }
}

public void run() throws IOException {
    Files.list(source)
         .filter(Images::isImage)
         //inserts into the stream the resulting image (empty streams are handled seamlessly)
         .flatMap(this::createImage)
         .filter(image -> image.isProportional(this.height, this.width))
         .map(image -> image.resize(this.height, this.width))
         .forEach(this::write);
}

    Sur la deuxième pensée, aller avec cette solution, il semble être plus simple, et puisque la méthode statique est privé de toute façon, moins de cris de la fin les utilisateurs, les autres développeurs, et des gens au hasard avec un accès décent à Java 8 décompilation (http://www.benf.org/other/cfr/).

    OriginalL'auteur srborlongan