Improve your coding skills from beginner to expert with the largest online Java e-learning platform

Java Advanced Topics

Featuring logging, generics, threading, lambda functions, memory management and collections.
  • This Advanced Java Training Course dives into topics that most professional Java developers will find invaluable.
  • The course is divided into 6 sections:
  • 1 - Collections : sorting lists and an in depth look at ArrayLists, LinkedLists, HashMaps and LinkedHashMaps.
  • 2 – Logging: How to get the most from your logging with Log4J, JUL (Java Util Logging), and Commons Logging.
  • 3 - Generics: How to use generics, creating our own generic classes and methods, dealing with warning messages. We also explain the complexities of the advanced generics syntax that you see in the Javadocs.
  • 4 – Lambda Functions: how functional programming is possible in Java 8, including functional interfaces and streams.
  • 5 – Threading: creating multi threaded applications, and underestanding the risks of threading. Including deadlocks, thread safety, and Java 5 concurrency features
  • 6 – Memory: we go deep into how memory works in Java - what's really happening in your programs. Including garbage collection, finding memory leaks, monitoring application performance, and tuning the JVM.
  • The course is written with Java 8, although all chapters except section 4 can be studied using Java 7 if preferred.
  • Please note that most of parts 1 and 6 of this course have been updated for Java 11 and can be found in our Optimising Application Performance course.

Pre-requisites

This course is aimed at Java developers with some experience working on Java projects.

Newer programmers will be able to follow the course as long as they have already learned the basics of java programming. We recommend you take Virtual Pair Programmers’ Java Fundamentals Course before starting Java : Advanced Topics.

The course is ideal for developers working with frameworks like Spring and Hibernate. There are a number of example spring and hibernate projects, taken from Virtual Pair Programmers’ other courses, which feature in this course, although you do not need any prior knowledge of Spring or Hibernate to take this course.

If you’re still a relatively novice java programmer, then don’t worry – you’ll be able to follow this course as long as you have learned the basics before you start – we recommend you take Virtual Pair Programmers’ Java Fundamentals Course – certainly that covers all the pre-requisites for this course.

Contents - contains over 12 hours of video - equivalent to 4 days of live training.

 

Having problems? check the errata for this course.

1

Introduction


9m 50s
An overview of the course

2

Sorting Lists


24m 1s
How to sort Lists in Java, with the Comparable and Comparator interfaces.

3

Types of List


25m 44s
An in depth look at the ArrayList and LinkedList.

4

How HashMaps Work


23m 22s
How HashMap data is stored, and the purpose of the hashCode. How Linked HashMaps work.

5

Beginning Log4j


36m 1s
Why to use logging, what are logging events, appenders and severity levels, and how to configure version 2 of Log4J.

6

Going Further with Log4j


30m 3s
We explore the differences between versions 1 and 2 of Log4J, and see a working example with Spring. We’ll cover the rolling file appender, logging exceptions, and how to optimise logging code.

7

Java.util.logging


19m 55s
Differences between Log4J and JUL, and a worked example in JUL.

8

Logging facades


19m 41s
Why logging facades are used, and we’ll see Commons Logging in action. We’ll talk about SLF4J and JBOSS also.

9

Introducing Generics


14m 56s
What problems do Generics solve, and using built in Java classes that support generics.

10

Writing Generic Classes and methods


21m 15s
Creating our own generic classes and methods.

11

Handling Generics compiler warnings


27m 10s
Understanding the warning messages that Eclipse gives us when we use Generics, and strategies for resolving the warnings.

12

Generics with Wildcards


16m 50s
Approaches to using collections with multiple object types (interfaces, inheritance and Wildcards), and how to understand the complexities of generics syntax.

13

Lambdas in Java 8


34m 29s
An overview of functional programming and how it can add to the Java object model. Functional interface and lambda expression syntax.

14

Built in Functional Interfaces


24m 56s
The Function, Supplier, Consumer and Predicate functional interfaces and their variants.

15

Lambas with Collections


18m 52s
Using the forEach method and sorting collections with Lambdas.

16

Introducing Streams


28m 14s
Manipulating collections using the new Java 8 Stream objects.

17

Lambdas Practical


21m 54s
A chance to put the lambda functionality into practice on a project.

18

Introducing Threading


10m 57s
What is threading and how modern processors work.

19

Writing a Thread


15m 35s
Writing our first threading code.

20

Synchronization and Thread Safety


22m 14s
The problems of thread-safety, the synchronized and volatile keywords.

21

Collections Thread Safety


24m 24s
Using collections in multi-threaded applications.

22

Thread Safety in Web Applications


13m 54s
How to ensure web applications (including Spring MVC) are thread-safe.

23

Avoiding Deadlocks


21m 20s
The problem of synchronization deadlocks and the wait and notifyAll methods.

24

Thread Process Flow


18m 49s
How to interrupt and chain threads. Should I catch the InterruptedException?

25

Java 5 Enhancements


31m 9s
How to create thread pools with Executor Services, the Callable interface, Locks and Conditions.

26

Memory Fundamentals


18m 30s
How java manages memory, explaining the stack and the heap.

27

Values and References


25m 1s
How varaibles are passed into methods, by value or by reference and what this means.

28

Escaping References


36m 10s
The problem of escaping references and strategies to avoid them.

29

Garbage Collection


42m 24s
Introduction to garbage collection, string itnernalization, garbage collection eligibility, the finalize method, and memory leaks.

30

Generational Garbage Collection


26m 45s
An in depth look at how the JVM collects garbage in an efficient way, monitoring the garbage collection process, and understanding PermGen memory issues.

31

Tuning the Virtual Machine


17m 14s
Options for adjusting the default behaviour and settings of the virtual machine.

32

Hunting for Memory Leaks


26m 2s
A practical session where we’ll looking at a real web application to detect and fix a memory leak.

33

Weak and Soft References


5m 59s
Weak references, Soft references and WeakHashmaps.

34

Course Summary


3m 41s
A final farewell

Let the Course Come to You

About Us Pricing Frequently Asked Questions Contact Privacy T&Cs Affiliates and Resellers
Facebook Twitter YouTube LinkedIn