List processing to understand with pictures --java8 stream / javaslang --bonus

Other than when you want to pair ʻA and B, for example, when you want to know the size of each gap in the list of ʻInteger, try zip by shifting the same list by one. There is a way.

List<Integer> times = List.of(10, 15, 35, 60); //this[15 - 10, 35 - 15, 60 - 35]Want to

times
    .zip(times.subSequence(1))
    .map(t -> t._2 - t._1);                    // [5, 20, 25]

Do you use reduce when you think about processing from the beginning? You might think, but if you make a picture, it's completely different. (Reduce does not calculate with the neighbor, but calculates the sum (or) up to that point one by one, so the gap calculation cannot be straightforward.)

If you do filter and map well on a log file, zip, take the processing time difference for each line, and try reverse sort and takeWhile, the lines that take 500 ms or more are displayed in order of slowness. You can do it.

[Bonus-java8 stream / javaslang]: Benefits of map

There are definitely talks such as "I don't know the merits" and "Isn't it okay with for?", But of course there are merits that are worth the learning cost.

There are some, but I'll briefly list three.

1. You can separate the situation from what you want to do

For example, there is such a function of String-> Integer.

private static Integer toIntAndTwice(String s) {
    return Integer.valueOf(s) * 2;
}

The code that applies this function to "when there are multiple Strings "," when there is at most one String", and "when there is a String that may be malformed "is Become.

List example

List<Integer> result = List.empty();

List<String> org = ...; // List.of(1, 2, 3) or empty

for (String x : org) {
    result.append(toIntAndTwice(x));
}

return result;

ʻOption` example

Option<Integer> result;

Option<String> org = ...; // Option.of(1) or empty

if (org.isEmpty()) {
    result = Option.none();
} else {
    result = Option.of(toIntAndTwice(org.get()));
}

return result;

try example

Integer result;

String org = ...; // "1" or "x"

try {
    result = toIntAndTwice(org);
} catch (Throwable t) {
    result = null;
}

return result;

You have to write a completely different code to apply toIntAndTwice to String in a particular situation.

If you write this with map, it will be like this.

List example

List<String> org = ...;
List<Integer> mapped = org.map(JSMain::toIntAndTwice);
return mapped;

ʻOption` example

Option<String> org = ...;
Option<Integer> mapped = org.map(JSMain::toIntAndTwice);
return mapped;

Try example

Try<String> org = ...;
Try<Integer> mapped = org.map(JSMain::toIntAndTwice);
return mapped;

It looks the same! This is because "the rules of List and ʻOption in a specific situation" and "what you actually want to do ( toIntAndTwice`) "are separated, and the former is followed by the language.

By the way, if the code is similar so far, I feel that it can be made more common, right? Since List and ʻOption of javaslang inherit from Value`, you can also do this.

If you define such Value <T>-> Value <R>,

private static Value<Integer> mapAnyType(Value<String> org) {
    return org.map(JSMain::toIntAndTwice);
}

It works whether the argument is List or ʻOption`!

List example

Value<Integer> m1 = mapAnyType(List.of("1", "2", "3")); // List(2, 4, 6)

ʻOption` example

Value<Integer> m2 = mapAnyType(Option.none());          // None

Try example

Value<Integer> m3 = mapAnyType(Try.of(() -> "x"));      // Failure(java.lang.NumberFormatException: For input string: "x")

In this case, the same code can handle different situations, so for example, prepare a cancellation process for paid options, and have a" function to cancel all at once (List)" and a "function to cancel if you have one (ʻOption". ")" And "The function to cancel because you should have it ( Try) "can be realized at once.

I think the biggest merit is the separation of "situation" and "processing".

2. Temporary variables do not appear

Legacy code that everyone loves. This is common.

//Initialization
result = 0;
flag = false;

for (i ...) {
    result = ...;

    //Is ~ ~ finished?
    if (i < ...) {
        result = ...;
        flag = true;
    }

    //If it is ~~, it ends
    if (flag) {
        return result;
    }

    //Then loop with ~ ~
    for (j ...) {
        result = ...;

        //If it is ~~, it ends
        if (j < ...) {
            return result;
        }
    }
    //Initialization
    flag = false;
}

//return
return result;

The return result; in this code is the same as the text, but the contents are completely different. (Maybe, I don't even know.)

Since there is a context in the lines, you can not copy and paste only that line, and it seems that you are making blocks with comments, but in reality this is only one huge block.

If this looks like the code above, all three lines of the argument work independently, and there are no variables in the method scope that shouldn't be return. (Since there is one ;, this code is one line. Therefore, there can be no gap state.)

return cs.stream()
        .reduce(
                Optional.of(0),
                (acc, c) -> c == '(' ? acc.map(n -> n + 1) : acc.map(n -> n - 1).filter(n -> n >= 0),
                (acc1, acc2) -> acc1.flatMap(v1 -> acc2.map(v2 -> v1 + v2))
        ).equals(Optional.of(0));

I think that this is overwhelmingly more reusable and of higher quality. (Of course, if you do it with shared code, I think it's better to be a little more careful. The second argument should be named properly and the test code should be written lightly. I think the 3rd edition also said that.)

3. Utilize the experience of another language

I will touch on the details next, but the more you know the idea itself, the better it will be at first glance unless it is a special language.

If you learn java8 stream and go to ruby, you will be able to operate the list immediately, and even if you are new to java8, if you are experienced with python, you will be able to stream.

[Bonus]: Wordbook

As mentioned in the last-minute benefits, most languages have map, filter, reduce.

When you have to maintain a language you don't know in a hurry at work, or when you want to make some changes to the tools you picked up, all you need to know is the words and the processing image. So, at the end, I will end with a summary of how to do the same processing in the language you often hear.

(The part with (*) feels like you can do something similar if you use it well)

If you remember the words around map / collect, filter, reduce / fold / inject, most languages will work.

map vs collect and reduce vs inject may be interesting to look into.

end

If anyone has read this far, thank you.

It was good that the article was in time on the day I declared it. That's it.