It's old, but the material holds up well since it covers a lot of fundamentals
- Think Java (programming, foundational; free) https://greenteapress.com/wp/think-java/
- Think Data Structures (programming, foundational; free) https://greenteapress.com/wp/think-data-structures/
- Effective Java (classic) https://www.amazon.co.uk/Effective-Java-Joshua-Bloch/dp/0134...
- Java Concurrency in Practice (classic) https://www.amazon.co.uk/Java-Concurrency-Practice-Brian-Goe...
- Continuous Delivery in Java (essential) https://www.amazon.co.uk/Continuous-Delivery-Java-Daniel-Bry...
[1] https://youtu.be/dGVqrGmwOAw?t=23m57s [2] https://www.amazon.com/Java-Concurrency-Practice-Brian-Goetz...
The answer also depends a bit on what exactly you want to do. If you're mainly interested in web apps, it's one thing, "big data" is another world altogether, mobile (Android) has its own ecosystem, etc.
All of that said, here are some thoughts:
Generics and the newer Collections related stuff is one area that changed a lot. There's online documentation at:
https://docs.oracle.com/javase/tutorial/java/generics/index....
https://docs.oracle.com/javase/tutorial/java/generics/types....
and a decent, if somewhat older, book is http://shop.oreilly.com/product/9780596527754.do
Then there's the newer concurrency stuff that came along in the Java 5 / Java 6 era. Fork/Join, Executors, etc. Java Concurrency In Practice should still be useful to you, even though it is, again, a little bit dated now.
https://www.amazon.com/Java-Concurrency-Practice-Brian-Goetz...
To get started with the Java 8 stuff, a book like "Java 8 in Action" would be good.
https://www.amazon.com/Java-Action-Lambdas-functional-style-...
Another good intro the Java 8 era stuff is
https://www.amazon.com/Beginning-Java-Language-Features-Expr...
And to make it even harder, Java 9 just dropped, so there's even more new stuff. I just picked up this book myself, but haven't had a lot of time to dig into it yet.
https://www.amazon.com/Java-Programmers-4th-Deitel-Developer...
For frameworks, Spring and Hibernate are both still popular and it wouldn't hurt to brush up on both of those. Spring Boot in particular has caught on for a lot of Java developers.
https://www.amazon.com/Spring-Boot-Action-Craig-Walls/dp/161...
Also, Tomcat is still very popular for hosting java Web applications and services of various sorts. JBoss / Wildfly is still around, but JEE (as J2EE is now known) is not as popular as in the past (even though it has actually improved a LOT).
Play and Dropwizard are two more frameworks you might want to familiarize yourself with
https://www.playframework.com/
http://www.dropwizard.io/1.1.4/docs/
In terms of tools, Eclipse is still popular, IntelliJ is probably the most popular Java IDE these days, and Netbeans seems to have faded from view a bit. Ant has fallen out of favour for builds, with most devs now using either Maven or Gradle. Read up on / play around with both of those and you'll be in good shape there.
Also, Java shops have also been affected by the overall move to "The Cloud" and you can't really ignore that either. If you haven't already, you'll probably want to familiarize yourself with AWS and the AWS SDK.
If you want to work/play in the "big data" space, you'll need some combination of Hadoop, Kafka, Spark, Hive, Storm, Flume, HBase, Impala, etc., etc., etc.
http://www.amazon.com/Java-Concurrency-Practice-Brian-Goetz/...
and it'd be a good start. It's in "boring" old Java, but it goes over a lot of the meat and potatoes concepts.
Why dont we ask Brian Goetz a Java Language Architect how "easy" it is, read his book [1] and then lets talk again how easy it is.
[1] http://www.amazon.com/Java-Concurrency-Practice-Brian-Goetz/...
Here are the books that our university uses for first-year students combined with books that I found to be useful:
Introduction to Programming (using Eiffel) [1]
Mathematics for Computer Science (or: Discrete Mathematics) [2]
Introduction to Datastructures and Algorithms [3]
Introduction to Digital Design [4]
Parallel Programming (using Java) [5]
Optional but highly recommended, you'll probably find it completely out of scope:
Real Analysis I [6]
Real Analysis II [7]
Introduction to Linear Algebra [8]
Introduction to Physics [9]
[1]: http://www.amazon.com/Touch-Class-Learning-Program-Contracts...
[2]: http://ocw.mit.edu/courses/electrical-engineering-and-comput...
[3]: http://www.amazon.de/Introduction-Algorithms-Thomas-H-Cormen...
[4]: http://www.amazon.com/Digital-Design-Computer-Architecture-E...
[5]: http://www.amazon.com/Java-Concurrency-Practice-Brian-Goetz/...
[6]: http://www.amazon.com/Analysis-Texts-Readings-Mathematics-No...
[7]: http://www.amazon.com/Analysis-II-Texts-Readings-Mathematics...
[8]: http://www.amazon.com/Introduction-Linear-Algebra-Fourth-Gil...
[9]: http://www.amazon.com/Fundamentals-Physics-Extended-David-Ha...
http://www.amazon.com/Java-Concurrency-Practice-Brian-Goetz/...
#2. ... hmm, that might be it.
http://www.amazon.com/Java-Concurrency-Practice-Brian-Goetz/...
I only know about that book because of Rich's mentions of it.
To be honest, I"m also a little surprised that the Pickaxe book is in the list. Not that Ruby isn't the bees knees; it just didn't strike me as being influential on Clojure.
One of the best books I've read on it is Java concurrency in practice [1]. It does an excellent job of dispelling these occultic beliefs and letting the reader know exactly when and how concurrency should be implemented. It is applicable to more languages than just java, especially since many have adopted large parts of the java memory model.
The worst things I usually find when reviewing concurrent code is people either not using locks when they should, using locks when they shouldn't, and having inconsistent data guards. I've seen people throw in random locks to guard local non-shared state which is just crazy town but "Multiple threads are running this code, so I'm adding a lock".
I certainly prefer message passing over shared state. However, it's a little baffling to me why it's so hard for devs to grasp how to properly maintain shared state. Instead of just learning the basic rules, it gets couched in "It's just too hard to understand so keep adding things until it works".
[1] https://www.amazon.com/Java-Concurrency-Practice-Brian-Goetz...