Course curriculum

    1. Welcome

    2. Bootcamp Objective

    3. Bootcamp Logistics

    4. Audience Q&A

    5. What does a Java backend engineer do?

    6. The three tier architecture

    7. The CDN and how it works

    8. The REST API request flow

    9. Audience Q&A on REST and HTTP

    10. Cookies and sessions with HTTP

    11. Essential tools of the trade

    12. Audience Q&A on app servers

    13. Source control

    14. Introducing the GitHub workflow

    15. Audience Q&A on GitHub

    16. Homework

    17. Audience QA on SSR

    18. Understanding the GitHub workflow

    1. Data Types

    2. Wrapper classes

    3. Operators

    4. Hands-on exercises

    5. Arrays

    6. Classes

    7. Encapsulation

    8. Inheritance and polymorphism

    9. The static keyword

    10. Why is main static?

    11. Static vs instance methods

    12. Nested classes

    13. Inner class types

    14. Records

    15. Homework

    16. Audience Q&A

    1. Collections overview

    2. Equality and the equals method

    3. Rules for equality

    4. Walkthrough of an equals implementation

    5. Hashing and hash codes

    6. Equality and hash codes

    7. Hands-on exercise

    8. Time complexity

    9. Space complexity and tradeoffs

    10. Comparator and Comparable

    11. The iterator pattern

    12. Fail fast iterators

    13. The Collection interface hierarchy

    14. The List interface

    15. Amortized time complexity

    16. LinkedList

    17. Vector

    18. Autoboxing with Lists

    19. CopyOnWriteArrayList

    20. List iterators

    21. SubList

    22. Equals with List objects

    23. The Set interface

    24. HashSet

    25. HashSet load factor and capacity

    26. LinkedHashSet

    27. SortedSet and TreeSet

    28. TreeSet exercise

    29. NavigableSet

    30. The Map interface

    31. The Queue interface

    32. The Deque interface

    33. WeakHashMap

    34. Collections utility methods

    1. 1 Functional programming in Java

    2. 2 What is functional programming_

    3. 3 Functions vs methods

    4. 4 Limitations of Object Oriented Programming

    5. 5 First class functions

    6. 6 Introducing Lambda expressions

    7. 7 Lambda expression examples

    8. 8 Recommendation and Q&A

    9. 9 Functional interfaces

    10. 10 Typing lambdas with interfaces

    11. 11 Why Single Abstract Method_

    12. 12 Lambda hands-on coding

    13. 13 Interface typing, not SAM typing

    14. 14 Revisiting the task example with lambdas

    15. 15 The FunctionalInterface annotation

    16. 16 Lambda code demo

    17. 17 Lambdas vs anonymous classes

    18. 18 The interface overhead of lambdas

    19. 19 JDK functional interfaces

    20. 20 The Function interface

    21. 21 Consumer, Supplier and Predicate

    22. 22 JDK functional interfaces hands-on

    23. 23 Function arity

    24. 24 Operator interfaces

    25. 25 Method references

    26. 26 Method reference examples

    27. 27 Method references hands-on

    28. 28 Lambda calling lambdas calling lambdas

    29. 29 Composability with andThen and compose

    30. 30 Closures in Java

    31. 31 Pure functions

    32. 32 What are streams_

    33. 33 Declarative model

    34. 34 Stream API characteristics

    35. 35 The assembly line analogy

    36. 36 Streams code demo

    37. 37 Other ways to create streams

    38. 38 The toList method

    39. 39 Three key elements in Streams API

    40. 40 Streams vs collections

    41. 41 Limit and filter operators

    42. 42 The map operator

    43. 43 The peek operator and debugging

    44. 44 The effect of terminal operations

    45. 45 distinct and sorted operators

    46. 46 Concatenating streams

    47. 47 Working with object streams

    1. A typical Java project needs

    2. How Maven helps

    3. Project management with Maven

    4. Convention over configuration

    5. The Project Object Model

    6. Audience question about classpath

    7. Creating a Maven project in IntelliJ

    8. Examining pom.xml

    9. Maven project coordinates

    10. Running Maven targets

    11. Dependency Management

    12. Maven repositories

    13. Fetching a dependency from Maven Central

    14. Dependency Scopes

    15. Maven Versioning

    16. Maven Plugins and Goals

    1. Building the time tracker app

    2. Outlining the CLI experience

    3. Designing the data structures

    4. Coding start and stop tasks

    5. Accepting CLI arguments

    6. Setting up and running start task

    7. Refactor argument processing

    8. Switching to the new parser

    9. Running and troubleshooting

    10. Saving task information to file

    11. Refactoring all file related code into FilesUtil

    12. Add reporting for tasks

    13. Report categories

    14. Wrap up

About this course

  • Free
  • 175 lessons
  • 21 hours of video content