Running on Java 22-ea+15-1134 (Preview)
Home of The JavaSpecialists' Newsletter

The Java Specialist Master Course

Finishing School for the Professional Java Programmer

Using Java 6

Duration of 4 Days

During this 4-day course, we will study over 1000 slides of advanced Java topics. Each major section is followed by practical hands-on exercises to apply what you have learned. Even the most experienced Java programmer will be stimulated and challenged.

This course is ideally suited to the professional Java programmer with at least 2 years experience, who would like to learn how to truly master the Java Programming Language.

Is this course for you?

If you answer "yes!" to any of these questions, then this course is for you:

  • Would you like to become a true master of the Java Programming Language?
  • Would you like to truly understand threading, Java NIO?
  • Are you curious on how to write a small event-driven non-blocking server?
  • Would you like to understand the intricacies of Java memory, including tips on how to diagnose problems?
  • Have you ever wondered what possibilities exist in the reflection API?
  • Or wondered what data structures would be best suited to your application?
  • Or looked for better ways of managing exceptions?
  • Ever wanted to improve the performance of your Java program, but did not know where to start?

The Java Specialist Master Course is authored by Heinz Kabutz, the publisher of The Java Specialists' Newsletter.

"This course embodies my Java knowledge and experience gained publishing 200 advanced Java newsletters, teaching hundreds of seminars and writing hundreds of thousands of lines of Java code."
Heinz Kabutz, The Java Specialists Newsletter

Master Course Enquiry


This course is ideally suited to the professional Java programmer with at least 2 years experience, who would like to learn how to program advanced core Java.

Pricing Options

This course is unavailable. Please contact us if you would like to know of alternative courses.

Open Courses

All our courses are offered as in-house courses. Please contact us on

* Price is excluding EU VAT where applicable. Please contact us for an exact quote for your country.

Detailed Outline

The Java Specialist Master Course
The Java Specialist Master Course
1. IntroductionWelcome!Course organizationCourse contentsCourse overview2. Multi-ThreadingBasics of ThreadsThreading BackgroundThreading ModelsProcess vs threadParallel vs concurrentCreating NewThread GroupsStatesSynchronizedLocksPrioritiesTimersDaemon ThreadsThe Secrets of ConcurrencyInterrupted StatusWhat threads are doingLimiting # of ThreadsVisibility ProblemsEarly WritesCorrupt DataContentionJava Memory ModelHardware impactDeadlocksApplied Threading TechniquesExecutorsCount-down latchSemaphoreBlocking queuesAtomic VariablesVolatileExceptionsThread local variablesStopping ThreadsShutdown hooksThreading ProblemsRace ConditionsStarvationFairnessDeadlockLivelock3. Java IOObject Streams and SerializationObject SerializationSimple Object SerializationSerializable FieldsreadObject() / writeObject()Controlling SerializationExternalizableSerial Object VersioningCompatible Class ChangesIncompatible Class ChangesOverriding VersioningCircular ReferencesSerialization PerformanceSerialization PitfallsResetting StreamsJava New IO PackageMotivation for UsingWorking with BuffersAllocating BuffersBuffers AdvantagesChannelsMemory Mapped FilesNon-Blocking OperationsSelectorsNIO UsesEvent Driven ArchitectureCharacter Streams EncodingThe Unicode StandardForms of Unicode32-bit CharactersBig / Little EndianOther EncodingsOther Charsets - ISO 8859Charset ClassEncoders and DecodersCode Points4. Java MemoryGarbage CollectionOverviewGenerational SpacesGC TasksHeap FragmentationGC Pros and ConsAlgorithmsReachabilityHistoryJVM 1.4, 5, 6Young SpaceOld SpaceSummaryMeasuring GC ActivityPerformanceObject SizeUsing jConsoleManaging OutOfMemoryErrorTuning JVMJVM SwitchesNon-Standard SwitchesSizing Generational SpacesReferencesReference ObjectsObject ReachabilityUsing ReferencesSoftReferenceWeakReferencePhantomReferenceAbstractingReferenceQueueWeakHashMapSoftHashMapPerformance ImplicationsObject PoolingIntroductionReasons for not UsingThread PoolingDatabase Connection Pooling5. Reflection APIOverviewIntroductionUsefulness of ReflectionDangers of ReflectionExamining ClassesReflection PackageRetrieving Class ObjectsWorking with Class ObjectsAccessing fieldsAccessing methodsGenericsManipulating ObjectsWorking with objectsCreating new objectsGetting and Setting FieldsInvoking MethodsCasting through ReflectionFinal fieldsArraysWorking with ArraysElements' TypeCreating new ArraysGetting and Setting ElementsDynamic Proxy ClassesProxy DefinitionCreating new ProxyInvocationHandlerProxy ClassClassesWhen are Classes Loaded?How loadClass() worksImplementing own ClassLoaderThe defineClass Method6. Data StructuresBasicsIntroductionAbstract ClassesAlgorithm ComplexityData Structures & GCPrimitive Data StructuresNull ElementsType SafetyIterationIteratorsEfficiencyRandomAccessMultithreadingConcurrentModificationCopyOnWrite CollectionsNew "for-each" iterationIterable interfaceSortingCollections & ArraysSorting PerformanceComparisonsMapsTreesHashingJDK 1.4+ rehashingCompound KeysMap of MapsConcurrentHashMapLinked MapsSearchingGenericsOther StructuresMultimapQueuesDequesHeapsLRU Cache7. ExceptionsError HandlingClass HierarchyThrowable ClassException ClassError ClassStackTraceElementAbuse of ExceptionsUncaught ExceptionsAsynchronous ExceptionsCritical Errors Inside the JVMBest PracticesChecked vs. UncheckedAvoid Custom ExceptionsWriting Good ExceptionsWrap Low Level ExceptionsAvoid Catching "Programmer Bug" ExceptionsChain ExceptionsAvoid Swallowing ExceptionsCleanup After An ExceptionNever Abuse Exceptions for Flow ControlThrow Exceptions EarlyCatch Exceptions LateGood Throws ClausesDocument ExceptionsUnit Test ExceptionsAssertionsMechanism"assert" StatementDetecting if enabledWhen to UseWhen Not to UseJVM switchesWhy disable?Performance Issues8. Java OptimizationsLow LevelOverviewHigh LevelLow LevelWhen Not to UseMicrobenchmarkingFinding bottlenecksOptimization TechniquesOther OptimizationsCompilerRuntimeJust-in-TimeHotSpotProblem AreasTypical Problem AreasMethods DeclarationsObject CreationStrings and constantsLoopsBenchmarkingClass CastingGenericsOther AreasToolsProfiling ToolsHPROFHow to tune9. Dates and Time ZonesComputer TimeTime SynchronizationHuman Time InterpretationComputer SettingTime in JavaIntroductionjava.util.Datejava.util.TimeZonejava.util.Calendarjava.util.GregorianCalendarjava.util.DateFormatjava.sql.Datejava.sql.TimestampBest practices10. LoggingOverviewWhy log?Principal RequirementsMain Logging APIsJakarta Commons LoggingLog4j APIBuilding BlocksLoggerAppenderLayoutPrinciplesLogger HierarchyLevel InheritanceAppenders AdditivityConfigurationFrom ApplicationFrom XML FileBest PracticesDefining Logging SchemeLogging LevelsLog Messages FormatCentralized LoggingCode GuardsExceptionsReviewing LoggingImpact on PerformanceUnecessary StringsWriting to DiskAsynchronous Logging

The Java "Specialist" Course lasts 4 days.

We spend approximately 43% doing active hands-on labs.

Each days training starts at 9:00am and ends at 17:00, with about one hour of lunch and 30 minutes of tea / coffee / nicotene breaks.

Day 1:

  • Introduction: 0h
  • Multi-Threading: 4h lectures, 3h labs

Day 2:

  • Java IO: 2h lectures, 1.5h labs
  • Java Memory: 2h lectures, 1.5h labs

Day 3:

  • Reflection: 1h lectures, 45m labs
  • Data Structures: 2h lectures, 1.5h labs
  • Exceptions: 1h lectures, 45m labs

Day 4:

  • Java Optimizations: 2h lectures, 1.5h labs
  • Dates & Time Zones: 1h lectures, 45m labs
  • Logging: 1h lectures, 45m labs
  • Conclusion: 0h

Total lecturing: 16 hours

Total labs: 12 hours

  • 1. Introduction
    • Welcome!
    • Course organization
    • Course contents
    • Course overview

  • 2. Multi-Threading
    • Basics of Threads
      • Threading Background
        • Threading Models
        • Process vs thread
        • Parallel vs concurrent
      • Creating New
        • Thread Groups
        • States
      • Synchronized
      • Locks
      • Priorities
      • Timers
      • Daemon Threads
    • The Secrets of Concurrency
      • Interrupted Status
      • What threads are doing
      • Limiting # of Threads
      • Visibility Problems
      • Early Writes
      • Corrupt Data
      • Contention
      • Java Memory Model
      • Hardware impact
      • Deadlocks
    • Applied Threading Techniques
      • Executors
      • Count-down latch
      • Semaphore
      • Blocking queues
      • Atomic Variables
      • Volatile
      • Exceptions
      • Thread local variables
      • Stopping Threads
      • Shutdown hooks
    • Threading Problems
      • Race Conditions
      • Starvation
      • Fairness
      • Deadlock
      • Livelock

  • 3. Java IO
    • Object Streams and Serialization
      • Object Serialization
      • Simple Object Serialization
      • Serializable Fields
      • readObject() / writeObject()
      • Controlling Serialization
      • Externalizable
      • Serial Object Versioning
      • Compatible Class Changes
      • Incompatible Class Changes
      • Overriding Versioning
      • Circular References
      • Serialization Performance
      • Serialization Pitfalls
      • Resetting Streams
    • Java New IO Package
      • Motivation for Using
      • Working with Buffers
      • Allocating Buffers
      • Buffers Advantages
      • Channels
      • Memory Mapped Files
      • Non-Blocking Operations
      • Selectors
      • NIO Uses
        • Event Driven Architecture
    • Character Streams Encoding
      • The Unicode Standard
      • Forms of Unicode
      • 32-bit Characters
      • Big / Little Endian
      • Other Encodings
      • Other Charsets - ISO 8859
      • Charset Class
      • Encoders and Decoders
      • Code Points

  • 4. Java Memory
    • Garbage Collection
      • Overview
      • Generational Spaces
      • GC Tasks
      • Heap Fragmentation
      • GC Pros and Cons
      • Algorithms
        • Reachability
        • History
        • JVM 1.4, 5, 6
        • Young Space
        • Old Space
        • Summary
      • Measuring GC Activity
      • Performance
        • Object Size
      • Using jConsole
      • Managing OutOfMemoryError
    • Tuning JVM
      • JVM Switches
      • Non-Standard Switches
      • Sizing Generational Spaces
    • References
      • Reference Objects
      • Object Reachability
      • Using References
        • SoftReference
        • WeakReference
        • PhantomReference
        • Abstracting
      • ReferenceQueue
      • WeakHashMap
      • SoftHashMap
      • Performance Implications
    • Object Pooling
      • Introduction
      • Reasons for not Using
      • Thread Pooling
      • Database Connection Pooling

  • 5. Reflection API
    • Overview
      • Introduction
      • Usefulness of Reflection
      • Dangers of Reflection
      • Examining Classes
      • Reflection Package
      • Retrieving Class Objects
      • Working with Class Objects
      • Accessing fields
      • Accessing methods
      • Generics
    • Manipulating Objects
      • Working with objects
      • Creating new objects
      • Getting and Setting Fields
      • Invoking Methods
      • Casting through Reflection
      • Final fields
    • Arrays
      • Working with Arrays
      • Elements' Type
      • Creating new Arrays
      • Getting and Setting Elements
    • Dynamic Proxy Classes
      • Proxy Definition
      • Creating new Proxy
      • InvocationHandler
      • Proxy Class
    • Classes
      • When are Classes Loaded?
      • How loadClass() works
      • Implementing own ClassLoader
      • The defineClass Method

  • 6. Data Structures
    • Basics
      • Introduction
      • Abstract Classes
      • Algorithm Complexity
      • Data Structures & GC
      • Primitive Data Structures
      • Null Elements
      • Type Safety
    • Iteration
      • Iterators
      • Efficiency
      • RandomAccess
      • Multithreading
      • ConcurrentModification
      • CopyOnWrite Collections
      • New "for-each" iteration
      • Iterable interface
    • Sorting
      • Collections & Arrays
      • Sorting Performance
      • Comparisons
      • Maps
      • Trees
      • Hashing
        • JDK 1.4+ rehashing
      • Compound Keys
      • Map of Maps
      • ConcurrentHashMap
      • Linked Maps
      • Searching
    • Generics
    • Other Structures
      • Multimap
      • Queues
      • Deques
      • Heaps
      • LRU Cache

  • 7. Exceptions
    • Error Handling
      • Class Hierarchy
      • Throwable Class
      • Exception Class
      • Error Class
      • StackTraceElement
      • Abuse of Exceptions
      • Uncaught Exceptions
      • Asynchronous Exceptions
    • Critical Errors Inside the JVM
    • Best Practices
      • Checked vs. Unchecked
      • Avoid Custom Exceptions
      • Writing Good Exceptions
      • Wrap Low Level Exceptions
      • Avoid Catching "Programmer Bug" Exceptions
      • Chain Exceptions
      • Avoid Swallowing Exceptions
      • Cleanup After An Exception
      • Never Abuse Exceptions for Flow Control
      • Throw Exceptions Early
      • Catch Exceptions Late
      • Good Throws Clauses
      • Document Exceptions
      • Unit Test Exceptions
    • Assertions
      • Mechanism
      • "assert" Statement
      • Detecting if enabled
      • When to Use
      • When Not to Use
      • JVM switches
      • Why disable?
    • Performance Issues

  • 8. Java Optimizations
    • Low Level
      • Overview
      • High Level
      • Low Level
      • When Not to Use
      • Microbenchmarking
      • Finding bottlenecks
      • Optimization Techniques
    • Other Optimizations
      • Compiler
      • Runtime
      • Just-in-Time
      • HotSpot
    • Problem Areas
      • Typical Problem Areas
      • Methods Declarations
      • Object Creation
      • Strings and constants
      • Loops
      • Benchmarking
      • Class Casting
        • Generics
      • Other Areas
    • Tools
      • Profiling Tools
      • HPROF
      • How to tune

  • 9. Dates and Time Zones
    • Computer Time
      • Time Synchronization
      • Human Time Interpretation
      • Computer Setting
    • Time in Java
      • Introduction
      • java.util.Date
      • java.util.TimeZone
      • java.util.Calendar
      • java.util.GregorianCalendar
      • java.util.DateFormat
      • java.sql.Date
      • java.sql.Timestamp
    • Best practices

  • 10. Logging
    • Overview
      • Why log?
      • Principal Requirements
      • Main Logging APIs
      • Jakarta Commons Logging
    • Log4j API
      • Building Blocks
        • Logger
        • Appender
        • Layout
      • Principles
        • Logger Hierarchy
        • Level Inheritance
        • Appenders Additivity
      • Configuration
        • From Application
        • From XML File
    • Best Practices
      • Defining Logging Scheme
      • Logging Levels
      • Log Messages Format
      • Centralized Logging
      • Code Guards
      • Exceptions
      • Reviewing Logging
    • Impact on Performance
      • Unecessary Strings
      • Writing to Disk
      • Asynchronous Logging

About the Author

Heinz Kabutz Java Conference Speaker

Java Champion, author of the Javaspecialists Newsletter, conference speaking regular... About Heinz

Superpack '23

Superpack '23 Our entire Java Specialists Training in one huge bundle more...

Free Java Book

Dynamic Proxies in Java Book

110% Money-back Guarantee

Should you not be satisfied with the quality of the training or the delivery, we will gladly refund you 100% of the course fees. This needs to be brought to our attention within the first 4 hours of the course and a chance should be given to correct whatever you are not satisfied with. If you are still not satisfied, we will refund you 100% of the course fees, plus we will pay our own travel expenses. The training material then remains the property of JavaSpecialists.EU.

Cancellation Policy

If the course is cancelled more than two weeks before the start of the course, a 10% cancellation fee of the fees will apply, plus any non-refundable travel expenses incurred by the trainer.

If the course is cancelled within two weeks of the start of the course, a 50% cancellation fee of the fees will apply, plus any non-refundable travel expenses incurred by the trainer.

No refund will be given to cancellations during the course.

Java Training

We deliver relevant courses, by top Java developers to produce more resourceful and efficient programmers within their organisations.

Java Consulting

We can help make your Java application run faster and trouble-shoot concurrency and performance bugs...