Modern Java for the Modern Age by Nick Maiorano

Classic Java is the language that won the world over 23 years ago. It’s what made it rise to the top of the heap of languages. But it’s not without its flaws. Classic Java is characterized by boiler-plated code - the copy/pasting of code with small variances throughout the code base. Boiler-plating is not something developers aspire to but rather the outcome of a language that lacks expressiveness. Another side-effect of boiler-plating is verbosity. It too is a symptom of a language that lacks constructs. When a language is verbose, it takes more lines of code to achieve the same functionality than it normally should. This can hurt maintainability and diminish quality. Classic Java is also dominantly object-oriented in structure and imperative in algorithmic style. While both of these are still generally useful today, Classic Java is sorely lacking in the more modern styles of functional and declarative programming, which are better suited to solve today’s stringent software requirements. Classic Java developers are therefore more limited in the tools at their disposal. 

 

 

 

 

 

Finally, Java Streams library allows algorithms to be coded declaratively meaning the developer specifies what they want, not how they want it. This improves code quality because all the plumbing code is handled by the library itself. The fluent interface style is just a way to express streams algorithm in one continuous line.

 

 

//Find palindromes - Classic Java

private static List < String > findPalindromeClassic(List < String > list) {
    List < String > palindromes = new ArrayList < > ();
    for (String nextWord: list) {
        String originalString = nextWord;
        nextWord = nextWord.toLowerCase();
        nextWord = nextWord.replace(" ", "");
        nextWord = nextWord.replace(",", "");
        nextWord = nextWord.replace("'", "");
        boolean isPalindrome = true;
        int halfWay = nextWord.length() / 2 - 1;
        for (int index = 0; index < halfWay; ++index) {
            if (nextWord.charAt(index) != nextWord.charAt(nextWord.length() - index - 1)) {
                isPalindrome = false;
                break;
            }
        }
        if (isPalindrome) {
            palindromes.add(originalString);
        }
    }
    return palindromes;
}

Figure 1: Find palindromes - Classic Java

 

//Find palindromes - Modern Java

private static List < String > findPalindromeModern(List < String > list) {
    BiFunction < String[], String, String[] > replacer =
        (h, s) - > {
            h[1] = h[1].replace(s, "");
            return h;
        };
    return list.stream().
    map(s - > {
        String[] h = new String[2];h[0] = h[1] = s;
        return h;
    }).
    map(h - > replacer.apply(h, " ")).
    map(h - > replacer.apply(h, ",")).
    map(h - > replacer.apply(h, "'")).
    map(h - > {
        h[1] = h[1].toLowerCase();
        return h;
    }).
    filter(h - > h[1].length() > 2).
    filter(h - > {
        int halfWay = h[1].length() / 2 - 1;
        return IntStream.rangeClosed(0, halfWay).
        allMatch(i - > h[1].charAt(i) == h[1].charAt(h[1].length() - i - 1));
    }).
    map(h - > h[0]).
    collect(Collectors.toList());
}

Figure 2: Find palindromes - Modern Java

 

Based on the experience in my own consulting practice, I can attest to the challenges they face.  Leveraging Modern Java requires more than just a Java upgrade. Developers must learn to think differently – and there is a steep learning curve. There are the new programming paradigms to understand and knowing how to apply these ideas is not trivial. 

 

 

 

 

 

[1] Source: TIOBE Index, from a survey of 258 Turing-complete programming languages.

[2] As surveyed by Java Magazine published in October 2018

Nick Maiorano is the author of “Functional Java: A Guide to Lambdas and Functional Programming in Java 8” as well as the LinkedIn learning’s “Learning Java 9 Modularity”. He is a software architect and has been developing with Java since the 1990’s. He has also been a Java-based technology instructor at ProTech for four years.