Course Description
You will learn how to develop using Java from the beginning. We will use Eclipse, Java 8, Maven and JUNIT and a little bit of imagination to create fun exercises so you don't get bored.
We will jump right into the fun stuff. First we will install what is necessary, then start coding and understand the principles of Java as we do it.
At the end of the beginners part of this course you will be able to develop small application in Java using clean and solid code.
After leaning how to develop in Java from the beginning we will jump to algorithms and data structures
We will code together the following algorithms:
Euclid, Linear Search, Insert Sort, Binary Search, Quick Sort
and for data structures we will code the following:
Binary Tree, Linked List, Doubly Linked List, Prefix Tree or Trie Tree, Stack
Finally some coding interview questions Print Odd Numbers, Longest Substring Without Repeating Character (Amazon Question), Sudoku (Amazon Question)
This is not just one of the most feared subjects in the computer science world but it is also one of the hottest topics. algorithms and data structures are very important topics since your choice of algorithm and data structure will affect memory and CPU time differently.
This topic will also help your daily coding as it did to me. There are hundreds of different algorithms and data structures but we will cover just a few of the most popular and one that might help you on your current project.
What am I going to get from this course?
- Prepare the development environment to work with Java
- Learn the Java Language
- Learn the most popular algorithms and data structures
- Write algorithms and data structures with confidence
- Think out of the box when solving daily problems
- Understand the importance of unit testing your application
- Get a basic understanding of Maven
- Learn how recursion works
- Practice with some interview coding questions
- Code a Sudoku solver
Prerequisites and Target Audience
What will students need to know or do before starting this course?
Internet connection and a computer
Who should take this course? Who should not?
- Anyone interested in learning Java
- Learning and/or improving the algorithms and data structure skills
- Preparing for an interview
Curriculum
Module 1: Installation and Setup
11:44
Lecture 1
Eclipse Installation
02:02
In this lecture, we will download and install eclipse so that we can get started with our next lecture. If you already have eclipse installed or you want to use your own editor then skip to the next lecture.
Lecture 2
Create the First Project
09:42
In this lecture, we will create a Maven project and run through Eclipse.
You will get familiar with the IDE that we will use to develop, debug and execute.
Module 2: Learning Java
03:56:39
Lecture 3
Creating Packages
04:46
In this lecture, we will create a Maven project and do a quick run through Eclipse for you to get familiar with the IDE that we will use to develop, debug and execute.
In this lecture, you will learn what a Class is. I will teach you what the structure of a class and we will also create a class with a constructor.
Lecture 5
Attributes and Constants
11:43
In this lecture, you will learn and code attributes and constants
In this lecture, you will understand what the methods are for. We will code a few of them and also implement another class with more methods. You will be able to understand the link that the method does between classes and attributes.
Lecture 7
Primitive Types and Reserved Words in Java
04:36
In this lecture, you will learn about the reserved words and all the primitive types which are used as a type of variables in Java.
Lecture 8
Operators
08:46
In this lecture, you will learn the java operators. including:
Arithmetic Operators
Relational Operators
Logical Operators
Assignment Operators
Conditional Operator
Instance Operator
Lecture 9
Decision Making - if condition
10:13
This lecture will teach you about if else condition.
Lecture 10
Loop Control
11:46
In this lecture, you will learn about for, while and do-while loops
Lecture 11
Methods and Hierarchy 1 of 4 Implementation Plan
02:56
This lecture is a presentation of what we are going to develop. It also contains a basic UML which will explain what we will accomplish with the classes that we are designing.
There are 3 more lectures after this one with just coding
Lecture 12
Methods and Hierarchy 2 of 4
19:15
In this lecture, we will code what was planned on the previous lecture. The coding will extend for 2 more lectures after this one.
We will implement multiple classes and connect all of them together either using just creating an instance or inheriting from a super class
Lecture 13
Methods and Hierarchy 3 of 4
19:43
In this lecture, we will continue coding our Pizza application started on the lecture 8. The next lecture will be the last lecture of the sequence for hierarchy. Using extends and polymorphism to use the Crust and the Topping
Lecture 14
Methods and Hierarchy 4 of 4
12:34
In this lecture, we will finish the implementation of our Pizza. It will calculate the total price for the pizza. The total calories was not implemented on purpose. Go ahead and implement it using the total price as a guide for you.
Feel free to contact me and I will be glad to help.
Lecture 15
Memory and Garbage Collector
07:02
In this lecture, you will learn how Java memory works.
I will also introduce the GC - Garbage Collector
Lecture 16
The List and ArrayList
17:24
In this lecture, we will use List and ArraysList as opposed as normal arrays []
Lecture 17
Dealing with Exceptions - Try, Catch and Finally
18:05
In this lecture, we you will learn how to deal with error. We will talk about Exceptions and how to catch them. We will also code try, catch finally blocks
Lecture 18
Wrapper Classes
09:01
In this lecture, you will learn what are wrapper classes. We will write code to test a couple of them and I will show you all the available ones
In this lecture, you will have a high level understanding of what maven does and how to download external packages and include to your project using maven.
Lecture 20
Cast objects
09:20
In this lecture, you will understand what is Cast and why to use it.
In this lecture, you will learn how to create a unit test from scratch using junit. You will learn how to use Assertions and execute the test on multiple packages at once
Module 3: The Parking Lot Exercise
01:01:04
Lecture 22
Parking lot development part 1 of 4
16:57
This lecture is the first part out of four and we will apply what you have learned so far. We will develop together a parking lot with levels and parking spaces. We will also be able to park cars into an empty space.
Lecture 23
Parking lot development part 2 of 4
15:48
This lecture is the second part out of four and we will apply what you have learned so far. We will develop together a parking lot with levels and parking spaces. We will also be able to park cars into an empty space.
Lecture 24
Parking lot development part 3 of 4
12:43
This lecture is the third part out of four and we will apply what you have learned so far. We will develop together a parking lot with levels and parking spaces. We will also be able to park cars into an empty space.
Lecture 25
Parking lot development part 4 of 4
15:36
This lecture is the forth part out of four and we will apply what you have learned so far. We will develop together a parking lot with levels and parking spaces. We will also be able to park cars into an empty space.
Module 4: Get Started With Algorithms and Data Structure
15:04
Lecture 26
Euclid's algorithm with Recursion
15:04
It will be easier to show how recursion works implementing an algorithm. We will implement Euclid's algorithm. I incentive you to write the code a few times then it will get stuck on your mind and easier to write and explain.
At the end of this lecture, you will be able to write Euclid's algorithm and be able to explain if someone asks you this question.
Module 5: Algorithms
01:53:42
Lecture 27
Linear Search - How it works?
02:21
In this video, you will learn Linear Search algorithm.
Lecture 28
Linear Search Coding
04:47
This lecture will teach you how to code a Linear Search. You will understand how it works and we will code it from scratch.
Lecture 29
Unit Testing Linear Search with JUNIT
07:40
In this video, we will create a unit test for the Linear Search algorithm. We will test the code that we just wrote on the previous lecture.
I will also exhaust a little bit about JUNIT debugging and explaining in detail how you run multiple unit test at once and check which tests worked and which tests failed.
Lecture 30
Insert Sort - How it works?
04:17
After this class, you will understand how Insert Sort algorithm works.
Lecture 31
Insert Sort Coding
09:49
After this lecture, you will be able to understand and code an Insert Sort algorithm.
Lecture 32
Unit Testing Insert Sort with JUNIT
14:50
After this lecture, you will test and play with the results of the InsertSort class that we created on the lecture 9. We will use a new Assertion to test the arrays. We will also use a toString from the java.util.Arrays class to help us illustrate what our code is doing.
Lecture 33
Binary Search - How it Works?
03:31
After this lecture, you will understand what is Binary Search Algorithm and how it works.
Lecture 34
Binary Search Coding
13:08
In this lecture, you will learn how to code a Binary Search Algorithm. This will be coded using a non recursive way and after unit testing we will code using recursion.
Lecture 35
Unit Testing Binary Search with JUNIT
11:23
In this lecture, we will unit test our Binary Search Algorithm coded on the previous lecture. We will also add some code to demonstrate what the code is doing and how many iterations are happening for the search to be completed.
Lecture 36
Binary Search using recursion
08:17
In this lecture, you will learn how to code the Binary Search Algorithm using recursion. We will also explore the differences between the two classes (non using recursion and using it)
Lecture 37
Unit Testing Binary Search using recursion
04:37
In this lecture, we will test the Binary Search Algorithm written using recursion. More important we will quickly debug and show the recursive calls happening.
Lecture 38
Quick Sort - How it Works?
05:31
After this lecture, you will understand what is Quick Sort Algorithm and how it works.
Lecture 39
Quick Sort Coding
14:22
In this lecture, you will learn how to code a Quick Sort Algorithm. It will be coded using recursion. Each functionality will be explained and we will go through some more detail over the next lecture while unit testing.
Lecture 40
Unit Testing Quick Sort with JUNIT
09:09
In this lecture, we will test the Quick Sort Algorithm written using recursion. We will quickly debug the code to understand a little better.
Module 6: Data Structure
03:06:28
Lecture 41
Binary Tree - How it Works?
04:10
After this lecture, you will have a clear understanding of what is a Binary Tree and how it works.
Lecture 42
Binary Tree Coding
13:36
In this lecture, you will learn how to code a BinaryTree. We will also implement pre and post order traversal of the tree to print the elements in sort ordered or reverse ordered. We will use recursion.
At the end you will understand what it is and how to code it.
Lecture 43
Unit Testing Binary Tree with JUNIT
18:00
In this lecture, we will test the BinaryTree coded using recursion. We will quickly debug the code to understand a little better.
We will also use the library from Apache common lang to use ArrayUtils
Lecture 44
Linked List - How it Works?
03:32
After this lecture, you will understand what is a Linked List and how it works.
Lecture 45
Linked List Coding
10:36
In this lecture, you will learn how to implement a LinkedList.
Lecture 46
Unit Testing Linked List with JUNIT
06:31
In this lecture, we will test the LinkedList created on the previous lecture. We will also debug to have a better understanding of the code.
Lecture 47
Doubly Linked List - How it Works?
02:21
After this lecture, you will understand what is a DoublyLinkedList and what is the difference between DoublyLinkedList and LinkedList and you will also be able to understand how it works.
Lecture 48
Doubly Linked List Coding part 1 of 2
10:49
In this lecture, you will code and understand line by line what happens on this implementation of the DoublyLinkedList.
Lecture 49
Doubly Linked List Coding part 2 of 2
15:05
We will develop the remove method and as an nice extra we will override the toString method to get a nice String when we print our DoublyLinkedList
Lecture 50
Unit Testing Doubly Linked List with JUNIT
11:01
In this lecture, we will unit test our DoublyLinkedList methods add and remove. We will also see the result expected by the toString that we implemented.
Lecture 51
Prefix Tree - How it Works?
04:33
After this lecture, you will understand what is a Prefix or Trie Tree and you will also be able to understand how it works.
Lecture 52
Prefix Tree Coding part 1 of 2
17:19
In this lecture, you will learn how to code a Prefix or Trie Tree and we will implement the insert method which will break a String into the nodes of the tree. The search method will be implemented on the next lecture so you can have some time do drink some water.
Lecture 53
Prefix Tree Coding part 2 of 2
05:08
In this lecture, you will learn how to implement the search method of a Prefix or Trie Tree
Lecture 54
Unit Testing Prefix Tree with JUNIT part 1 of 2
10:42
In this lecture, we will test the Prefix or Trie Tree implemented on the last two lectures. We will also debug the insert method so you have a better understanding of what it is doing and how it is actually working. I broke the test in two parts to make is easier to understand.
Lecture 55
Unit Testing Prefix Tree with JUNIT part 2 of 2
11:24
In this lecture, we will test the Prefix or Trie implemented on the lectures 30th and 31st and we will also debug the search method so you have a good understanding of what it is doing and how it is actually working.
Lecture 56
Stack - How it Works?
03:19
In this lecture, you will understand what is a Stack and how it works.
Lecture 57
Stack Coding
14:13
In this lecture, you will learn how to implement a Stack and this implementation will be using Object as the object being stored. In the next lecture, we will refactor this code to implement generics.
Lecture 58
Unit Testing Stack with JUNIT
10:11
In this lecture, we will test the Stack implemented on the previous lecture and we will also debug so you have a better understanding of what it is doing and how it is actually working. A refactor using Generics will be done on the next lecture.
Lecture 59
Stack Coding with Generics
03:35
In this lecture, we will refactor the stack developed on the previous lecture and refactor to implement generics
Lecture 60
Unit Testing Stack Generics with JUNIT
10:23
In this lecture, we will test the Stack with Generics implemented on the previous lecture and we will also debug so you have a better understanding of what it is doing and how it is actually working.
Module 7: Interview Coding Questions
01:50:34
Lecture 61
Print odd numbers
09:18
In this lecture, we will code the interview question to print the odd numbers. We will also implement a second way to the problem.
Lecture 62
Unit testing Print odd Number with JUNIT
08:12
In this lecture, we will unit test the print odd numbers interview question. We will also debug and do a small refactor to make it fancier and cleaner.
Lecture 63
Longest substring without repeating character Introduction (Amazon question)
04:17
In this lecture, you will understand what is this question all about and how we are going to proceed to implement it on the next lecture.
Lecture 64
Longest Substring without repeating character Coding 1 of 2
12:28
In this lecture, we will implement this interview question that returns the number of characters and comment through the code.
Lecture 65
Longest Substring without repeating character Coding 2 of 2
09:45
In this lecture, we will refactor the code implemented on the previous lecture to also make available the sequence of characters and not just the count. We will also comment as we code for you to have a better understanding.
Lecture 66
Unit testing Longest substring without repeating character with JUNIT
12:51
In this lecture, we will unit test our interview exercise find the longest substring without repeating characters. We will also debug the code to get it in a bit more detail
Lecture 67
Sudoku Introduction (Amazon Question)
03:28
In this lecture, you will understand what is this question all about and how we are going to proceed to implement it on the next lecture.
Lecture 68
Sudoku coding part 1 of 3
19:56
Sudoku was broken in two coding parts to make it easier for you. In this lecture, we will implement the first part of the Sudoku interview question and comment through the code.
Lecture 69
Sudoku coding part 2 of 3
11:15
In this lecture, we will implement the second part of the Sudoku interview question and comment through the code. We will implement all the methods necessary to have the solve method working properly.
Lecture 70
Sudoku coding part 3 of 3 Unit Testing Methods
12:44
In this lecture, we will create unit test for all the methods that we developed to have the Sudoku working. We will test solve and printMe on the next lecture.
Lecture 71
Unit Testing Sudoku with JUNIT
06:20
In this lecture, we will test the solve method, debug through the code and check the output using the printMe method implemented.
