Real-world! Spring Boot and JPA Utilization 2 - API Development and Performance Optimization

Hello everyone. Finally, we have opened the last lecture of the Java Roadmap, Advanced Java Part 3.

Link: https://inf.run/iZKKT

Kim Young-han's Practical Java - Advanced Part 3, Lambda, Stream, Functional Programming

• Lecture time: 16 hours 40 minutes

• Number of lectures: 97

• Lecture PDF Material: 387 pages

[Course Introduction]

Learn new syntax and techniques frequently used in modern Java, such as lambda, stream, and functional programming. In this lecture, I will teach you how to apply these techniques in practice, deeply understand them, and utilize them, beyond simply knowing them.

[Summary of lecture contents]

The main lecture contents are as follows.

1. Why Lambda is needed

Learn how lambdas play a vital role in modern Java, both for clean, concise code and for easily leveraging advanced features like parallel processing.

2. Lambda

You will learn the definition, syntax, and usage tips of lambda through real code examples. You will clearly understand how it differs from the existing method and what makes it attractive.

3. Functional interface

Functional interface, an essential concept used with lambda! We will tell you why functional programming is possible and how to easily utilize various functional interfaces built into the Java standard API.

4. Using Lambda

How can we apply lambda in practical code? Let's learn the core usage of lambda to simplify repetitive patterns and complex logic with examples.

5. Lambda vs Anonymous Class

We compare and analyze in which situations lambdas are more efficient and in which cases anonymous classes should be used.

6. Method Reference

The method reference syntax added in Java 8 takes functional programming to the next level of cleanliness. We will explain how the method reference syntax works and what are some practical examples of its use.

7. Stream API1 - Basics

The Stream API presents a new paradigm for handling Java collections with lambdas. We will organize the stream structure and basic usage in an easy-to-understand manner for beginners.

8. Stream API2 - Features

Let's take a closer look at the core features provided by streams, such as filtering, mapping, sorting, and reducing. You can learn how to write code more intuitively and concisely.

9. Stream API3 - Collector

Learn the concept of Collector, which is utilized in streams for efficient data collection and processing. You can learn essential skills in practice, such as collect(), grouping, and partitioning.

10. Optional

Let's make proper use of Optional, which cleanly resolves null handling. We will cover various methods to prevent NPE problems that are frequent in practice, such as isPresent(), orElse(), and orElseThrow().

11. Default method

Let's take a look at a new aspect of Java interfaces: default methods.

Learn the correct usage practices, along with how to maintain compatibility when extending interfaces.

12. Parallel Streams

Parallel processing for high performance! Learn about ForkJoin pools, multi-core utilization know-how through stream APIs, and precautions that may arise in parallel streams.

13. Functional Programming

All features added after Java 8, such as lambda, stream API, and Optional, reflect the functional programming paradigm. We will teach you how to write more efficient code by combining object-oriented languages and the functional paradigm.

thank you

Hello everyone, after two years we have finally completed the Java roadmap.

The last lecture of the Java roadmap , Kim Young-han's Practical Java - Advanced Part 3, Lambda, Stream, Functional Programming

The opening schedule has been confirmed to be between Tuesday, March 25th and Friday, March 28th.

• Lecture time: 16 hours 40 minutes

• Number of lectures: 97

• Lecture PDF Material: 387 pages

[Course Introduction]
Learn new syntax and techniques frequently used in modern Java, such as lambdas, streams, and functional programming.
In this lecture, I will teach you how to apply and utilize technologies such as lambda, streams, and functional programming in practice, beyond simply knowing them.

[Summary of lecture contents]

The main lecture contents are as follows.

1. Why Lambda is needed

Learn how lambdas play a vital role in modern Java, both for clean, concise code and for easily leveraging advanced features like parallel processing.

2. Lambda

You will learn the definition, syntax, and usage tips of lambda through real code examples. You will clearly understand how it differs from the existing method and what makes it attractive.

3. Functional interface

Functional interfaces, an essential concept used with lambda!
We will explain why functional programming is possible and how to easily utilize the various functional interfaces built into the Java standard API.

4. Using Lambda

How can we apply lambdas in real-world code?
Let's learn the core usage of lambda to simplify repetitive patterns and complex logic with examples.

5. Lambda vs Anonymous Class

We compare and analyze in which situations lambdas are more efficient and in which cases anonymous classes should be used.

6. Method Reference

The method reference syntax added in Java 8 takes functional programming to the next level of cleanliness. We will explain how the method reference syntax works and what are some practical examples of its use.

7. Stream API1 - Basics

The Stream API presents a new paradigm for handling Java collections with lambdas. We will organize the stream structure and basic usage in an easy-to-understand manner for beginners.

8. Stream API2 - Features

Let's take a closer look at the core features provided by streams, such as filtering, mapping, sorting, and reducing. You can learn how to write code more intuitively and concisely.

9. Stream API3 - Collector

Learn the concept of Collector, which is utilized in streams for efficient data collection and processing. You can acquire skills essential for practical work, such as collect(), grouping, and partitioning.

10. Optional

Let's make proper use of Optional, which cleanly resolves null handling. We will cover various methods to prevent NPE problems that are frequent in practice, such as isPresent(), orElse(), and orElseThrow().

11. Default method

Let's take a look at a new aspect of Java interfaces: default methods.

Learn the correct usage practices, along with how to maintain compatibility when extending interfaces.

12. Parallel Streams

Parallel processing for high performance! Learn about ForkJoin pools, multi-core utilization know-how through stream APIs, and precautions that may arise in parallel streams.

13. Functional Programming

All features added after Java 8, such as lambda, stream API, and Optional, reflect the functional programming paradigm. We will teach you how to write more efficient code by combining object-oriented languages and the functional paradigm.

[Full Table of Contents]

1. Why Lambda is needed

* Project environment configuration
* Why Lambda is Needed 1
* Why Lambda is Needed 2
* Why Lambda is Needed 3
* Function vs Method
* Lambda start

2. Lambda

* Lambda definition
* Functional interface
* Lambda and Signature
* Lambda and omission
* Lambda propagation
* Higher order functions
* Problem and solution 1
* Problem and solution 2
* Problem and solution 3
* organize

3. Functional interface

* Functional interfaces and generics1
* Functional interfaces and generics2
* Lambda and target type
* Basic functional interface
* Specialized functional interface
* Other functional interfaces
* Problems and solutions
* organize

4. Using Lambda

* Create a filter 1
* Create a filter 2
* Map Creation 1
* Map Making 2
* Using filters and maps1
* Using filters and maps 2
* Create a stream 1
* Create a stream 2
* Create a stream 3
* Create a stream 4
* organize

5. Lambda vs Anonymous Class

* Lambda vs Anonymous Classes1
* Lambda vs Anonymous Class2
* organize

6. Method Reference

* Why method references are needed
* Method Reference 1 - Start
* Method Reference 2 - Parameter 1
* Method Reference 3 - Reference an instance method of an arbitrary object
* Method Reference 4 - Utilization 1
* Method Reference 5 - Utilization 2
* Method Reference 6 - Parameter 2
* organize

7. Stream API1 - Basics

* Start Stream API
* What is the Stream API?
* Pipeline configuration
* Delayed operation
* Delayed computation and optimization

8. Stream API2 - Features

* Create a stream
* Intermediate operations
* FlatMap
* Optional brief description
* Final operation
* Basic specialized stream

9. Stream API3 - Collector

* Collector 1
* Collector 2
* Downstream collector 1
* Downstream collector 2
* organize

10. Optional

* Why optionals are needed
* Creating an Optional and obtaining its value
* Optional value handling
* Immediate and delayed assessment1
* Immediate and delayed evaluation2
* Immediate and delayed evaluation 3
* orElse() vs orElseGet()
* Practical Use 1 - Finding Address
* Practical Application 2 - Delivery
* Optional - Best Practice
* organize

11. Default method

* Why default methods appeared
* Introducing the default method
* Correct usage of default methods
* organize

12. Parallel Streams

* Single stream
* Use thread directly
* Use thread pool
* ForkJoin pattern
* ForkJoin Framework 1 - Introduction
* ForkJoin Framework 2 - Work Stealing
* Work stealing algorithm
* ForkJoin Framework 3 - Common Pool
* Java Parallel Streams
* Precautions when using parallel streams
* Use separate pool
* organize

13. Functional Programming

* Programming paradigm
* What is functional programming?
* Java and Functional Programming 1
* Java and Functional Programming 2
* Java and Functional Programming 3
* organize

thank you

Hello everyone^^! Java Advanced Part 2 lecture is finally open.

Lecture link: https://inf.run/puD14

Kim Young-han's Practical Java - Advanced Part 2

* Lecture time: 21 hours 35 minutes
* Number of lectures: 100 lectures
* Lecture PDF materials: Approximately 400 pages

[Course Introduction]

The goal is to completely master I/O, networking, reflection, and annotations from the basics to the level required for practical use.

And this lecture is particularly code and example-oriented.

We will use all the things we have learned so far - Java Beginner, Basic, Intermediate 1, 2, Advanced 1 - up to multi-threading - while creating various examples such as member management through files, chat, and web application servers.

So, through the Java roadmap, you can learn in depth how the Java content you have learned so far is actually utilized through example code.

My goal is not simply to teach Java grammar, but to foster competent developers with solid Java fundamentals necessary for practical work.

To this end, we are working on a deep and systematic Java roadmap. Please look forward to it.

thank you

hello everyone

Kim Young-han's Practical Java - Advanced Part 2, I/O, Network, Reflection

The opening schedule has been confirmed to be between Monday, October 7th and Friday, October 11th .

• Lecture time: 21 hours 35 minutes

• Number of lectures: 100 lectures

• Lecture PDF materials: Approximately 400 pages

[Course Introduction]

The goal is to completely master I/O, networking, reflection, and annotations from the basics to the level required for practical use.

And this lecture is particularly code and example-oriented .

We will use everything we have learned so far - from Java Beginner, Basic, Intermediate 1, 2, Advanced 1 - to Multi-threading - while creating various examples such as member management through files, chat, and web application servers.

So, through the Java roadmap, you can learn in depth how the Java content you have learned so far is actually utilized through example code.

[Full Table of Contents]

1. Character encoding

* Project environment configuration
* Computers and data
* Computers and Character Encoding1
* Computers and Character Encoding2
* Character set lookup
* Character encoding example 1
* Character encoding example 2
* organize

2. IO Basics 1

* Start Stream1
* Start Stream 2
* InputStream, OutputStream
* File I/O and Performance Optimization 1 - Write One by One
* File I/O and Performance Optimization 2 - Buffer Utilization
* File I/O and Performance Optimization 3 - Writing Buffered Streams
* File I/O and Performance Optimization 4 - Reading Buffered Streams
* File I/O and Performance Optimization 5 - Write at a time
* organize

3. IO Basics 2

* Handling Text 1 - Getting Started
* Handling characters 2 - Stream to characters
* Character Handling 3 - Reader, Writer
* Character Handling 4 - BufferedReader
* Other streams
* organize

4. IO Utilization

* Member Management Example 1 - Memory
* Member Management Example 2 - Save to file
* Member Management Example 3 - DataStream
* Member Management Example 4 - ObjectStream
* XML, JSON, database
* organize

5. File, Files

* File
* Files
* Show path
* Read text files with Files
* Optimized file copying
* organize

6. Network - Basic Theory

* Client and server
* Internet communication
* IP (Internet Protocol)
* TCP, UDP
* PORT
* DNS

7. Network - Program 1

* Network Program 1 - Example
* Network Program 1 - Analysis
* Network Program 2 - Example
* Network Program 2 - Analysis
* Network program 3
* Resource Management 1
* Resource Management 2
* Resource Management 3
* Resource Management 4

8. Network - Program 2

* Network Program 4 - Resource Management 1
* Network Program 5 - Resource Management 2
* Network Program 6 - Resource Management 3
* Network Program 6 - Resource Management 4
* Network exception 1 - Connection exception
* Network exception 2 - timeout
* Network exception 3 - Normal termination
* Network exception 4 - Forced shutdown
* Summary and Problems

9. Chat program

* Chat program - design
* Chat program - client
* Chat program - Server 1
* Chat program - Server 2
* Chat program - Server 3
* Chat program - Server 4
* organize

10. HTTP - Basic Theory

* HTTP Basic Theory
* HTTP method

11. Create an HTTP server

* HTTP Server 1 - Start
* HTTP Server 2 - Concurrent Requests
* HTTP Server 3 - Added features
* URL encoding
* HTTP Server 4 - Request, Response
* HTTP Server 5 - Command Pattern
* History of Web Application Servers
* organize

12. Reflection

* Why reflection is needed
* Classes and metadata
* Method lookup and dynamic invocation
* Field navigation and value change
* Reflection - Usage Examples
* Constructor search and object creation
* HTTP Server 6 - Reflection Servlet
* organize

13. Annotation

* Why annotations are needed
* Annotation definition
* Meta annotation
* Annotations and inheritance
* Using annotations - validator
* Java Basic Annotations
* organize

14. Using HTTP Server

* HTTP Server 7 - Annotation Servlet 1 - Start
* HTTP Server 8 - Annotation Servlet 2 - Dynamic Binding
* HTTP Server 9 - Annotation Servlet 3 - Performance Optimization
* HTTP server utilization - Member management service
* organize

thank you

Hello everyone^^! Java Advanced Part 1 - Multithreading and Concurrency lecture is finally open.

Lecture link: https://inf.run/RYNoL

Kim Young-han's Practical Java - Advanced Part 1, Multithreading and Concurrency
* Lecture time: 20 hours 48 minutes
* Number of lectures: 118
* Lecture PDF materials: Approximately 500 pages
* Picture: 270 sheets

This course aims to completely master multithreading and concurrency from CS basics to practical application techniques. And to explain complex multithreading as easily as possible , it contains about 500 PDF pages and 270 pictures!

Beyond simply knowing the basics of threads, I will teach you how to deeply understand and properly utilize Java multithreading technology and concurrency issues required for practical use.

My goal is not just to teach Java grammar, but to train competent developers with solid Java fundamentals needed in the field. To this end, I am working on a Java roadmap that is in-depth and systematic. Please look forward to it.

hello everyone
Kim Young-han's Practical Java - Advanced Part 1, Multithreading and Concurrency
The opening date has been confirmed for Monday, July 15th .

Kim Young-han's Practical Java - Advanced Part 1, Multithreading and Concurrency
* Lecture time: 20 hours 48 minutes
* Number of lectures: 118
* Lecture PDF materials: Approximately 500 pages
* Picture: 270 sheets

Advanced Part 1 aims to completely master multithreading and concurrency from CS basics to practical application techniques. And to explain complex multithreading as easily as possible, it includes a whopping 270 illustrations!

[Future plans]
The Advanced Edition will be released in three parts: 1, 2, and 3.
* Advanced Part 1: Multithreading and Concurrency (7/15)
* Advanced Part 2: I/O, Networks, Reflection, Annotations (Scheduled for October)
* Advanced Part 3: Lambda, Streams, Modern Java (scheduled for December)

[Course Introduction]

Kim Young-han's Practical Java - Advanced Part 1, Multithreading and Concurrency

Course Objectives

Beyond simply knowing the basics of threads, I will teach you how to deeply understand and properly utilize Java multithreading technology and concurrency issues required for practical use.

Lecture Contents

Learning CS theory to build a foundation
* Processes and threads
* Multitasking
* Scheduling 2

Thread Basics
* Thread control
* Thread life cycle
* Memory visibility, volatile
* synchronized synchronization
* ReentrantLock - Advanced synchronization
* Thread Control - Various Examples

Advanced techniques in threading
* Producer Consumer Issues
* CAS
* Synchronized collection

Multithreaded practical techniques used in practice
* How Future Works
* Thread Pool and Executor Framework - Principles
* Thread Pool and Executor Framework - Practical Applications

[Full lecture table of contents]

1. Introduction to processes and threads
* Multitasking and multiprocessing
* Processes and threads
* Threads and scheduling
* Context switching

2. Creating and running threads
* Project environment configuration
* Thread start 1
* Thread start 2
* Daemon thread
* Create a thread - Runnable
* Create a logger
* Create multiple threads
* Various ways to create a Runnable
* Problems and solutions
* organize

3. Thread Control and Life Cycle1
* Thread basic information
* Thread Life Cycle - Explained
* Thread life cycle - code
* Redefine checked exceptions
* join - start
* join - necessary situation
* Use join - sleep
* join - use join
* join - wait only for a certain amount of time
* Problems and solutions

4. Thread Control and Life Cycle2
* Interrupt - Start1
* Interrupt - Start2
* Interrupt - Start 3
* Interrupt - Start 4
* Printer Example 1 - Start
* Printer Example 2 - Introducing Interrupts
* Printer Example 3 - Interrupt Code Improvement
* yield - to give in
* Printer Example 4 - Introducing yield
* organize

5. Memory Visibility
* volatile, memory visibility1
* volatile, memory visibility2
* volatile, memory visibility3
* volatile, memory visibility4
* Java Memory Model
* organize

6. Synchronization - synchronized
* Withdrawal Example - Start
* Concurrency issues
* Critical area
* synchronized method
* synchronized code block
* Problems and solutions
* organize

7. Advanced Synchronization - concurrent.Lock
* LockSupport1
* LockSupport2
* ReentrantLock - Theory
* ReentrantLock - Utilization
* ReentrantLock - ReentrantLock
* organize

8. Producer-Consumer Problems 1
* Producer-Consumer Issues - Introduction
* Producer Consumer Problem - Example 1 Code
* Producer Consumer Problem - Analysis of Example 1 - Producer First
* Producer Consumer Problem - Analysis of Example 1 - Consumer First
* Producer Consumer Problem - Example 2 Code
* Producer Consumer Problem - Example 2 Analysis
* Object - wait, notify - Example 3 code
* Object - wait, notify - Example 3 Analysis - Producer priority
* Object - wait, notify - Example 3 Analysis - Consumer First
* Object - wait, notify - limits
* organize

9. Producer-Consumer Problems 2
* Lock Condition - Example 4
* Separate producer and consumer waiting space - Example 5 code
* Separation of producer-consumer waiting space - Analysis of Example 5
* Wait for thread
* Interim Summary - Producer Consumer Issues
* BlockingQueue - Example 6
* BlockingQueue - Function Description
* BlockingQueue - Check the function
* organize

10. CAS - Synchronization and Atomic Operations
* Atomic Operations - Introduction
* Atomic Operations - Start
* Atomic operations - volatile, synchronized
* Atomic operations - AtomicInteger
* Atomic Operations - Performance Testing
* CAS operation 1
* CAS operation 2
* CAS operation 3
* CAS lock implementation1
* CAS lock implementation 2
* organize

11. Concurrency Collection
* Why we need concurrent collections 1 - Getting started
* Why we need concurrent collections 2 - Concurrency issues
* Why we need concurrent collections 3 - Synchronization
* Why we need concurrent collections 4 - Introducing proxies
* Java Concurrency Collections 1 - synchronized
* Java Concurrency Collections 2 - Concurrency Collections
* organize

12. Thread Pool and Executor Framework1
* Problems with using threads directly
* Introduction to the Executor Framework
* Start with ExecutorService code
* Inconvenience of Runnable
* Future1 - Introduction
* Future2 - Analysis
* Future3 - Utilization
* Future4 - Reason
* Future5 - Summary
* Future6 - Cancel
* Future7 - Exception
* ExecutorService - Processes a collection of tasks.
* Problems and solutions
* organize

13. Thread Pool and Executor Framework2
* ExecutorService Graceful Shutdown - Introduction
* ExecutorService graceful shutdown - implementation
* Executor thread pool management - code
* Executor thread pool management - Analysis
* Executor Strategy - Fixed Pool Strategy
* Executor Strategy - Cache Pool Strategy
* Executor Strategy - Custom Pool Strategy
* Executor exception policy
* organize

thank you

Hello everyone^^! The second part of the intermediate Java course is finally open.
To celebrate the opening, I'm offering a 30% discount on all my lectures, including Spring and JPA! ^^!

Lecture link: https://inf.run/NevkE

Kim Young-han's Practical Java Intermediate Part 2 - Generics and Collections

* Lecture time: 19 hours 24 minutes
* Number of lectures: Approximately 90 lectures
* Lecture PDF materials: 355 pages

This lecture covers in depth the generics, data structures, and collection frameworks required for practical use.

In particular, you will deeply understand the principles by directly implementing various data structures used in collections. Therefore, you will be able to properly understand the fundamental reasons why each data structure performs well and poorly in certain cases and utilize them in practice.

My goal is not just to teach Java grammar, but to train competent developers with solid Java fundamentals needed in the field. To this end, I am working on a Java roadmap that is in-depth and systematic. Please look forward to it.

hello everyone
Kim Young-han's Practical Java Intermediate Part 2 - Generics and Collections
The opening date has been confirmed for Wednesday, May 8th.

Kim Young-han's Practical Java - Intermediate Part 2 Generics and Collections
* Lecture time: 19 hours 24 minutes
* Number of lectures: Approximately 90 lectures
* Lecture PDF materials: 355 pages

[Java Intermediate Part 2 Lecture Contents]

[Generic]
Generics in Java are really difficult to understand properly.
In this lecture, to explain generics as easily as possible, we will first write code without using generics at all. Then, as we gradually introduce generics into this code, we will naturally understand how generics solve code duplication that was difficult to solve with traditional methods.

[Understanding data structures]
This lecture explains the basic theory of data structures so that you can properly understand data structures, and also implements core data structures frequently used in practice with code.

* ArrayList
* LinkedList
* Hash Structure (Hash)
* Hash algorithm and hash table (Hash)
* Tree structure
* Set (Set) and Map Structure (Set, Map)
* Stack and Queue Structures

[Collection Framework]
Java's collection framework is a collection of data structures.
In practice, data structures are used very frequently and are directly related to performance issues, so it is very important to properly understand and use data structures.
In this lecture, you will deeply understand the principles by implementing various data structures used in collections. Therefore, you will be able to properly understand the fundamental reasons why each data structure performs well and poorly in certain cases and apply them in practice.
In each chapter, you will learn about various data structures through theory and practical implementation. In this way, you will complete the overall Java collection framework and properly understand which data structure to use where.

[Full lecture table of contents]

1. Generic - Generic1

* Project environment configuration

* Why Generics Are Needed

* Attempt to resolve duplication through polymorphism

* Generic application

* Generic terms and conventions

* Generic usage examples

* Problem and solution 1

2. Generic - Generic2

* Type parameter constraints 1 - Start

* Type parameter restrictions 2 - Attempt at polymorphism

* Type parameter restrictions 3 - Introducing generics and their failures

* Type parameter restrictions 4 - Type parameter restrictions

* Generic method

* Utilizing generic methods

* Wildcard 1

* Wildcard 2

* Type Eraser

* Problem and solution 2

* organize

3. Collection Framework - ArrayList

* Array Features 1 - Arrays and Indexes

* Big O notation

* Array feature 2 - Adding data

* Implementing Array List 1 - Start

* Directly implementing array list 2 - dynamic array

* Directly implementing array list 3 - Added features

* Implementing Array List Directly 4 - Generic 1

* Implementing Array Lists Directly 5 - Generics 2

* organize

4. Collection Framework - LinkedList

* Connect to node 1

* Connect to node 2

* Connect to node 3

* Implementing a linked list directly 1 - Start

* Directly implementing linked list 2 - Addition and deletion 1

* Directly implementing linked list 3 - Addition and deletion 2

* Directly implementing linked list 4 - Introducing generics

* organize

5. Collection Framework - List

* List Abstraction 1 - Introducing Interfaces

* List Abstraction 2 - Dependency Injection

* List Abstraction 3 - Compile-time, runtime dependencies

* Performance comparison of directly implemented lists

* Java List

* Performance comparison of Java lists

* Problem and solution 1

* Problem and solution 2

* organize

6. Collection Framework - Hash

* List vs Set

* Implement Set0 directly - Start

* Hash Algorithm 1 - Start

* Hash algorithm 2 - using index

* Hash Algorithm 3 - Memory Waste

* Hash Algorithm 4 - Remainder Operation

* Hash Algorithm 5 - Hash Collision Description

* Hash Algorithm 6 - Hash Collision Implementation

7. Collection Framework - HashSet

* Implementing Set1 directly - MyHashSetV1

* String hash code

* hashCode() in Java

* Implementing Set2 directly - MyHashSetV2

* Implementing Set3 yourself - storing objects you create yourself

* Importance of equals and hashCode 1

* Importance of equals and hashCode 2

* Implementing Set4 directly - Introducing generics and interfaces

8. Collection Framework - Set

* Set1 provided by Java - HashSet, LinkedHashSet

* Set2 provided by Java - TreeSet

* Set3 provided by Java - Example

* Set4 provided by Java - Optimization

* Problem and solution 1

* Problem and solution 2

* organize

9. Collection Framework - Map, Stack, Queue

* Collection Framework - Introduction to Map 1

* Collection Framework - Introduction to Map 2

* Collection Framework - Map implementation

* Stack data structure

* Queue data structure

* Deque data structure

* Deque, Stack, and Queue

* Problem and solution 1 - Map1

* Problem and solution 2 - Map2

* Problem and solution 3 - Stack

* Problem and solution 4 - Queue

* organize

10. Collection Framework - Iteration, Sorting, and Full Cleanup

* Iteration 1 - Implementing Iterable and Iterator directly

* Iteration 2 - Enhanced for loop

* Iteration 3 - Iterable and Iterator provided by Java

* Sort1 - Comparable, Comparator

* Sort2 - Comparable, Comparator

* Sort3 - Comparable, Comparator

* Collection Utility

* Complete collection framework summary

* Problems and solutions

* organize

thank you