Is Functional Programming possible in Java?

I'm reading the book you mentioned. It is really good BTW.

Yes it is possible to be functional in Java. I don't know to which degree you can achieve it but you can implement many functional programming idioms.

One of the most important things is trying to code with "Don't mutate states" mentality.

For example you use the final keyword to achieve immutability. If you are going to use a data structure then you should code in immutable data structures. Google Guava library is already doing this.

Also for concurrent programming, you can rely on Akka framework (the actor model).

It is worth mentioning that the JVM bytecode doesn't support (at least yet) Tail-call optimization, a very important feature for functional programming languages.

Yes, it is definitely possible, in the same way that it is possible in any turing-complete language / execution environment combination. You can even get it to perform quite well if you know what you are doing.

Not sure how sensible it is though. In particular, be aware that it's not particularly idiomatic (i.e. it will look very strange, you will have to do some unconventional things and confuse people who are used to regular Java)

You'll end up with some odd looking code, e.g. to define a new function:

Function twoStrings=new Function() {
  public Object apply(Object param1) {
    // do something to param1 and return a result
  }
}

To do functional programming you typically need:

• First class functions - easy to create in Java by defining an abstract class or interface that represents your "Function" and has an "apply" method which applies the function to one or more parameters.
• Closures - create an instance of your function object above with the closed-over values stored in final fields. You can use an anonymous inner class for this.
• A library of standard higher order functions - this is trickier, however you can still write your own to bootstrap a simple functional language in a few hours. If you want something fancier, you can check out other functional libraries people have built in Java.

So it's possible as an exercise and even an interesting hobby project. But you really want to do serious functional programming while maintaining the advantages of the JVM / accessing Java libraries then Clojure is by far your best option in my opinion.

p.s. since the core of Clojure is actually written in Java, it's actually a very interesting case example of how to do functional programming in Java while hiding the messy details behind a nice new modern language syntax. Clojure source code is on GitHub for those interested.

It is possible to be somewhat functional in Java. Doing so is seriously painful. Instead of

myList.each { doSomething(it); }

You have something like:

myList.each(new Function() { public void do(Object arg) { something(); }})

And if you want true functional programming, with closures and functions as first class objects, pick another language. Scala, Clojure, Groovy all run on the JVM and can interact with legacy Java classes. .

The answer is a resounding "yes, of course", yet in my opinion one of the most important features in many functional languages is the excellent type system. You'll never be able to manage this in Java yourself.

If you want to write functional programs and yet stay with the JVM I can recommend among the usual suspects Scala and Clojure to look at Frege. Frege has a syntax and type system that is very close to Haskell, but programs are translated directly to java code and can interact with other java code.

Well, all sorts of things are possible. It's possible to do object-oriented programming in C; it's just not a very good idea.

Java wasn't designed for FP, so if you're trying to do everything in a purely-FP style, you'll have problems. You'll be fighting the language, instead of working with it. And not just the language - there's also all the wonderful free Java libraries. So don't go for pure FP; take some of the ideas behind FP and integrate them into your Java code, but understand that you can't do that to all the ideas.

You're encouraged by the OpenJDK team to download their latest OpenJDK 8 binaries and play around with the new lambda expressions and the new functional idioms introduced in the Collections API (among others). You can program in a clear functional style. See "Functional programming in Java?" for a JDK8 Collections comparison with pre Java8 libs like Guava, FunctionalJava and LambdaJ.