Java Programming Essentials (5-Course Bundle)

Java Programming Essentials (5-Course Bundle) - Druckversion

+- Forum Rockoldies (https://rockoldies.net/forum)
+-- Forum: Fotobearbeitung - Photoshop (https://rockoldies.net/forum/forumdisplay.php?fid=16)
+--- Forum: E-Learning, Tutorials (https://rockoldies.net/forum/forumdisplay.php?fid=18)
+--- Thema: Java Programming Essentials (5-Course Bundle) (/showthread.php?tid=64662)

Java Programming Essentials (5-Course Bundle) - Panter - 14.12.2022

[Bild: 3687388233agqie2.jpg]

Java Programming Essentials (5-Course Bundle)
Last updated 12/2020
MP4 | Video: h264, 1280x720 | Audio: AAC, 44.1 KHz
Language: English | Size: 5.14 GB | Duration: 10h 36m

Build your first app with Java, the all-time favorite language for application development.

What you'll learn
Understand programming syntax, variables, and expressions to create your algorithms
Use Object Oriented Programming concepts for efficient programming
Understand some of the fundamental concepts behind key algorithms
Correctly implement basic and complex data structures
Master graph representations and learn about different graph algorithms
Utilize the functional programming paradigm on practical problems in Java
Focus on the pros and cons of alternative Reactive frameworks, Reactor, and RxJava
Build efficient and elegant code with popular parallel Java frameworks, including ForkJoin and Streams

Requirements
Prior knowledge of Java is not required.
Basic understanding of computer programming will be helpful.

Description
Java is one of the most well-known programming languages out there, primarily due to how adaptable and perfect it is. Java can be utilized for an extensive number of tasks, including programming improvement and versatile applications. Knowing Java opens a lot of doors for you as a developer.In this series of 5 courses, you'll build professional Java projects and be confident with your programming skills.Course 1:From installation to key features, this course will be your companion as you build robust and efficient applications with the latest features of Java 11. This tutorial will give you a head start in programming. It supplies enough material for you to start creating something with it right from the word go.Course 2:Next, you will be introduced to algorithms, big O notation, bubble, merge, quicksort, and other popular programming patterns. You'll also learn about data structures such as binary trees, hash tables, and graphs. The course progresses to advanced concepts, such as algorithm design paradigms and graph theory. By the end of the course, you will know how to correctly implement common algorithms and data structures within your applications.Course 3:This course takes a thought-leadership approach, gently introduces you to Functional Programming, and takes you all the way to becoming a master of the paradigm. You'll then learn how to work with higher-order functions, lambda functions, collections and more. You'll learn how to apply the best data structures and algorithms that optimize functions and also how to reuse and refactor functional blocks of code.Course 4:This course is a step-by-step guide to creating applications with Java 12 by applying reactive programming. You will get hands-on experience; each section will build on the previous one, so that you will be able to make your app responsive and reliable by implementing reactive principles with Java.Course 5:Multi-core processors are everywhere-from super-computers to mobile devices right in your pocket. That's why a modern developer must know how to leverage the power of multithreading.This course will teach you how to use parallelism and concurrency in Java. You will learn how to parallelize tasks and functions with the ForkJoin framework and Streams. You will also learn how to work with the very popular Reactive Streams recently introduced to Java. Furthermore, you will master concurrent collections and lower-level synchronization techniques with locks.

Overview

Section 1: Learning Java 11

Lecture 1 The Course Overview

Lecture 2 Setup, Installation, and Runthrough of IntelliJ IDEA

Lecture 3 Writing Your First Java Code

Lecture 4 Understanding the Programming Basics

Lecture 5 Uses of Variables and Types

Lecture 6 Using Expressions

Lecture 7 Working with More Expressions

Lecture 8 IF Statements

Lecture 9 WHILE Loops

Lecture 10 FOR Loops

Lecture 11 Using Switch Statements

Lecture 12 Understanding Arrays

Lecture 13 Understanding Methods

Lecture 14 Exception Handling

Lecture 15 Files Input and Output

Lecture 16 Introduction to Classes and Objects

Lecture 17 Enum Class

Lecture 18 Understanding Inheritance

Lecture 19 Understanding Abstraction

Lecture 20 Java Interfaces

Lecture 21 Recursive Methods

Lecture 22 ArrayList and LinkedList

Lecture 23 TreeSet and HashSet

Lecture 24 HashMap and TreeMap

Lecture 25 Multi-Dimensional Arrays

Section 2: Beginning Java Data Structures and Algorithms

Lecture 26 Course Overview

Lecture 27 Lesson Overview

Lecture 28 Developing Our First Algorithm

Lecture 29 Measuring Algorithmic Complexity with Big O Notation

Lecture 30 Identifying Algorithms with Different Complexities

Lecture 31 Summary

Lecture 32 Lesson Overview

Lecture 33 Introducing Bubble Sorting

Lecture 34 Understanding Quick Sort

Lecture 35 Using Merge Sort

Lecture 36 Getting Started with Fundamental Data Structures

Lecture 37 Summary

Lecture 38 Lesson Overview

Lecture 39 Introducing Hash Tables Part 1

Lecture 40 Introducing Hash Tables Part 2

Lecture 41 Getting Started with Binary Search Trees

Lecture 42 Traversing a Binary Search Tree

Lecture 43 Summary

Lecture 44 Lesson Overview

Lecture 45 Introducing Greedy Algorithms

Lecture 46 Getting Started with Divide and Conquer Algorithms

Lecture 47 Understanding Dynamic Programming

Lecture 48 Summary

Lecture 49 Lesson Overview

Lecture 50 Naive Search Algorithms

Lecture 51 Getting Started with the Boyer-Moore String Searching Algorithm

Lecture 52 Introducing Other String Matching Algorithms

Lecture 53 Summary

Lecture 54 Lesson Overview

Lecture 55 Representing Graphs

Lecture 56 Traversing a Graph

Lecture 57 Calculating Shortest Paths

Lecture 58 Prime Numbers in Algorithms

Lecture 59 Other Concepts in Graphs

Lecture 60 Summary

Section 3: Hands-On Functional Programming with Java

Lecture 61 The Course Overview

Lecture 62 What Is Functional Programming?

Lecture 63 Implementing Anonymous Classes (Example A)

Lecture 64 Lambda Expression (Lambda Version of Example A)

Lecture 65 Differentiating Interfaces versus Functional Interfaces

Lecture 66 Implementing the Syntax of Lambda Expressions

Lecture 67 Replacing Anonymous Classes

Lecture 68 Using Method References

Lecture 69 Best Practices for Using Lambda Expressions

Lecture 70 Introduction to the Collections Framework

Lecture 71 Implementing the Set Interface Using HashSet and LinkedHashSet

Lecture 72 Implementation of the SortedSet Interface

Lecture 73 Deploying the List Interface

Lecture 74 Working with the Queue Interface

Lecture 75 Introduction and Implementations of Maps

Lecture 76 Understanding the Stream API and Constructing Streams

Lecture 77 Intermediate Stream Operations

Lecture 78 Terminal Stream Operations and the Optional Class

Lecture 79 Implementing Stream Operations in Examples

Lecture 80 Operations on Collections and Creating Collections Using Collectors

Lecture 81 Hands-on Collection Sorting Using Streams

Lecture 82 Advanced Filtering and Mapping Using Streams

Lecture 83 Using Reduce for Advanced Transformations

Lecture 84 Implementing flatMap in Examples

Lecture 85 Advanced Grouping of Objects Using Streams

Lecture 86 Advanced Joining and Partitioning of Objects Using Streams

Lecture 87 Benefits of Concurrent Streams and Concurrency in General

Lecture 88 Implementing Parallel Streams

Lecture 89 Parallel Stream Operations

Lecture 90 Comparing Sequential to Parallel Streams

Section 4: Hands-On Reactive Programming with Java 12

Lecture 91 The Course Overview

Lecture 92 Flow: The Main Entry Point of Every Reactive App

Lecture 93 Subscriber versus Publisher: When to Use Which

Lecture 94 Hot Publisher: Why It Is Hard to Take Control Over It

Lecture 95 Cold Publisher: Pairing with Back Pressure

Lecture 96 Consuming Messages: Creating a Subscriber

Lecture 97 Using Publisher to Emit Stock Events

Lecture 98 Testing Stock Reactive Flow

Lecture 99 Handling Errors in Subscriber

Lecture 100 Flow.Processor API for the Skeleton of Transformation

Lecture 101 Using SubmissionPublisher for Proxying Event to Another Publisher in the Chain

Lecture 102 Plugging the TransformProcessor for Transformation Logic

Lecture 103 Testing Stock Transformation Logic

Lecture 104 Leveraging Subscription Object for Controlling the Number of Fetched Stocks

Lecture 105 Controlling the Speed of Consumer with AtomicInteger

Lecture 106 Creating Overproducing Publisher

Lecture 107 Testing Backpressure in Stock Exchange Application

Lecture 108 RxJava - Observables Abstractions

Lecture 109 RxJava - Advanced Operations - flatMap

Lecture 110 Reactor - Flux

Lecture 111 Reactor - Combining Publishers

Lecture 112 Reactive Spring Boot

Lecture 113 Creating Reactive Data Access Layer

Lecture 114 Creating Reactive Controller

Lecture 115 Testing Reactive Microservices

Section 5: Java Concurrency and Multithreading in Practice

Lecture 116 The Course Overview

Lecture 117 Executing Tasks in Parallel with ForkJoinPool

Lecture 118 Joining the Results of the Tasks

Lecture 119 RecursiveAction and RecursiveTask

Lecture 120 Exception Handling and Cancelling a Task

Lecture 121 Callable and Future

Lecture 122 Thread and Thread Pool

Lecture 123 CompletableFuture

Lecture 124 Sequential Streams

Lecture 125 Parallel Streams

Lecture 126 Overview: Publishers, Subscribers, and Subscriptions

Lecture 127 Subscriber: Consuming Messages

Lecture 128 Publisher and SubmissionPublisher: Providing Messages

Lecture 129 Processor: Transforming Messages

Lecture 130 Threads: Thread Lifecycle

Lecture 131 Structured Locks (The "synchronized" Keyword)

Lecture 132 Working with Locks

Lecture 133 Object#wait(), notify(), and the New onSpinWait()

Lecture 134 Possible Problems: Data Races, Deadlock, Livelock, and Resource Starvation

Lecture 135 Atomic Types and the Compare-and-Set Approach

Lecture 136 Concurrent Collections: ConcurrentHashMap, ConcurrentLinkedQueue

Lecture 137 Blocking Queues

Lecture 138 Copy-on-Write Collections

Lecture 139 Wrap Up and Next Steps

This course is for anyone who wants to get ahead in Java programming.

Homepage

Show Content

Show Content