Best Books for Learning Java Effectively

In this post, I will be listing books that I recommend Java developers to read. 

I have personally purchased and read through each of the books in this list. And I have also read other books related to Java that are not on this list. Please note that these are simply a list of books that I felt had the greatest impact for me personally. I am sure that there are other books out there that are great.

I read countless number of articles, a fair share of books, watched many videos on Java. In this post, I am putting up the books that impacted me the most in journey of learning and discovery.

Please bear in mind that the​ listing order does not bear weight on any of the qualities and/or traits of each individual book.


Review Criteria​

In each of the book reviews, I give a rating for each book. Please do bear in mind that in this post, I am only listing what I think are the best books for learning Java. I have read some books but had to put it down.

Out of the books I ve read, the following four helped me out the most. 

Please also bear in mind that I haven't read every single book in the universe so if there is another book that you highly recommend, please leave a comment. I might even give the book a try and update this list in the future. 

Anyhow, the purpose of this post is to help readers who are interested in learning Java, but don't know what book to buy. Later on, I will also compile a list of recommended free resources that helped me. 

Below is the review scale and criteria implemented in each of the book reviews made in this post. ​

Go get the book!

Get the book already!

Rating: 8.5-10/10

Highly relevant info

Extremely well

Stands the test of time

Situational Buy

Only buy situationally

Rating: 5-8.5/10

Relevant info

Well written

May stand the test of time

Do NOT Buy

Waste of time

Rating: Below 5/10

Irrelevant and time-wasting content

Poorly written

Will become outdated

Readers might be wondering: How do I determine whether the information I am reading is highly relevant? Click the tab below to read the guidelines by which I reviewed each book. 

  Book Review Criteria (click here to see)

Experience Level Criterion

You might also be wondering: How do I (Jay Lee) define and evaluate a developers skill or experience? For the sake of this post, I will be specifying three categories.

  • Beginner (0-2 years of experience)
  • Intermediate (2-6 years of Professional Experience)
  • Advanced (6+ years of experience)

You might be reading this and rolling your eyes thinking "oh man, that is so narrow-minded ... you can't just classify a developer's skill level with the amount of experience that they have". 

Well, if I were to factor in other information, such as their experience with other languages, gauge their knowledge and understanding of software design, architecture, object oriented analysis and so on, the book review may become so bloated that it can potentially be a book of its own. 

Hopefully, my reasoning sits well with you. Without any further ado, lets head straight into the list of books!

Overall Impression: When I read this book, I was fairly new to programming, with only a very short background in JavaScript. Compared to other Java books that I read, this book had the most impact. The reason was simple: Head first Java is simple and beginner-friendly. It managed to unpack and explain concepts that I had difficulty understanding.

If you are a senior developer and you are picking up Java, unless the Head First Style fits with your way of thinking or learning, I don't think it is the right choice.

He​ad First Java however, serves as a great resource to individuals who have little or zero programming knowledge and want to learn Java. I define little programming experience as anything below 1.5 years. 

​It has great analogies. I don't think the content is dry. Some of the textbooks can be very difficult to read for extended period of time. I need a little bit of spice, some sass and some corny jokes to keep me going. 

Head First Java provides a bit off all of that. Which is why I highly recommend it as an introduction to programming in Java. ​

1.1 Analysis

Target Audience: Beginner​


For the beginner, Head First Java's content is highly relevant. Head First is written in a manner that empowers visual learners and those that come from non-technical backgrounds to wrap their minds around the concepts explored. 

RATING: 8/10

Quality of Content

The quality of the content is high, like most of the other books in the Head First series. The content contains many diagrams, which suits visual learners, uses very relate-able examples to drive a certain point home. I also enjoy the way that they present information such as having a fireside chat between Objects and Classes to illustrate the difference. 

People may argue that because the content is updated (covers up to Java 5), it is not a recommended book, but I beg to differ. 

The reason being, it does a great job in explaining core Java. All the stuff introduced in Java 8 such as lambda expressions can be picked up much more quickly, if one has a solid understanding of the fundamentals of Java.

Head First does a great job at introducing the fundamentals of the Java programming language in a beginner-friendly way. 

RATING: 9/10​

Stands the Test of Time

Because of the very nature of the book, I believe that as the Java language evolves, inevitably, some of the contents may become outdated and other contents will be omitted. 

Update: A major downside however, is that Head First Java 2nd edition covers up to Java 5. In another words, the source code is fairly outdated.

However, I don't believe that there are drastic changes made to make a certain section of the book entirely obsolete. Furthermore, any book that is tied down to a specific language will, to some extent, face the same problems that I mentioned just now.

I made a mistake by stating that it covers Java 8, but this is not the case. However, my recommendation does not change. I still highly recommend this book to those who are starting out with Java. It gives a very simple

@Credit Evans Thomas thank you so much for pointing out that Head First Java only covers up to Java 5. I realized that I made an error when allocating points here.

RATING: 7/10

Note: The reason why I did not downgrade it to 5 or below was because of the way the concepts are taught in Head First. Head First does its job in explaining fundamental concepts of Java programming to beginners with no computer science or programming background. Therefore, I believe it stands strongly against the test of time, due to its unique teaching approach, which still draws me in to this day.

I did however, downgrade the rating by two points, due to outdated content. Naturally, any book on programming languages will have a disadvantage when standing against the test of time, because new features are being added. Especially if some ground-breaking changes are introduced in newer iterations of a programming language. Java is no exception to this rule.

Learning some of the newer features of the Java programming language will become more natural after reading this book.

1.2 Summary


  • Simple explanations.
  • Use of real-world and relate-able cases to drive home a point or concept.
  • Content is thorough, despite its simplicity.


  • Its narrative style approach to explanations may not be suitable for all audience.
  • Lack of focus on advanced topics.


Overall Impression: The authors were not kidding when they called it a brain-friendly guide

When I first read this book, I had 8 months of programming experience under my belt. I dismissed it as a book that was difficult to understand, hard to read, and thus, not worth my time. Oh how wrong I was. 

After abandoning the book for 1.5 years, after my skills had developed somewhat, I decided to pick it up. And lo and behold! The illustrations in the book, the phrases as well as some of the terms used, along with the examples began to click! 

If one mentions design patterns, it is often regarded as blasphemy to not mention the legendary book written by the Gang of Four, Design Patterns: Elements of Reusable Object-Oriented Software.

I wish to inform readers that I have not read this book yet. I look forward to reading it in the future however. However, as an Intermediate Java developer, I recommend Head First Design Patterns over the GoF book. You might ask why? Understandable, especially since I haven't read the GoF book. Well, here area my reasons.

  • The source code in head first is all in Java. The GoF book's source is in C++.
  • According to other reviews, the GoF design pattern book is drier and thus, more difficult to read. I must admit myself that reading the Head First design patterns is relatively easier because it is written more like a novel with relate-able examples.

Okay, I have rambled on for far too long. As a book, Head First Design Pattern definitely left a mark

2.1 Analysis

Target Audience: Intermediate​ (2 - 6 years of experience)


Design patterns are NOT for beginners. I highly recommend that readers develop a solid understanding of Java, and of object-oriented programming concepts before trying to read a book on design patterns. Otherwise, you will most likely end up confused and disillusioned just like how I was back when I first read this book. 

Design patterns teach us tested and proven methods to solve existing problems. Therefore, in terms of relevance, I think they are quite relevant. However, I place core knowledge, problem solving skills, software engineering best practices and an understanding of data structures and algorithms above design patterns. One will come up with suitable solutions with the aforementioned set of skills, as design patterns were built by people who had strong understanding in these areas.

RATING: 7/10

Quality of Content

Even out of the Head First series, I think this book boasts surprisingly high quality content. Referring back to my review criteria for high quality content, this book is easy to read, understand and draws me in. However, due to the complexity of the design pattern topic, I recommend taking a break every 30-40 minutes to digest the knowledge and actually practice what you read by writing code. I recommend spending at least 30 minutes writing code to solidify the knowledge. 

Sorry about that, for some reason, I just went into teaching mode. 

RATING: 9/10

Stands the Test of Time​

Design patterns are language agnostic, which makes it more durable by nature against the wear and tear brought by the passing of time. We still talk about the observer pattern as a possible solution for handling subscribe and publishing events.

Design patterns will never become obsolete. The reason for that is, it is not an API or a programming language. Design patterns are a way of thinking. Of course, newer patterns or methods of solving problems will eventually be discovered and rise in popularity. But the existing patterns will serve as bases for understanding some of the newer patterns. 

Therefore, I am convinced that learning design patterns will help you throughout your entire career as a programmer, regardless of what language/framework you use in the future.

RATING: 9.5/10

2.2 Summary


  • Extremely well written with plenty of examples to help readers understand.
  • Use of real-world and relate-able cases to drive home a point or concept.
  • Fun to read. Writing style involves user interaction, which makes the content very engaging.


  • The content and its delivery makes it difficult to continue reading for an extended period of time.
  • Lack of focus on advanced topics.

RATING: 8.5/10

Overall impression: As with Head First Design Patterns, this is not a book on the fundamentals of programming. The book was written with the purpose of training the audience to write clean code. 

If this does not pique your interest, look at all the time that you spent reading and maintaining code. Writing clean code makes the job of individuals that will come in months later and read your code. That person could even be you.

You could be that guy who walks in on the first day at your job, look at the code base and say ... WHAT THE ?!?!?! By learning how to write clean code, you are not only doing yourself a favor. You will be affecting far more people than you think and could possibly imagine. ​

Writing clean code is beneficial for both the company and the developer. Without ANY hesitation, I will recommend this book to just about any Java developer. It is, to say the least, an enlightening read for any Java developer. 

​I rarely get this crazy or enthusiastic about something, but Clean Code is one of those books that will stick with you throughout your entire life as a programmer.

I will mention this many times though, take it with a grain of salt. Especially this bookEat the meat and throw out the bones. Put on​ your critical thinking cap. Although I really admire Uncle Bob and respect him, I don't agree with everything that he says. 

Update: Uncle Bob is releasing a new book in September of 2017 titled

Clean Architecture: A C​raftsman's Guide to Software Structure and Design.

If you loved clean code, this book is definitely a must get. I am going to be getting it for sure. If the book lives up to its standard, I will definitely add the book to this review post, or on another book review post on software design and architecture. 

3.1 Analysis​

Target Audience: All Levels


VERY RELEVANT. Regardless of what language you are writing in, and no matter what the day and age is, as long as there are human developers around, the art of writing clean code is probably one of the most relevant and important skill for a programmer.

Clean code helps readers understand what the code does in as little time as possible. 

The cocepts behind clean code is more than just writing readable code. There is so much more to it. To keep it relatively surface level, it also involves concept like DRY (don't repeat yourself), other things to make code more robust and with minimal side-effects.

Hopefully by now, you are convinced by the relevance of the topic matter and content presented in this book.

Please be aware that the concept of clean code is relatively subjective. As developers, we don't have the EXACT SAME opinion when it comes to our understanding and ideal concept of what clean code should be.​

RATING: 10/10 

Quality of Content

I am huge fan of this code, but I think if there is any place to take points off this book, it would be in the quality. Don't get me wrong, the quality of the writing in it of itself is extremely high. 

However, one downside to the book is that it takes the idea of clean to code to extremes. Readers, please take some of the concepts with a grain of salt. Naturally, there will be points that you disagree with.

Like any other book that covers the concept of clean code, some ideas are ones that we all agree on such as giving variables meaningful names. However, there are also grey areas​

Still, most of the book is written extremely well and very engaging. In one sitting, I read it like I was reading Lord of the Rings, and left me wanting more. I read for 3-4 hours straight to realize that it was ​dark already and that I was hungry *insert awkward laugh. 

RATING: 8/10

Stands the Test of Time​

By nature, the art of writing clean code is an asset and a trait that will be valued in all contexts, as long as humans are still writing code. Code is maintained, read and refactored by humans. Therefore, humans need to be able to understand and grasp the code as quickly as possible.

Aside from the mental and emotional burden one bears when reading poorly written code, brittle, spaghetti code also costs the business a TONNE OF MONEY. The time spent reading the code could have been invested elsewhere. Not to mention updating, extending and maintaining the code. Anyway, we are not here to talk about business. 

When we talk about programming, we often talk about "best practices". ​Don't do this. Don't do that blah blah blah blah.

However, best practices and how we read and write code, as well as what we perceive to be clean is susceptible to change. We can see it even in this very day and age. Functional programming is becoming all the rage, especially in the world of JavaScript. With that, there are more examples of functional programming. As a result, people are becoming more and more adamant that functions should be pure.

As humans, we are most familiar with what we see most often. Just as trends come and go, the idea of clean code will also flow along with what the trends and ideas that seasons introduce and dismiss.  

Therefore, I believe that some of the concepts taught in this book may not fare well when standing the test of time. 

However, the idea of clean code, I believe, will be relevant, for as long as humans are the ones maintaining code. ​


3.2 Summary


  • Priceless information.
  • Motivates readers to scrutinize their code and pursue mastery.
  • The concepts taught in this book will serve readers for their entire career as programmers.
  • Re-reading value is huge. I learn more each time I read this book.


  • Some practices are questionable such as word limits on variables, never using more than three arguments, etc. 
  • Uncle Bob does talk about fairly advanced concepts in quite a few parts of the book. 

RATING: 8.33/10

The title is an extremely accurate two-word summary of this book.

If I could choose only one Java-related book to take with me (from my bookshelf), it might just very well be Effective Java. This book was written by Joshua Bloch and it is written with the focus on Java 5 and 6. So it is fairly dated, but still very relevant. 

Before rushing to buy this book, please do NOT buy this book as an introduction to programming in Java. You will regret it. The book is targeted towards experienced Java developers. If you want a book that explores the Java API, basic programming concepts and whatnot, you will be disappointed. ​

As an introduction to Java, I recommend Head First Java especially for those that are relatively new to programming.​

If you want to gain a deeper understanding of Java, best practices and really push yourself to improve as a Java developer, Effective Java is definitely the book for you. If you ask experienced Java Developers around you, around 8-9 out of 10 of them read Effective Java. And out of those who read it, I am certain that 90% or more will highly recommend this book. ​

HEADS UP: Effective Java (3rd Edition) is on its way in late 2017. According to Joshua Bloch, the book will be updated for Java 8 and 9. You bet that I am going to purchase this the moment its out! :)It is scheduled to be released on October 29th 2017.

4.1 Analysis​

Target Audience: Intermediate - Advanced


You can bet that the content is very relevant to Java developers. Effective Java effectively teaches readers to write effective Java code (pun intended). It is a must-read for all Java developers.

I don't even have to write a book review for this book. It is that obvious. Even if I don't mention this book here, somebody else next to you or online will recommend this book to you.

Think of it this way: imagine you are trying to learn how to play tennis. Head First Java teaches you how to swing your racket, the rules, the basic strokes and forms. Effective Java trains you to actively assess your play and how to effectively use the techniques you have been taught. It takes your play to the next level by providing insight on when a particular play may be effective by analyzing the position of your opponent, etc. In the context of tennis or any other sport, Effective Java is pretty much the ideal coach you have been searching for.

Effective Java is famous for its rules. Summary notes on Effective Java can be found on GitHub. Some of these may sound obvious such as item 5: Avoid creating unnecessary objects. Joshua then goes on to suggest various methods to prevent the creation of unnecessary objects such as the lazy loading method. 

RATING: 10/10

Quality of Content

Admittedly, I had difficulty in understanding everything that was going on. However, that is the beauty: digging into this book will make you a better Java developer.

If you are coding regularly and you want to improve as a Java developer, the content will quickly draw you in. It is written in an actionable way, providing developers with specific guidelines and methods of improving the we write code.

I can attest to this. If you are a Java developer, just applying some of the techniques in this book will improve your code.

Taking it one step and understanding the motive behind each item, when to apply these techniques and when to refrain will make you a better developer. 

For the richness of content and the complexity, it is written surprisingly well and in a manner that is relatively digestible, given the nature of the content. 

RATING: 9/10

Stands the Test of Time​

Considering that it was written in 2008 and is still considered a must-read book, the book as a source of information has stood the test of time.

However, I will say this. If it was a book other than Effective Java, I cannot guarantee the same longevity. What makes the useful life of this book so long-lived is the solid, actionable items as well as the authority backed by.

For those that do not know, Josh Bloch is one of the most respected names in the Java community. You know that collections framework that you use on a regular basis to store and process data. Well, it was developed by Josh. He also co-authored in another Java Best Seller book Java Concurrency in Practice. To say that he is quite well-known in the Java community would be an understatement. 

Because the Java language is evolving, as time goes by, the book will inevitably require an update. Existing items may need to be modified. New items will likely be added, and obsolete items remove. ​Need more proof? Josh is publishing Effective Java 3rd edition to accommodate for the rapid evolution of the language (namely Java 8 and 9). 

Needless to say, despite the rapid evolution of the Java language, for a book that was written when Java 5 and 6 was still prevalent, Effective Java performed remarkably against the test of time.

Whereas other books that were written during those times quickly became obsolete, Effective Java retained its authority as one of the Must Read books and guide to journeymen and senior Java developers.

RATING: 9/10

4.2 Summary


  • Extremely accurate and precise information.
  • Each item provides a way to improve your existing code. 
  • Quite a few concepts not only apply to Java, but also to other object-oriented programming language.
  • Re-reading value is arguably even greater than Clean Code.


  • As Java evolves, some of the items may become slightly inaccurate/incomplete or obsolete.

RATING: 9.33/10

Please Share if this Review Helped you

As always, I sincerely appreciate feedback. Please let me whether the book review or any of the contents on this site is useful or not by leaving a comment. That way, I can work on producing, tweaking and serving better content to those that come across this site. 

Also, if this article was helpful to you, please share it with those around you. If it is helpful, they will thank you for it. 

And if it is not helpful, please let me know right away. Feedback on specifically why it was not helpful would help me reproduce articles so that you and the other readers get the most out of it. 

Thank you for taking time to read through the review and catch you later!


About the Author Jay

I am a programmer currently living in Seoul, South Korea. I created this blog as an outlet to express what I know / have been learning in text form for retaining knowledge and also to hopefully help the wider community. I am passionate about data structures and algorithms. The back-end and databases is where my heart is at.

follow me on: