Start reading Functional Programming for Java Developers on your Kindle in under a minute. Don't have a Kindle? Get your Kindle here or start reading now with a free Kindle Reading App.

Deliver to your Kindle or other device


Try it free

Sample the beginning of this book for free

Deliver to your Kindle or other device

Anybody can read Kindle books even without a Kindle device-with the FREE Kindle app for smartphones and tablets.
Functional Programming for Java Developers: Tools for Better Concurrency, Abstraction, and Agility

Functional Programming for Java Developers: Tools for Better Concurrency, Abstraction, and Agility [Kindle Edition]

Dean Wampler
2.8 out of 5 stars  See all reviews (4 customer reviews)

Print List Price: 17.50
Kindle Price: 10.82 includes VAT* & free wireless delivery via Amazon Whispernet
You Save: 6.68 (38%)
* Unlike print books, digital books are subject to VAT.


Amazon Price New from Used from
Kindle Edition 10.82  
Paperback 15.57  
Kid's and Teen books from £0.99 on Kindle
Browse our selection of top children's and teen title in our one week sale, with top titles from only £0.99.Browse the sale here

Product Description

Book Description

Tools for Better Concurrency, Abstraction, and Agility

Product Description

Software development today is embracing functional programming (FP), whether it's for writing concurrent programs or for managing Big Data. Where does that leave Java developers? This concise book offers a pragmatic, approachable introduction to FP for Java developers or anyone who uses an object-oriented language.

Dean Wampler, Java expert and author of Programming Scala (O'Reilly), shows you how to apply FP principles such as immutability, avoidance of side-effects, and higher-order functions to your Java code. Each chapter provides exercises to help you practice what you've learned. Once you grasp the benefits of functional programming, you’ll discover that it improves all of the code you write.

  • Learn basic FP principles and apply them to object-oriented programming
  • Discover how FP is more concise and modular than OOP
  • Get useful FP lessons for your Java type design—such as avoiding nulls
  • Design data structures and algorithms using functional programming principles
  • Write concurrent programs using the Actor model and software transactional memory
  • Use functional libraries and frameworks for Java—and learn where to go next to deepen your functional programming skills

Product details

  • Format: Kindle Edition
  • File Size: 369 KB
  • Print Length: 90 pages
  • Simultaneous Device Usage: Unlimited
  • Publisher: O'Reilly Media; 1 edition (22 July 2011)
  • Sold by: Amazon Media EU S. r.l.
  • Language: English
  • ASIN: B005KOJ3Z4
  • Text-to-Speech: Enabled
  • X-Ray:
  • Average Customer Review: 2.8 out of 5 stars  See all reviews (4 customer reviews)
  • Amazon Bestsellers Rank: #258,500 Paid in Kindle Store (See Top 100 Paid in Kindle Store)
  •  Would you like to give feedback on images?

More About the Authors

Discover books, learn about writers, and more.

Customer Reviews

2.8 out of 5 stars
2.8 out of 5 stars
Most Helpful Customer Reviews
1 of 1 people found the following review helpful
2.0 out of 5 stars Guess I have to learn Scala after all... 21 Jan 2012
When I saw this book on Amazon I thought I had a chance to learn why people get so excited about functional programming, before deciding whether to learn a real functional language. Unfortunately, it really is too superficial to add much to what I already knew from a brief time browsing Wikipedia and a few other online articles.

As the author admits in the preface, some topics are not discussed because they are difficult to represent in Java, so the book covers only a few of the important aspects of functional programming. Some of these, such as the emphasis on immutable objects, are useful even in Java, but are already well known from books like "Effective Java". Others, such as recursion, are generally useless in Java because it lacks the appropriate optimisations. While I can see, from other sources, why recursion can simplify code, this does not come across in this book.
Comment | 
Was this review helpful to you?
4.0 out of 5 stars A short, but useful read 23 May 2012
Format:Paperback|Verified Purchase
If I paid the full new price for this book, with it being so small I'd feel short changed, however:

It can be hard to make head or tail of functional programming coming from an object oriented world. This book makes a good attempt at using Java to describe the concepts of functional programming, and ultimately tries to get you to think in a more declarative and 'functional' manner when approaching programming problems. Therefore there is a lot of talk about concepts like concurrency and abstraction, with relatively small code snippets which I think is why it has got some negative reviews. But it is concise and I think reads pretty well. Contrary to what you might think you can use a lot of functional concepts in Java with the libraries presented in this book, without the need to take up another specifically functional language.

But it certainly isn't a book about a particular technology which you can learn and say 'now I know functional programming'. It is a good intro though.
Comment | 
Was this review helpful to you?
2 of 3 people found the following review helpful
1.0 out of 5 stars Wrong choices, sketchy definitions, poor read 30 Sep 2011
A classical objection Java programmers (and programmers of other languages) have against functional programming is the abundance of recursion. In Java it makes perfect sense to try and avoid it as much as possible. The title of the book suggests that it will teach you to bridge the conceptual gap and help you translate common recursion patterns to structures better suited for Java, i.e. loops / iterators / etc. This is just an example of a wrong choice (he actually uses recursion in almost all his Java code, even though he comments it doesn't optimise).

Definitions of central concepts (lists, category theory, monads, concurrency) are sketchy at best. Some are downright incorrect (lazy evaluation; his definition is that of non-strictness). Oftentimes I couldn't help but be under the impression that the author is convinced it's more important to sound intelligent than it is to be to-the-point. This would normally only be considered a stylistic problem, but in this case it leads to confusion, ambiguity and incorrectness.

Java programmers that want to know what all the fuss is about would do better getting a simple introduction text (e.g. Graham Hutton's Programming in Haskell), working through that in a few days (at most) and applying the concepts in a world they know all too well.
Comment | 
Was this review helpful to you?
2 of 3 people found the following review helpful
4.0 out of 5 stars Useful intro through the lens of Java 4 Aug 2011
By d6y
A personal take on functional programming in terms of the Java language. Keeping the book small was a great idea, as it's just about the right size to communicate the style of functional programming so you can decide if it's something you want to pursuit (probably in a different language).

This is the book for you if you code in Java, you've heard of functional and want to know what the fuss is about, but you only want it in terms of the constructs of Java that you already know.
Comment | 
Was this review helpful to you?
Most Helpful Customer Reviews on (beta) 3.4 out of 5 stars  16 reviews
13 of 13 people found the following review helpful
4.0 out of 5 stars Concise and "gentle" introduction 14 Aug 2011
By Yuriy Zubarev - Published on
This is a very concise and useful introduction to functional programming for Java developers. It's going to be useful for developers coming from other object oriented languages as well.

At the beginning, the book contrasts two paradigms and outlines basic principles of functional programming. It then delves into data structures and concurrency, all while demonstrating benefits of thinking in a functional style. The author uses whatever means Java has to offer, be it interfaces and/or anonymous inner classes, to mimic functional constructs. Examples may not be beautiful (after all, we're limited to Java syntax) but they do drive home the main concepts.

The book will be invaluable to people who are curious about functional programming and spent years working with objects in Java or similar languages. You will only concentrate on the new ideas while relying on an already familiar syntax and language features. I found this approach to be very useful.

If you're already comfortable with functional style and want to dig deeper to understand how to think of writing software in a new way, then the book is not for you. In one of the final chapters the author presented a UML diagram for an "American payroll application". He reasoned how the object model wasn't ideal for the problem domain, but he only offered very general statements on what the solution would look like in a functional world. This was the most disappointing part of the book for me. I thought I would see a decomposition of a real-life example of a respectable size but instead there was almost nothing offered.

Summary. Concise and "gentle" introduction to functional programming to OO developers. Not enough real-life examples to support some big claims.
5 of 5 people found the following review helpful
5.0 out of 5 stars The book I wish I had... 7 Aug 2011
By William Pollock - Published on
This book's primary audience is the career Java programmer who's heard of functional programming, and wants to find out more about it, but doesn't feel ready to dive into the deep end with Scala or Clojure. For such a reader, this is a marvelous (and short!) book that will reward her/him far beyond the time required to read it. I was that person a few years back, and while I really wish I could have read this book back then, it has insights too for the Java programmer already familiar with functional programming. FPfJD presents functional programming concepts in the context of Java, and shows how I can further improve my Java by formalizing my application of FP concepts.
7 of 8 people found the following review helpful
5.0 out of 5 stars Good introduction to FP for Java devs 6 Aug 2011
By Raymond Tay - Published on
First bought this ebook from and began reading it. I have to admit i have mixed feelings about this book. But first things first, i've done Erlang and Scala development and so i'm not really a beginner in FP so i have to start from there.

The book's intention is to introduce FP concepts to Java programmers and considering the fact that FP is a big subject not to mention this book is about 70+ pages thick means you won't get everything known to FP world. To be honest, this is fine since the purpose wasn't to do that. I liked the fact that Dean introduced the concepts of lambdas, closures, lazy evaluation, combinators etc through encouraging his readers to try out every exercise (which i did quite happily) which really reinforces the ideas. That's always a good thing in any lesson/subject you're trying to learn. I also liked the fact that Dean mentioned the LSP and Functional concurrency in two (relatively short) chapters of his book but he doesn't go into detail into these subjects but he did showed examples using Akka Framework and explaining STM (Software Transactional Memory). These last two chapters sort of provided an anti-climax to the entire book cos i was expecting to work out more programming exercises w.r.t STM, Actors.

After re-assessing my emotions, i've discovered that Dean probably avoided functional concurrency because it would take another book (which i'll happily purchased) since its another realm really. FYI, go read "Java Concurrency in Practice" if you want a primer in it. I should caution you to NOT compare this book with "Structure and Interpretation of Computer Programs" since they serve different audiences.

Overall, putting my shoes into the Java programmer whose had little exposure to FP and want to know what it is and how YOU can learn introductory concepts on it, this is currently a good one. Once you've done that, you can probably go read developer books on Scala (Dean's got a strong inclination to it in this book) by Dean & Alex, Odersky Spoon & Venners, Venkat Subramaniam and of course Debasish Ghosh's "DSL in Action"
5 of 6 people found the following review helpful
4.0 out of 5 stars Great Introduction to Functional Programming 14 Aug 2011
By David Witherspoon - Published on
"Functional Programming for Java Developers" provides an introduction to Functional Programming to Java developers that have been using Object Oriented development. The focus of this book is to provided some great examples of how to use Functional Programming and to get you excited about expanding your knowledge by looking into many of the references that are included at the end of the book. Dean did a great job providing examples throughout the book related to the topic of each chapter. In addition, he provides concise coverage of the topics and exercises at the end of each chapter to help enforce the topics that were just covered.

I would recommend this book to anyone that wanted to get an understanding of what Functional Programming is all about and the benefits that it brings to the table. Reading through this book opened up my eyes to how to improve on coding and designs that I have implemented over the years. For example, dealing with mutable objects and the issues that it cause with concurrency and/or other classes modifying them outside of the class that owns that data. I really enjoyed the sections on Persistent Data Structures and Software Transactional Memory in the way that trees are used to deal with changes throughout time. How you could use this to help present the pedigree of changes made by users of your system. Or you could even use this type of technique to roll back data to a specific state similar to version control systems (SVN, CVS, GIT, etc).

On the other hand, if you already have the basic understanding and see the benefits of functional programming, I would not recommend this book and would suggest getting his book on Scala or another book for intermediate to advanced on Functional Programming.
2 of 2 people found the following review helpful
4.0 out of 5 stars Functional Programing described in plain Java 27 Nov 2011
By Matthew Taylor - Published on
There is something about seeing a concrete example of an abstract concept that helps one tremendously over the hump of understanding.

Like most good programming books I've read, this book starts by slowly implementing one new concept in straight-forward code step by step. The completed code at the end of each chapter is then used as the basis for the next concept/implementation, and so on.

The appendix also contains a good solid set of libraries and pointers to other projects for a quick way to get ones 'hands dirty' without starting from first-principles.

Recommended for anyone interested in learning functional programming concepts with a Java background, or interested in how FP concepts can be used in 'real world' Java programs.
Were these reviews helpful?   Let us know
Search Customer Reviews
Only search this product's reviews

Popular Highlights

 (What's this?)
The first principle is the use of immutable values. &quote;
Highlighted by 8 Kindle users
allowing mutable values is what makes multithreaded programming so difficult. &quote;
Highlighted by 7 Kindle users
The term lambda is another term for anonymous function. &quote;
Highlighted by 7 Kindle users

Customer Discussions

This product's forum
Discussion Replies Latest Post
No discussions yet

Ask questions, Share opinions, Gain insight
Start a new discussion
First post:
Prompts for sign-in

Search Customer Discussions
Search all Amazon discussions

Look for similar items by category