Tags
Language
Tags
October 2025
Su Mo Tu We Th Fr Sa
28 29 30 1 2 3 4
5 6 7 8 9 10 11
12 13 14 15 16 17 18
19 20 21 22 23 24 25
26 27 28 29 30 31 1
    Attention❗ To save your time, in order to download anything on this site, you must be registered 👉 HERE. If you do not have a registration yet, it is better to do it right away. ✌

    ( • )( • ) ( ͡⚆ ͜ʖ ͡⚆ ) (‿ˠ‿)
    SpicyMags.xyz

    Java Programming Essentials (5-Course Bundle)

    Posted By: ELK1nG
    Java Programming Essentials (5-Course Bundle)

    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.