eXtreme Java


24 Hours

The Java programming language was born in 1995. During the years it has become the most popular software programming language in the world ( During the last years the Java programming language was extensively expanded and its new versions (Java 5 & Java 6) were released. This course focuses on thoses extensions as well as on those parts of the language that are less known to the common developer and aims at providing the experienced Java programmer with the details and the understanding of these topics.
Please note that the topics listed below are the topics we recommend based on our familiarity with the Java software development market. We recommend you to check the other available topics as reflected in our detailed core Java topics excel document available at If there is a specific required topic you don't find in this list please don't hesitate and let us know. Please don't hesitate and let us know of your needs. We would love to tailor the exact course accordingly.

Java Programmers

Understand Java newest extensions and be capable of using them effectively in order to create faster and more robust Java applications.

Practical experience in developing Java applications.

Multi Threading
Threads Overview
Threads Benefits
Threads Importance
Threads Pitfalls
Threads Starvation
Inheritance versus Runnable Implementation
Stopping Threads
Suspending Threads
Threads Communication
Thread Safe Classes
Exceptions & Threads
Slicing & Preemptive Scheduler
Priority Pools
Threads Scheduling
Join Method
Yield Method
Synchronized Method
The wait & notify Methods
Daemon Threads
User Threads
Thread Dump
Blocking Queues
Thread Safe Collections
Callables & Futures
Threads Pools
Synchronizer Classes
Cyclic Barrier

I/O Streams
I/O Streams Overview
I/O Streams Categories
Byte & Char Streams
The InputStream Abstract Class
The OutputStream Abstract Class
Writing & Reading to/from Files
The Reader Class
The Writer Class
Streams Chaining
The InputStreamReader and OutputStreamWriter Classes
The URL Class
Objects Serialization
The File Class
The RandomAccess File
The Path Class
The FileRef Interface
Checking Files
Comparing Paths
The FileChannel Class
The Attributes Class
The FilesSystem Class
The PathMatcher Class
Symbolic Links
Files Iteration
The WatchService API
Reflection Capabilities
What is Reflection
Reflection Benefits
Reflection Drawbacks
The Class Class
Retrieving a Class Object
The .class Syntax
The Class.forName() Method
Primitive Types
Class Methods
The Method
Constructor & Field Methods
Class Modifiers & Types
Discovering Class Members
The Field Class
The Method Class
The Constructor Class
Class Instantiation
Arrays in Java
Identifying an Array
Creating Arrays
Accessing Arrays
What are Generics
Collections using JDK 1.4
Collections using JDK 1.5 (and above)
Generics Basic Usage
Declaring Generic Class
Generics Subtypes
Generics Wildcards
The Object Class
Bounded Wild Card
In Depth Understanding
One Class
Static Variables & Methods
The instanceof Operator
Generics & Class Type Casting
Generics Parameterized Type Info
Generics & Arrays
Introduction to Assertions
Assertion Structure
Agile Methodologies
Assertion Importance
Unexpected Errors
Assertions & Exceptions
Design By Contract Methodology
Assertion Syntax
Command Line Control
Programmatically Control
Catching Assertions
Practical Examples
Consistent State Examples
Range of States Examples
Regular Expressions
What is Regular Expression
Using Regular Expressions
Regular Expressions Syntax
Simple Regular Expression Code
Meta Characters
Character Classes
What is Character Class
Available Character Classes
Simple Character Class
Negation Character Class
Ranges Character Class
Unions Character Class
Intersections Character Class
Subtraction Character Class
Predefined Character Class
Logical Operators
X followed by Y
X or Y
X as a Capturing Group
What is a Quantifier?
Quantifiers Types
Greedy Quantifiers
Possesive Quantifiers
Reluctant Quantifiers
Zero Length Matches
Occurrences Cannot Overlap
X? X?? and X?+
X* X*? and X*+
X+ X+? and X++
The n Times Quantifier
The n (at least) Times Quantifier
The n
m (range of) Times Quantifier
What is a Capturing Group?
Capturing Groups Numbering
Back Referencing
What is a Boundary Match?
The \b Word Boundary
The \B Word Boundary
The \z End of Input Boundary
The $ End of Line Boundary
The Pattern Class
The UNIX_LINES Static Field
The COMMENTS Static Field
The MULTILINE Static Field
The DOTALL Static Field
The CANON_EQ Static Field
The compile() Method
The pattern() Method
The toString() Method
The flags() Method
The matches() Method
The split() Method
The Embedded Flag Expressions
String's Pattern Methods
The Matcher Class
The Index Methods
The start() Methods
The end() Methods
The Quick Search Methods
The lookingAt() Methods
The matches() Methods
The find() Method
The Replacements Methods
String Matcher Methods
What is Annotation?
The @Test Annotation
Parameterized Annotation
What Can We Annotate?
The Annotation Interface
Annoatation Definition
Using Annotation
Element Default Value
Marker Annotation Syntax
Single Value Annotation Syntax
The Annotation Interface
The Annotation Elements Types
Annotatios Possibilities
Standard Annotation
The @Deprecated Annotation
The @SuppressWarnings Annotation
The @Overrides Annotation
The @Generated Annotation
The @Target Annotation
The @Retention Annotation
The @Documented Annotation
Processing Annotations
The AbstractProcessor Class
The TypeElement Interface
The RoundEnvironment Interface