book

Learning Java Functional Programming

Name: Learning Java Functional Programming
ISBN: 9781783558483

by Richard M Reese, Richard M. Reese

October 2015

Beginner to intermediate

296 pages

5h 56m

English

Packt Publishing

Read now

Unlock full access

Learning Java Functional Programming
Table of Contents
Learning Java Functional Programming
Credits
About the Author
About the Reviewers
www.PacktPub.com
Support files, eBooks, discount offers, and moreWhy subscribe?Free access for Packt account holders
Preface
What this book covers
What you need for this book
Who this book is for

Conventions
Reader feedback
Customer support
Downloading the example codeErrataPiracyQuestions
1. Getting Started with Functional Programming
Aspects of functional programmingFunctionsFunction compositionFluent interfacesStrict versus non-strict evaluationPersistent data structuresRecursionParallelismOptional and monads
Java 8's support for functional style programming
Lambda expressionsDefault methodsFunctional interfacesMethod and constructor referencesCollections
Summary
2. Putting the Function in Functional Programming
Lambda expressions usage
Functional programming concepts in Java
High-order functionsReturning a functionFirst-class functionsThe pure functionSupport repeated executionEliminating dependencies between functionsSupporting lazy evaluationReferential transparencyClosure in JavaCurrying
Lambda expressions revisited
Java 8 type inferenceException handling in lambda expressions
Functional interfaces revisited
Creating a functional interfaceCommon functional interfacesFunction-type functional interfacesPredicate-type functional interfacesConsumer-type functional interfacesSupplier-type functional interfacesOperator-type functional interfaces
Summary
3. Function Composition and Fluent Interfaces
Introduction to function composition
Creating composite functions prior to Java 8
Creating composite functions in Java 8
Using the Function interface for function compositionUsing the Functional interface to supplement methodsPassing instances of the Functional interface
Fluent interfaces
Fluent interfaces in Java 8Method chaining and cascadingContrasting method cascading and fluent interfacesCreating and using fluent interfacesUsing fluent interfaces to hide older interfaces/classesUsing fluent interfaces with the Properties classExtending fluent interfaces
Default methods and functions
Static default methodsDefault methods in Java 8Multiple inheritance in Java 8
Summary
4. Streams and the Evaluation of Expressions
The Stream class and its useIntermediate and terminal methods
Creating streams
Fixed length streamsInfinite streamsUsing the iterate method to create an infinite streamUsing the generate method to create an infinite stream
Using the Stream class methods
Filter methodsUsing the filter methodUsing the skip methodSorting streamsMapping methodsUnderstanding the mapping operationImplementing the map-reduce paradigmUsing the flatmap method
Lazy and eager evaluation
Stream and concurrent processing
Understanding non-inferenceUnderstanding stateless operationsUnderstanding side effectsUnderstanding the ordering
Summary
5. Recursion Techniques in Java 8
Recursive data structures
Types of recursion
Using direct recursionHead and tail recursion
Understanding recursion
The Node classUsing head recursionUsing tail recursionUsing the head and tail recursionCreating a recursive solution based on a formulaConverting an iterative loop to a recursive solutionMerging two listsUnderstanding the program stackRecursive lambda expressionsCommon problems found in recursive solutionsAbsence of a base caseUsing static or instance variablesUsing the pre- and post-increment operators
Recursion implementation techniques
Using a wrapper methodUsing short circuitingTail call optimizationConverting to a tail call
When to use recursion
Recursion and humor
Summary
6. Optional and Monads
Using the Optional classCreating Optional instancesUsing the Optional class to support return valuesHandling missing valuesUsing the orElse method to get a substitute valueUsing the orElseGet method to use a function to get a substitute valueUsing the orElseThrow method to throw an exceptionFilter and transforming valuesUsing the Optional class's filter methodUsing the Optional class's map methodOptional solution to the Customer problemDisadvantages of the Optional class
Monads
Monads in Java 8Using the of method as the unit functionUsing the flatMap methodUsing the map methodUsing the Optional class with stringsUsing monads with the Part classA formal discussion of monadsAssociativityLeft identityRight identity
Summary
7. Supporting Design Patterns Using Functional Programming
Implementing the execute-around-method patternObject-oriented solution to the execute-around-method patternFunctional solution to the execute-around-method patternUsing the execute-around-method pattern with a stream
Implementing the factory pattern
Object-oriented solution to the factory patternFunctional solution to the factory pattern
Implementing the command pattern
Object-oriented solution to the command patternFunctional solution to the command pattern
Implementing the strategy pattern
Object-oriented solution to strategy patternFunctional solution to the strategy patternUsing the Function interface
Implementing the visitor pattern
Object-orient solution to the visitor patternFunctional solution to the visitor pattern
Implementing the template pattern
Object-oriented solution to the template patternFunctional solution to the template pattern
Summary
8. Refactoring, Debugging, and Testing
Refactoring functional codeNetBeans support for refactoringConverting anonymous inner classes to lambda expressionsRefactoring multiple code instancesSupport of other refactoring operationsEclipse support for refactoringConverting anonymous inner classes to lambda expressionsRefactoring multiple code instancesSupport of other refactoring operations
Debugging lambda expressions
Using the println method to assist debugging
Using the peek method to assist debuggingDebugging lambda expressions using NetBeansDebugging lambda expressions using EclipseDebugging recursive lambda expressionsDebugging parallel streams
Testing functional programs
Testing lambda expressionsCopying the lambda expressionUsing a method referenceReorganizing the test classTesting exceptions using a fluent style
Summary
9. Bringing It All Together
Functional ZorkPlaying the game
The game's architecture
Understanding the GameElements classIntroducing the Item, Direction, and NPC classesImplementing the FunctionalZork classInitializing the gameInitializing the commandsGetting a command from the consoleParsing the commandExecuting the commandImplementing the Character classImplementing the pickup methodImplementing the drop methodImplementing the walk methodImplementing the inventory methodImplementing the Location classHandling itemsHandling NPCsHandling directions
Summary
Epilogue
Index

Content preview from Learning Java Functional Programming

Chapter 4. Streams and the Evaluation of Expressions

In this chapter, we will examine how Java 8 supports the concept of streams. A stream can be thought of as a sequence of elements processed by a series of methods using a fluent interface. The stream concept is supported by the Stream class.

We will begin with a brief overview of the Stream class and its methods. After conveying the essence of the stream technique, we will examine how streams are created and show how they can replace imperative and object-oriented approaches to solve similar problems. The intent is to provide an overview of the Stream class and its methods. A detailed coverage of each method is not possible here.

The topics you will cover include the following:

Creating fixed and ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Hands-On Functional Programming with Java

Publisher Resources

ISBN: 9781783558483

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Learning Java Functional Programming

by Richard M Reese, Richard M. Reese

Chapter 4. Streams and the Evaluation of Expressions

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.