Alternative to new method to avoid duplicating code

user_1039920 0
Viewed 107

I would like to apply the same operations to different streams (using Java 8 at the moment)

Background: I am trying to get dimension data out of a Tika Metadata object

The following works but repeats code (metadata is a Tika Metadata object):

    private static void processDimensions(final Metadata metadata) {
        Optional<Integer> optWidth = Arrays.stream(new String[] {"tiff:ImageWidth", "Image Width"})
                .map(metadata::get)
                .filter(Objects::nonNull)
                .map(v -> v.replace("pixels", ""))
                .map(Integer::parseInt).findFirst();
        // do something with optWidth

        Optional<Integer> optHeight = Arrays.stream(new String[] {"tiff:ImageLength", "Image Height"})
                .map(metadata::get)
                .filter(Objects::nonNull)
                .map(v -> v.replace("pixels", ""))
                .map(Integer::parseInt).findFirst();
        // do something with optHeight
    }

I have gotten to this point which does not repeat code: 

    private static void processDimensions(final Metadata metadata) {
        Optional<Integer> optWidth = processDimension(metadata, "tiff:ImageWidth", "Image Width");
        // do something with optWidth

        Optional<Integer> optHeight = processDimension(metadata, "tiff:ImageLength", "Image Height");
        // do something with optHeight
    }

    private static Optional<Integer> processDimension(final Metadata metadata, @NonNull final String... keys) {
        return Arrays.stream(keys).map(metadata::get).filter(Objects::nonNull).map(v -> v.replace("pixels", ""))
                .map(Integer::parseInt).findFirst();
    }

Is it possible to do this same thing without a separate method such as a Function inside processDimensions()? How would that look?

java-stream java
2 Answers

Yes declare it as a java.util.Function and reuse it.

Function<String[], OptionalInt> funct = keys -> Arrays.stream(keys)
    .map(metadata::get)
    .filter(Objects::nonNull)
    .map(v -> v.replace("pixels", ""))
    .mapToInt(Integer::parseInt)
    .findFirst();

Here's how you call it.

funct.apply(strArr);

In fact, declaring a method gives a much more readable name such as processDimensions and you declare parameter types with more descriptive names than a lambda, hence it is much more readable to me. Unless you are well versed with streams, you may find hard time reading this pipeline. Moreover, a method defines a de facto API, but a stream pipeline usually doesn't.

user_41085900

Would something like this work?

        private static Optional<Integer> processDimension(final Metadata, dim) {
            return Arrays.stream(new String[] {"tiff:Image" + dim, "Image " + dim})
                    .map(metadata::get)
                    .filter(Objects::nonNull)
                    .map(v -> v.replace("pixels", ""))
                    .map(Integer::parseInt).findFirst();
        }

And call it like so.

        int width = processDimension(metadata, "Width").get();
        int height = processDimension(metadata, "Height").get();

You may want to use a different method to retrieve the optional to provide a default.

user_15525340
Related