Working With Martin C Brown's Reference Books
I picked up a copy of the Java Complete Reference by Martin C Brown a few years back when I was trying to get serious about understanding the language beyond just writing quick scripts. It sat on my desk for about three months before I actually used it properly. The thing about these reference books is that they are not designed to be read cover to cover. They are designed to be opened at random and searched when something is not working. The book covers a wide range of Java topics, from basic syntax through the standard libraries, generics, concurrency, and more. Brown writes in a straightforward style that assumes you already know a bit and just need clarification on a specific point. I found the sections on exception handling and collections to be the most useful, mainly because those are the areas where most people hit problems in real projects. Here is something most tutorials do not tell you: the later editions of this book include coverage of newer Java features, but some of the API references skip over the nuances of how certain methods interact under the hood. I ran into this when I was debugging a collection modification issue. The book says ConcurrentModificationException happens when you modify a collection during iteration. That is true, but it does not explain the actual fail-fast mechanism in HashMap and related classes, or why adding elements through the iterator's own add method does not trigger it. I had to dig into the OpenJDK source to fully understand what was going on. The book gives you the surface-level answer, which is fine for passing interviews but not enough when production code breaks at 2 AM.
One practical tip that saved me time: Brown's sections on lambda expressions and the Stream API in the newer editions are reasonably solid, but they gloss over the performance implications of intermediate operations on large datasets. I once replaced a nested loop with a stream pipeline and watched runtime increase from about 3 seconds to nearly 45 seconds on a dataset of roughly 2 million records. The code looked nicer, but the overhead of boxing, intermediate stream creation, and lambda invocation added up. Going back to the imperative version brought it down to under 4 seconds. The book mentions performance briefly but does not hammer home how much of a difference there can be. If you are looking to download or access the book, the official publisher links from McGraw-Hill or major book retailers are the safest route. There are third-party sites offering PDF versions, but those tend to have outdated editions with pre-Java 8 content, which makes them not particularly useful for modern development work. Make sure you are getting at least the 10th edition if you want coverage of lambdas, streams, and the module system. The main downside of this book, in my experience, is that it tries to cover too much ground in a single volume. Some chapters are only a few pages long and barely scratch the surface. The concurrency chapter, for example, is adequate for understanding the basics but will leave you exposed if you are building anything with complex thread interactions. I ended up supplementing it with explicit deep-dives into the java.util.concurrent package documentation and a separate book specifically on concurrent programming.
Overall it is a decent shelf reference. Keep it within arm's reach. Do not expect it to solve every problem. Use it when you need a quick lookup on syntax or a concept you have not touched in a while. For anything beyond that, you will need other resources regardless of what edition you own.
Get the Full Details
