(Part 2) Top products from r/java

We assign mentors (usually the more experienced team members, but can vary depending on project and resourcing requirements) to new guys who will help them get to grips with things like our methodologies, coding standards, etc.

If we end up with a team consisting of a lot of guys without TDD experience (rare, but my teams can vary depending on other projects/resources within my company), we'll occasionally run TDD workshops where one of my senior guys or myself will go through a fill worked example of TDD, and then point the new guys in the direction of suitable resources so they can self learn (although we support them as much as required).

In terms of resources, there are a number of books we have on our internal "recommended reading" list:

1. The Clean Coder : A Code Of Conduct For Professional Programmers by Robert C. Martin (http://www.amazon.com/The-Clean-Coder-Professional-Programmers/dp/0137081073). This is a good book for developers in general, but has a good section on TDD.
   
   
2. Test Driven Development : By Example by Kent Beck (http://www.amazon.com/Test-Driven-Development-Kent-Beck/dp/0321146530/ref=sr_1_1?s=books&ie=UTF8&qid=1458766760&sr=1-1&keywords=kent+beck). Kent Beck is one of the leading proponents of TDD, and this is well worth a read. I find that the fact the text is example driven really helps our developers relate TDD principals to actual real life situations.
   
3. xUnit Test Patterns : Refactoring Test Code by Gerard Meszaros (http://www.amazon.com/xUnit-Test-Patterns-Refactoring-Code/dp/0131495054). This is a bit more advanced and goes above why and how to use TDD - in fact, it's not specifically about TDD, but rather just unit tests in general. However, it explains ways and patterns that can be used to design your code and your tests correctly in order to produce quality tests.
   
   There's a lot of information on the web, but I find sometimes books are just the best source.

I've heard good things about these two:

• http://www.amazon.com/Java-Program-Early-Objects-10th/dp/0133807800/
  
• http://www.amazon.com/Head-First-Java-Kathy-Sierra/dp/0596009208/
  
  My first Java book was:
  
  
• http://www.amazon.com/Java-Programming-Language-4th/dp/0321349806/
  
  Although I enjoyed it a lot it's extremely weak on exercises (besides teaching java 1.5 (iirc)).
  
  The java tutorials are quite good, but lack on the exercises area, which is sort of crucial to learning how to program.
  
  
• https://docs.oracle.com/javase/tutorial/
  
  It's good too keep those tutorials in mind though because they're great as a first read on a particular piece of the java language and/or library.
  
  I think the best mix of learning java and learning how to program among these books is in the one by Paul and Harvey Deitel.
  
  Another good one on Java is the "Core Java" two volumes pack:
  
  
• http://www.amazon.com/Core-Java-I--Fundamentals-10th/dp/0134177304/
  
• http://www.amazon.com/Core-Java-II--Advanced-Features-10th/dp/0134177290/
  
  Although they're also weak on exercises, I remember the second volume being filled with examples.
  
  By the way, don't get discouraged by the sizes of those books. They're big not because they're difficult, but because there are lots of things to talk about. Generally speaking, all these books are mostly easy.

I used this book,
http://www.amazon.com/Introduction-Programming-Comprehensive-Version-Edition/dp/0132936526/ref=zg_bs_3608_53

There are probably other good books, but I really liked this one. It has a broad range of topics and examples.

Also, I didn't start programming until college. Starting at 14 is awesome! You're going to be amazing by the time you graduate!

You mentioned Robert Sedgewick. His book, Algorithms and his online courses are highly recommended. And he uses Java in them.

http://www.amazon.com/Algorithms-4th-Edition-Robert-Sedgewick/dp/032157351X
http://algs4.cs.princeton.edu/home/

For object-oriented design the Head First books are great. It also worth to have the classic book Design Patterns: Elements of Reusable Object-Oriented Software.

http://www.amazon.com/dp/0201633612

I also recommend the books Code Complete, and Clean Code, they are great.

You can also check out the Java tutorials and the Java EE tutorials, but these might be a little on the light side compared to books devoted to the topic.

The Core Java Volume I and Core Java Volume II by Cay Horstmann are the best books I've read for learning Java. Some people like the Head First series.

Effective Java is a must read.

Because it sounds like you already have a ton of experience with language fundamentals, best practices and design I would recommend Java: The Complete Reference. It reads more like a reference guide and covers the entire language up through Java 8. I'm sure this would suffice to just pick up the differences and nuances between the two languages.

Sure, glad I could help. It sounds like you're having some difficulties with the fundamentals of object-oriented programming. The Java tutorials are good, but they are focused on the Java specifics and don't really go into the bigger picture.

For that, I would highly recommend Agile Software Development, Principles, Patterns, and Practices by Bob C. Martin.

didn't read it, but from the index and reviews I read about it it seems good: http://math.hws.edu/javanotes/

for me I started with this book: Java how to program
it contains all the basics for J2SE so you will have an idea about each topic and you can expand the knowledge on your own.

if you are a beginner stay away from design patterns and effective java, once you learn the basics of the language and OOP you can move to these, also stay away from certification books, they are not for learning a language but rather for passing an exam.

I have Beginning Java. It's very comprehensive, but geared towards beginners. So it can get dry at times. Great reference for later on.


Only downside is, it's not one of those learn java fast books. It covers everything properly and thoroughly.
Also pretty cheap for such a large book.

I'm only about 6 chapters into volume 1, but I'm really enjoying Core Java by Cay Horstman and Gary Cornell. It assumes previous programming knowledge. My only issue with it so far is that there are no exercises to work through.

I also hear Thinking in Java is the defacto standard on how to learn it though, but I don't know if it assumes previous programming knowledge or not.

I started with C++ so the C++ comparisons throughout are helpful to me.

If you're interested in Core Java:

Volume I - http://www.amazon.com/Core-Volume-I-Fundamentals-Edition-Series/dp/0137081898/ref=dp_ob_title_bk

Volume II - http://www.amazon.com/Volume-II-Advanced-Features-Edition-Series/dp/013708160X/ref=pd_sim_b_1

You might be interested in this book, dated but still quite relevant. Has a nice animation framework that it walks you through:

https://www.amazon.com/Killer-Game-Programming-Andrew-Davison/dp/0596007302

There are free draft chapters online:

http://fivedots.coe.psu.ac.th/%7Ead/jg/

My college uses Introduction to Java, Comprehensive Edition. We'll be using it for 4 full semesters, and I think there will still be a chapter or two we don't cover. It has 34 Chapters in the book then 16 online chapters that covers a lot of topics covering Java EE, JSP, etc. It starts at the beginner level and goes from there.

However, despite its size it still doesn't go too in depth in many topics. For example, I'll be taking Java concurrency class next semester. We'll be starting with the concurrency chapter in the Intro to Java book and then we'll be moving to Concurrency in Practice by Brian Goetz.

This os only the second of two Java books I have exposure to, so I can't really rate it against any others, but it seems pretty good overall, though slightly vague on a few topics.

Today the defacto way to design something is though tests. Some people might disagree with me here but I believe that Test Driven Development can help. You may want to do a small top level design but before you write any code you must always write the unit test for that code first. This way you can see how it is going to be used before you spend time coding it. Each of your tests should represent a piece of functionality in the code base. As you write each test you implment just enough code to get it to pass before you move on to the next one. Never regressing by letting old tests fail.

I usually start with a top level class and work out it's relationship to other objects in the design through interfaces. Then I'll write tests for each of the dependent objects and work top down like this. This is known as the London style TDD. There are other ways as well.

I reccommend this book:

Growing object orientated design through tests

Also this one, (but it's a bit long winded and it's a different style of TDD)

Test Driven - Kent Beck

Also, for those interested, you can buy the 8th edition of this book used on Amazon for a fraction of the cost of the 9th edition. A quick comparison of the table of contents shows an almost identical chapter structure, and there was less than 2 years between publications, so it's likely that not much changed between the two books.

Someone more knowledgeable in JAVA updates and the differences between them could probably better answer if anything significant happened between 2009 and 2011 that would justify the difference in cost between the two editions.

Amazon link to 8th Edition

Amazon link to 9th Edition

I also highly recommend the book Filthy Rich Clients if you want to read up on this.

You can't go wrong with these two books:
http://www.amazon.com/Java-Puzzlers-Traps-Pitfalls-Corner/dp/032133678X/

http://www.amazon.com/Effective-Java-Edition-Joshua-Bloch/dp/0321356683

Joshua Bloch is a good author and was involved in implementing the Java API (collections API, etc.) early on...

You can also find several talks he's done online for Java puzzlers.

Some good presentations online (including some puzzler ones):
https://www.youtube.com/results?search_query=joshua+bloch

I'm not sure there is any, depending on the level of detail you need you might have to read the source code. This book is very detailed on certain parts of it: "Java Performance" -> http://www.amazon.co.uk/Java-Performance-Addison-Wesley-Charlie-Hunt/dp/0137142528/ref=sr_1_2?ie=UTF8&qid=1449831270&sr=8-2&keywords=java+performance

At least in terms of garbage collection and how the JIT compiler works it covers those well. It also has a lot of stuff other than that, like how to troubleshoot memory issues in a unix/windows box

I used the 2nd edition of this when I was studying Java. It was good then so I'm assuming the later versions are just as good. http://www.amazon.com/Data-Structures-Algorithms-Michael-Goodrich/dp/0470383267

The Core Java books are a great resource.

Study more about Java. If you can afford this book, then it'd be amazing. Complete Java knowledge right there including topics that deal with Threads, Generics, etc. All the essentials a Java programmer should know.

This is because in Android, you'll be dealing with a lot of Inner/Anonymous classes, Inheritance/Abstract classes, and Generics.

Java and JavaScript are completely different. However programming languages share similar structures in general.

I like the book (AMAZON LINK) Java, How To Program, 10th Edition

I can't recommend this book enough - http://www.amazon.com/Java-Performance-Definitive-Scott-Oaks/dp/1449358454

O'Reily's Java Performance Definitive 1st Edition. It has everything you'll need. The section on the "new" G1 collector is special.

If you want to get a head start at the college, I'd rather get more fundamental programming knowledge. Get a book about algorithms and datastructures (e.g. this or this, first few Google results pointed me to a PDF).

Well of course practical knowledge is also never bad.

I really like Java Puzzlers.

I'd start with a classic: Patterns of Enterprise Application Architecture by Martin Fowler. He blogs a lot on topics related to enterprise architecture.

I'd follow up with another classic: Domain Driven Design by Eric Evans. Martin Fowler has a lot to say about DDD as well

Oi, caution against taking the advice in that article too seriously; the article is barely readable and has at least a few mistakes. For example, this syntax is incorrect:

public V put(K key, V value) {
return cache.put(key, value);
}
You need to let the compiler know that K and V are generic type placeholders, so the proper syntax is

public <K,V> V put(K key, V value) {
return cache.put(key, value);
}
Java Generics is a great a resource for those trying to get familiar with Java Generics and Collections.

I liked "Core Java", but it is not as concise as Kernighan/Ritchie.

This is the text I used to learn elementary Java programming:

https://www.amazon.com/Introduction-Java-Programming-Comprehensive-Version/dp/0132936526

at the end of each chapter is a set of exercises... we're talking about 20-30 or more exercises.

I'm actually re-studying basic java because I have an advanced java course this fall. I'm just going back to each chapter, read through it, and doing every.single.exercise.

It gets repetitive very quickly, but that's what I want: to know the basics so thoroughly that I don't have to think in order to type or use them in basic scenarios.

The main point for me is to do the basic exercises so much that when I start this advanced Java course this fall, i'm not re-learning any of the basics. if you're willing to spend $15 to get an old copy, it might be worth it.

Or find a pdf online if you don't care about paying for it. That works, too, I guess.

User OwlShitty in another thread recommended this as a study guide.

>Complete Java knowledge right there including topics that deal with Threads, Generics, etc. All the essentials a Java programmer should know.

Resources:

Kathy Sierra's study guide


Enthuware mock tests

That is a pretty good combo. Read the book, do the mock tests. If you get 70% on the final mock test, you are good to go.

You missed:

Filthy Rich Clients

http://www.amazon.com/Filthy-Rich-Clients-Developing-Applications/dp/0132413930

Not so relevant now that JavaFx is here, but still a good way to understand how to properly write Swing code that doesn't put Java to shame.

Java Concurrency in Practice

http://www.amazon.com/Java-Concurrency-Practice-Brian-Goetz/dp/0321349601

A must read for anyone writing multicore code on the JVM.

Its not advertised but it uses Java for the examples.

http://www.amazon.com/Algorithms-4th-Edition-Robert-Sedgewick/dp/032157351X

Java How To Program (first edition):
https://www.amazon.com/Java-How-Program-9th-Deitel/dp/0132575663

We used HeadFirst Java and Data Structures and Algorithms in Java

for my first year


Source:

http://www.amazon.ca/Head-First-Java-Kathy-Sierra/dp/0596009208/ref=sr_1_sc_1?ie=UTF8&qid=1405444231&sr=8-1-spell&keywords=HeadFirst+hjava


http://www.amazon.ca/Data-Structures-Algorithms-Michael-Goodrich/dp/0470383267/ref=sr_1_1?ie=UTF8&qid=1405444258&sr=8-1&keywords=data+structures+and+algorithms+in+java

I realize these are older titles but java is still built on the same principals.

http://www.amazon.com/Head-First-Java-2nd-Edition/dp/0596009208
http://www.amazon.com/Ivor-Hortons-Beginning-Java-Horton/dp/0470404140/ref=sr_1_1?s=books&ie=UTF8&qid=1407753555&sr=1-1&keywords=beginning+java

i'm using Java: The Complete Reference by Herbert Schildt for syntax and general overview of the language and it's packages and such...

I'm also going through Stanford's CS106A which is a programming methodology class that uses Java 5... there are about 28 lectures with transcripts, assignments, handouts, exams and all that available at that link.

there is a lot of redundancy in the two resources i'm using, but the book is concise with it's progression through the language, while the methodology lectures are a bit more pragmatic.

Did you get your start with Killer Game Programming in Java? . The timing loop reminds me of reading that a while back, but I bet that's a common enough way to do it.

Someone made a comment about this yesterday: here

The article is extremely informative, enough so that I immediately ordered a copy of Java Generics and Collections.

Java Generics and Collections

http://www.amazon.com/Java-Generics-Collections-Maurice-Naftalin/dp/0596527756

Java Performance: The Definitive Guide

I think Java Performance and Java Concurrency In Practice are two of the main ones. Especially JCIP is the reference for concurrent programming.

I cannot recommend The Java Programming Language highly enough. It was written by the creator of Java, and it shows. It's the reason I've spent my 12 year programming career using Java.