Taming the Tiger, an article archive about Java 5 resources

I found a link to a Java 5 article resource at the IBM developer works website.

one article in particular I found useful, it gives a good overview of what you will be tested on the SCJP Java 5 exam. There is also a good article about collections

It had a good summary of the Exam objectives in no particular order

The seven categories of objectives for the exam are as follows:

• Declarations, initialization, and scoping
• Flow control
• API contents
• Concurrency
• Object-oriented concepts
• Collections/generics
• Fundamentals

Declarations, initialization, and scoping

The initial section describes everything you need to know about the basics of the Java programming language. Expect to be tested on covarient return types, JavaBean naming conventions, and the ability to read nested class listings. Here is also where you are expected to develop classes and interfaces, understand abstract classes, deal with the differences of static and non-static methods and variables, and work with constructors and return values. There's nothing here that should sound too complicated to an experienced developer, but there are some things thrown in to trip you up. For example, don't assume that just because code lines up at the same tab stop that it is a method for the same class. Instead, ignore white space and tab stops when reading code. Expect little tricks like that to try to confuse you. Remember: follow the {}s.

Flow control

Most people should find this section easier than the others, having to deal with the familiar for-loops, while-loops, and do-while loops. However, it also includes content about the assertions and for-each loops. The other big section of content to explore here is exception handling. If you have a good grasp of try-catch-finally and where exceptions come from, you should do fine here.

API contents

This topic is mostly a catchall for those that don't fit elsewhere. It might require a good amount of study time if you have not used certain areas of the platform. Most of you should be familiar with working with the I/O streams for bytes and characters, but some of you might be unfamiliar with object serialization. You may be less familiar with locales and formatting dates and numbers.

The 1.4 release introduced regular expression handling, and it is covered here too. Also, there is the different primitive wrapper classes with autoboxing/unboxing and the string handling classes of String, StringBuffer, and the new StringBuilder. If you aren't familiar with StringBuilder, be sure to learn how it is different from StringBuffer.

Lastly, there is the reading and writing of formatted input and output using the new Scanner and Formatter classes. Because of the broad nature of this topic, don't feel like you should spend an equal amount of time studying each; give yourself at least twice as long for this section.

Concurrency

The concurrency section is not about the new java.util.concurrent package. Instead, it is about understanding the use of Thread and Runnable, along with the proper use of synchronization, wait(), notify(), and notifyAll(). You should know how and when to lock objects properly when accessing critical sections of code.

Object-oriented concepts

The object-oriented concepts section requires that you have a good understanding of object-oriented programming principals and practices, like when to use inheritance, how to implement is-a and has-a relationships, and the differences in overriding and overloading methods. If you understand why you want loose coupling tied to high cohension and can describe its benefits, you should do well here.

Collections/generics

One of 5.0's bigger additions is with generics. You'll need to understand the differences between the various collection types, when to use each, and the importance of overriding both hashCode and equals. You'll need to know how to write generic methods and classes -- not just use them. You should expect to be tested on dealing with sorting through both the Comparable and Comparator interfaces. If you haven't used generics much, you should spend some time focusing on this area.

Fundamentals

The fundamentals section requires you to understand various key aspects of the language, tools, and underlying virtual machine. You can expect questions on garbage collection, operator precendence and usage, access modifiers, JAR files, and the class path. Be sure you know the difference between primitive and object references and the autoboxing features found in 5.0.