I think you are comparing apples and oranges here, Giovanni. Functional programming is not just a way to write less code, although that can be one of the benefits of using FP with the right language. It's not about static or dynamic typing either, as static typing in any language can help to trap certain errors at compile time so you can fix them before your users see them at runtime. Scala has static types, while Clojure does not, yet Clojure is probably more of a "pure" FP language than Scala, which is a hybrid FP/OOP language.
Immutability is a key FP feature that really helps to reduce errors, which is why people like Josh Bloch (in "Effective Java") also recommend making variables immutable in Java where appropriate. All "variables" are immutable by default in both Scala and Clojure, for example, so you have to deliberately choose to create a risky mutable variable in these languages, and you rarely need to do this in an FP language compared to OO.
Having functions as first class objects, and being able to use
higher order functions, removes a lot of complexity and eliminates the need for many common OO design
patterns (see
https://pragprog.com/book/mbfpp/functional-programming-patterns-in-scala-and-clojure), because you no longer need to wrap a function in a load of extra kruft just to pass some behaviour into another function (method). Java 8 lambdas finally give you the ability to do this in Java, but it's still pretty clunky compared to Clojure or Scala.
OOP and FP take different approaches to how you combine data and processing to implement your task. Objects combine state and behaviour and try to encapsulate complexity, often resulting in lots of different structures (classes) with distinctive behaviours. FP tends to aim for relatively simple data structures and separate functions, plus things like collections that provide fairly generic mechanisms such as map() and reduce() (i.e. higher order functions) for applying those functions to the data. There's a whole
world of mathematics behind this, which I do not understand, but that's OK with me right now.
Of course, purists on both sides will argue all day about which is best, and I'm no expert on either paradigm, so this is a very simplistic view. But as an ordinary developer who's worked with procedural, imperative, declarative, OO and FP languages, I find FP much easier to work with (even if I still don't understand monads!), because I find it allows me to focus more clearly on telling the computer what I want to do, instead of having to tell it how to do it, and I can do what I want with less code than in Java. FP works for me.
YMMV, of course!