Java: The Complete Reference, which edition to follow

I would recommend you to rely more on online tutorials. They are updated as fast as the language itself.

Buy one good latest book. That will help you set the foundation (not that you cannot set foundation from online tutorials.)

I left programming in Java more than 7 years ago but I have still managed to stay up to date on it through OTLs like Pluralsight, LinkedIn Learning (formerly Lynda.com) and O’Reilly. And I know I am not far behind because I interview with companies in Java while coding in C++ at work.

I'll try to give a few actual textbook recommendations.

If the goal is to learn Java for regular programming, I would avoid like the plague any Java book that doesn't at least go through Java 5, at which point it practically became a different language. I have always found David Liang to be quite a clear writer, and his most recent text (finally) introduces Java 5 features such as generics.

If you're looking for a book that shows you the deeper beauty of object oriented programming, Joseph Bergin's got your back. This isn't a book about Java features, but really more about the why of things. Please note that after reading it, you will constantly run into people saying very silly things about OO online. Many people really, really seem to think that they understand it because they have learned some of its mechanics, but they truly don't understand the core idea at all.

In terms of more recent language features, I'm not familiar with this book by Joshua Bloch, but it is well reviewed, and covers far more recent developments than the Liang book.

The fundamental question is, whether your goal is to learn programming (in which case the language doesn't matter at all … theoretically at least) or to learn Java.

If you want to learn programming, the programming language and the version doesn't really matter. It only matters insofar as to understand the examples, and to understand the concepts behind the code, you need to understand the programming language. So, the code and the programming language should be as simple as possible … e.g. a language like Scheme or Smalltalk, or you already need to know the language.

If you want to learn Java, then you should use a recent book, because there has been a lot of stuff introduced that not only makes stuff easier to read and write, but that fundamentally changes the way Java programs are written.

Sun dropped the "2" from "Java 2" in 2004. That should give you an indication as to how old this book is. It covers Java 2 1.4, which was released in 2002.

You don't have to chase every version, every release, every edition, every new feature (especially with the new 6-month release cycle), but since 2002, there have been multiple new features in the Java language that fundamentally change how Java code is written:

• Java 5 (2004):
  • Generics
  • Annotations
  • Autoboxing/Autounboxing
  • enums
  • Varargs
  • The enhanced for loop
  • [LIB] JSR166 Concurrency APIs
• Java 7 (2011)
  • [LIB] Extended JSR166 Concurrency APIs
  • [LIB] NIO.2
• Java 8 (2014)
  • Lambdas
  • default methods on interfaces
  • [LIB] The Stream API
• Java 9 (2017)
  • modules
  • [LIB] Reactive Streams
• Java 10 (2018)
  • Local variable type inference
• Java 14 (2020)
  • switch expressions

[I bolded the ones I deem to be particularly disruptive. I marked some features as [LIB] which are library additions to the Java platform and not language features, but are nonetheless important. E.g. NIO.2 offers a whole new, much higher-level, much improved way of interacting with files. And Streams essentially mean that you will never have to iterate over a collection ever again.]

Value Types and sealed Types will bring another major shift in the near future (possibly as early as Java 15 (October 2020)). In particular, sealed Types will allow modeling Algebraic Sum Types in Java, which opens up a fundamentally different way of structuring programs.

Oracle has recently started to include so-called Previews as well, these are features that are shipped as part of an official release, so they reach a wide audience, but that are not guaranteed to be supported in future releases in that form. They may be changed or dropped completely. One of those features is records that currently ship as a preview in Java 14. While they aren't as disruptive as some of the others (Generics, lambdas, Value Types, sealed) as they are just syntactic sugar, they allow to drastically reduce the amount of code for simple data classes, and thus make it easier to see what is going on.

For example, this:

final class Point {
    private final int x;
    private final int y;

    Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int x() {
        return x;
    }

    public int y() {
        return y;
    }

    @Override
    public boolean equals(Object that) {
        if (!(that instanceof Point)) {
            return false;
        }

        var other = (Point) that;
        return x() == other.x() && y() == other.y();
    }

    @Override
    public int hashCode() {
        return x() ^ y();
    }

    @Override
    public String toString() {
        return "Point[x=" + x + ", y=" + y + "]";
    }
}

Can be written in Java 14 as this:

record Point(int x, int y) { }

For a student, any recent edition will be fine. Don't overthink it. The first task is to become thoroughly familiar with the mental model required of a Java programmer. Or even, for the very experienced, the mental model of a programmer in general.

Most, but not all of the recent changes in Java are in the libraries, but even the more fundamental additions can wait until you can program effectively in any consistent subset of the language. The intimate details of most recent additions are much less important than gaining a facility with the ideas of abstraction, composition, inheritance, encapsulation, and such.

And yes, the language will either continue to change or it will become obsolete. Don't worry about that until you can't solve some programming problem effectively with what you already know.

And a good textbook is probably more valuable to you at this point than a reference in any case. Reference material tends to present features in isolation, which is essentially worthless. The features need to work together to be effective. Textbooks will tell you that better than a reference guide.