Programming Foundations: Algorithms

Algorithms are the universal building blocks of programming. They power the software you use every day, whether it's a spreadsheet, a social network, or a driving assistant. Algorithms offer a way to think about programming challenges in plain English, before they are translated into a specific language like C# or JavaScript. In this course, author and developer Joe Marini explains some of the most popular and useful algorithms for searching and sorting information, working with techniques like recursion, and understanding common data structures. He also discusses the performance implications of different algorithms and how to evaluate the performance of a given algorithm. Each algorithm is shown in practice in Python, but the lessons can be applied to any programming language.

Course Contents

Introduction

Algorithms power the world 1m 2s

What you should know 1m 35s

Overview

What are algorithms? 2m 44s

Common algorithms in programming 5m 42s

Measuring algorithm performance 3m 47s

Common Data Structures

Introduction to data structures 1m 56s

Arrays 2m 29s

Linked lists 2m 36s

Linked lists walkthrough 7m 35s

Stacks and queues 2m 43s

Stacks and queues walkthrough 6m 2s

Hash tables 7m 59s

Recursion

Understanding recursion 3m 38s

Simple recursion example 3m 9s

Power and factorial 4m 14s

Sorting Data

Overview of sorting 2m 4s

The bubble sort5m 8s

The merge sort 2m 24s

Implement the merge sort 5m 10s

The quicksort 3m 31s

Implement the quicksort 5m 39s

Searching Data

Unordered list search 3m 45s

Ordered list search 5m 30s

Determine if a list is sorted 3m 37s

Other Algorithms

Unique filtering with hash table 3m 25s

Value counting with hash table 3m 4s

Find max value recursively 3m 44s

Conclusions

Next steps 1m 18s

01. Introduction

02. Overview

03. Common Data Structures

04. Recursion

05. Sorting Data

06. Searching Data

07. Other Algorithms

00. Introduction

1. Getting Started

2. Java Basics

3. Control Flow

4. Beyond the Basics

05. Conclusion

00. Introduction

01. Core Concepts

02. Object-Oriented Analysis and Design

03. Utilizing Use Cases

04. Domain Modeling (Modeling the App)

05. Creating Classes

06. Inheritance and Composition

07. Advanced Concepts

08. Object-Oriented Design Patterns

09. Object-Oriented Design Principles

10. Conclusion

1 - Introduction

2 - 1. What Is Java

3 - 2. Get Started

4 - 3. Work with Variables

5 - 4. Work with String Values

6 - 5. Manage Program Flow

Conclusion

Java Essential Training: Objects and APIs

If you want to build applications for mobile devices, desktop computers, or the web, you need to know Java—and keep your knowledge up to date as the language evolves. Java 9 is changing quite a few important aspects of the programming workflow, particularly the handling of objects and APIs. This course is the second in the Java Essential Training series, which provides the foundation for learning Java 9. Instructor starts by showing how to debug Java code in IntelliJ IDEA, and handle any exceptions that occur. He explains how to create custom classes and understand how Java implements inheritance, a core principle of object-oriented programming. Plus, learn how to store data in memory with the Java Collections Framework, extend Java with popular APIs, make network requests, and package your applications for deployment in JAR files.

Introduction

Welcome

What you should know

How to use the exercise files

1. Exception Handling and Debugging

Syntax errors vs. exceptions

Debug with IntelliJ IDEA

Handle exceptions with try-catch

Create multiple catch blocks

Checked vs. unchecked exceptions

2. Create Custom Classes

About encapsulation

Use the Java runtime classes

Wrap code in static methods

Declare and use custom classes

Organize code with packages

Create and use instance methods

Manage state with instance variables

Declare multiple constructor methods

Use static fields as constants

Declare and use enum types

Organize code with nested types

3. Work with Inheritance

About inheritance and polymorphism

Extend classes and override methods

Cast objects as different types

Create and implement interfaces

Use abstract classes and methods

4. Manage Data Collections

Store values in simple arrays

Manage resizable arrays with List

Manage key-value pairs with Map

5. Use Java Packages and Libraries

Work with dates and times

Copy files with readers and buffers

Copy files with Path and Files classes

Parse a JSON file

Include packages with modules

6. Prepare a Java Application for Deployment

Document code with Javadoc

Package classes in JAR files

Conclusion

Next steps

1 - Introduction

1. Exception Handling and Debugging

2. Create Custom Classes

3. Work with Inheritance

4. Manage Data Collections

5. Use Java Packages and Libraries

6. Prepare a Java Application for Deployment

Code Clinic: Java (May. 2018)

Practice coding with Java. Code Clinic is a series of courses that solve the same problems using different programming languages. It gives developers a chance to experiment with new platforms and compare their strengths. Here, Carlos Rivas takes you through six different challenges and provides an overview of his solutions in Java. Challenges cover topics such as statistical analysis, geolocation, facial recognition, and accessing peripheral devices. Each lesson provides practical skills, valuable design patterns, and code snippets you can use in your own projects.

Contents

Introduction

Welcome

What you should know

Using the exercise files

Getting the most from Code Clinic

1. Problem 1: Pond Oreille

Intro: The weather at Pond Oreille

Solution Overview

Loading data

Parse the data

Perform calculations

Putting it all together

2. Problem 2: Where Am I?

Intro: Where am I?

Solution overview

Calling the API

Parsing the location data

3. Problem 3: Eight Queens

Intro: Eight queens

Solution overview

Scanning for solution

Chess board validation

Print the solutions

4. Problem 4: Accessing Peripherals

Intro: Accessing peripherals

Fugue library

Solution overview

Implement the music player

5. Problem 5: Facial Recognition

Intro: Facial recognition

The OpenIMAJ library

Solution overview

Implement facial detection

Perform facial detection

6. Problem 6: Real-Time Information Dashboard

Intro: Real-time information dashboard

Required tools

Solution overview

Import the CSV

Calculate the seconds passed

Generate JSON output

Send data to the dashboard

1 - Introduction

2 - 1._Problem_1_-_Pond_Oreille

3 - 2._Problem_2_-_Where_Am_I

4 - 3._Problem_3_-_Eight_Queens

5 - 4._Problem_4_-_Accessing_Peripherals

6 - 5._Problem_5_-_Facial_Recognition

7 - 6._Problem_6_-_Real-Time_Information_Dashboard

Java Design Patterns: Creational

Design patterns provide a kind of template for writing quality code. Knowing which design pattern to use in which scenario can be challenging, but will make you a better Java programmer. This course takes a deep dive into creational patterns, which can help you create more flexible, reusable objects. Instructor Bethan Palmer covers the five most popular creational patterns—Builder, Singleton, Prototype, Factory Method, and Abstract Factory—as well as concepts such as multithreading, mutability, and hierarchies. She provides example use cases, complete with implementation instructions and tips for avoiding the unique challenges posed by each pattern. By the end of the course, you'll be armed with the knowledge and skills necessary to implement each design pattern in your own Java projects.

Introduction

Improve code with creational design patterns

What you should know

1. Creational Design Patterns

What is a design pattern?

Creational design patterns

2. The Builder Pattern

Avoid complex constructors

Implement the Builder pattern

Implement a complete Builder pattern

Complex constructions

3. The Singleton Pattern

When to use the Singleton pattern

Implement the Singleton pattern

Multithreading with the Singleton pattern

Javas -  Collection class

4. The Prototype Pattern

Understand the Prototype pattern

Implement the Prototype pattern

Dealing with mutability

5. The Factory Method Pattern

Understand the Factory Method pattern

Implement a simple Factory Method pattern

Introduction to hierarchies

The complete Factory Method pattern

6. Abstract Factories

Understand the Abstract Factory pattern

Dealing with extensible factories

Implement the Abstract Factory pattern

Implement extensible factories

Conclusion

Next steps

1 - Introduction

2 - 1._Creational_Design_Patterns

3 - 2._The_Builder_Pattern

4 - 3._The_Singleton_Pattern

5 - 4._The_Prototype_Pattern

6 - 5._The_Factory_Method_Pattern

7 - 6._Abstract_Factories

8 - Conclusion

Lynda - Learn Java Concepts By Example

Do you learn best by doing? Why not learn Java that way? Learn Java Concepts by Example is a Java cookbook that pairs four Java programming challenges with step-by-step solutions. Julian Robichaux shows how to create command-line applications to search text and access a relational database, a GUI app to display and resize images, and a Java API to access third-party webpage content. By practicing these examples, you'll learn concepts such as regular expressions, arrays, JDBC, JAR files, Swing, Java math, lambdas, and RESTful programming—all within the context of real-world applications.

Topics include:

Creating a command-line application

Building a graphical user interface

Creating a Java API

Parsing JSON data

Refactoring and testing Java code

01. Introduction

02. Create a Command-Line Application That Searches Text Files

03. Create a Command-Line Application That Accesses a Database

04. Create a GUI Application That Resizes Images

05. Create a Java API That Searches Stack Overflow

06 - Conclusion

Learning Java 9 Modularity

Project Jigsaw is the star attraction of Java 9. It introduces the Java Platform Module System (JPMS) and makes it possible to create modular applications natively in Java. Modularity is key in managing complexity in modern applications but is also a complex subject in it of itself that impacts the entirety of an application.

In this course, instructor Nick Maiorano breaks down this complexity by explaining what modularity is all about, how Java has adopted modularity and how to start using to build better quality applications.

01. Introduction

02. Introduction to Modularity

03. Java Modularity through the Ages

04. Building Modular Applications with Java

05. Tools and Strategies

06 - Conclusion

Advanced Java Programming

ava Advanced Training shows developers how to expand their programming skills and get more out of Java. This course offers platform- and framework-neutral tutorials that can be used to build web, mobile, and desktop applications. Starting with advanced methods of defining Java classes and programmatic flow, author David Gassner goes on to describe the Java Reflection API and the Collections Framework; management of files and directories; test-driven development with advanced exception handling and reporting; and how to work with multiple threads.

Topics include:

Installing Java on Windows and Mac OS X

Installing Eclipse

Using new features such as simplified generics

Working with advanced class structures (member, local inner, etc.)

Using the Reflection API

Navigating inheritance trees

Managing unordered and ordered sets

Peeking and polling with queues

Testing and error handling

Managing files and directories

Working with I/O streams

Multi-threading

Next steps with Java

01. Introduction

1. Getting Started

2. Java 7 New Features

3. Using Advanced Class Structures

4. Using the Reflection API

5. More of the Collections Framework

6. Testing and Advanced Exception Handling

7. Managing Files and Directories in Java 7

8. Working with I/O Streams

9. Working with Multi-threading

Java: Database Integration with JDBC

Whether you're building a web- or desktop-based application with Java SE or Java EE, many Java applications need to integrate data from a relational database. This course describes how to read and manage data from relational databases such as MySQL and SQL Server using the Java Database Connectivity (JDBC) API.
Author David Gassner explains how to choose a JDBC driver and connect to one or more databases. He also provides detailed instructions on reading, selecting, and updating data; calling stored procedures; managing data via JavaBean classes or with prepared statements; and working with metadata.

Topics include:

Importing a MySQL database

Connecting to databases

Handling JDBC exceptions

Looping through result sets

Limiting the number of fetched rows

Filtering data with prepared statements

Calling stored procedures

Inserting, updating, and deleting rows with prepared statements

Using a persistent database connection

Committing and rolling back transactions

01. Introduction

1. Installing Software

2. Getting Started with JDBC

3. Managing Database Resources

4. Reading Data

5. Managing Data

6. Using Metadata

Java for Data Scientists Essential Training

Learn how to use Java for two components of data science—data engineering and data analysis. Instead of poring over every facet of Java, instructor Charles Kelly focuses on a selection of valuable topics that will help you learn how to leverage Java in your data science career. This course revolves around the ingest, model, query, analyze, and visualize (IMQAV) model, which is a framework for data science workflows. Charles goes over test-driven development and object-oriented design. Using the free community edition of IntelliJ from JetBrains, he presents Java examples including Java classes, methods, operations, and libraries. Plus, Charles shares how to apply the skills that you learned in the course to create magic squares and sudoku puzzles.

Topics include:

The IMQAV model

Downloading software

Installing and setting up a Java coding environment

Mock tests

Code coverage

Using windows, views, and modes in IntelliJ IDEA

Creating classes and attributes

Creating constructors

Casting variables

Matching literals with regular expressions

Libraries

Regular expressions

Design patterns

01. Introduction

1. Getting Started with Java

2. Test-Driven Development

3. IntelliJ IDEA

4. Object-Oriented Java

5. Libraries

6. Regular Expressions

7. Reflection

8. Design Patterns

9. Applying Data Science

Nail Your Java Interview

Have you lined up an interview for a Java developer position? In this course, review critical Java concepts-and commonly-asked interview questions-to ensure that you approach your Java interviews with confidence. Instructor Kathryn Hodge dives into a discussion of key topics that might appear as questions in an interview, such as the difference between the Java Runtime Environment (JRE) and the Java Development Kit (JDK). She also goes over string manipulation, data structures, and essential object-oriented programming concepts. Throughout the course, Kathryn offers examples that lend a real-world context to the concepts she covers.

Introduction

Welcome

What you should know

Using the exercise files

Overview

Types of questions

Getting ready for the interviews

2. Java-Specific Questions

What is the Java Virtual Machine?

What is the JDK and JRE?

Class vs. instance

Static vs. non-static methods

Scope

Access modifiers

3. String Manipulation in Java

What is a string?

Different ways to concatenate strings

Basic string functions

More string functions

Advanced string functions

String equality

Challenge: String interview

Solution: String interview

4. Data Structures

How to use a linked list

How to use a queue

How to use a stack

How to use a hash map

Challenge: Data structures interview

Solution: Data structures interview

5. Object-Oriented Concepts

Abstraction

Encapsulation

Inheritance

Polymorphism (generics)

Solution: Object-oriented interview

Conclusion

Next steps