Created read me file

Author: rohitchavan-git

README.md

@@ -0,0 +1,56 @@
+# Design Patterns with Java 8 Functional Programming
+
+Welcome to the **Design Patterns with Java 8 Functional Programming** repository! This repository aims to provide a comprehensive guide to understanding design patterns and their implementation using Java 8's functional programming features. By leveraging the power of functional programming, we can explore new ways of implementing and utilizing design patterns in our software projects.
+
+## Table of Contents
+
+- [Design and Design Patterns](#design-and-design-patterns)
+- [Optional: Patterns and Anti-patterns](#optional-patterns-and-anti-patterns)
+- [Iterator Pattern](#iterator-pattern)
+- [Lightweight Strategy](#lightweight-strategy)
+- [Factory Method using Default Methods](#factory-method-using-default-methods)
+- [Laziness using Lambda Expressions](#laziness-using-lambda-expressions)
+- [Decorator using Lambda Expressions](#decorator-using-lambda-expressions)
+- [Creating Fluent Interfaces](#creating-fluent-interfaces)
+- [Execute Around Method Pattern](#execute-around-method-pattern)
+
+## Design and Design Patterns
+
+In this section, we will introduce the concepts of design and design patterns. Understanding the importance of design patterns in software development will lay a solid foundation for the rest of the topics covered in this repository.
+
+## Optional: Patterns and Anti-patterns
+
+The `Optional` class in Java provides a way to handle nullable values. In this section, we will explore different patterns and anti-patterns related to using the `Optional` class effectively in our code.
+
+## Iterator Pattern
+
+The Iterator pattern allows us to iterate over a collection of objects without exposing its underlying representation. We will dive into the implementation details of the Iterator pattern and demonstrate how it can be leveraged in a functional programming context.
+
+## Lightweight Strategy
+
+The Strategy pattern enables us to select an algorithm dynamically. By applying functional programming concepts, we can create lightweight strategies that provide flexible behavior implementation.
+
+## Factory Method using Default Methods
+
+The Factory Method pattern is a creational pattern that provides an interface for creating objects but lets subclasses decide which class to instantiate. We will leverage the default methods introduced in Java 8 to implement the Factory Method pattern in a more concise and elegant way.
+
+## Laziness using Lambda Expressions
+
+Lazy evaluation is a powerful concept in functional programming that allows computations to be deferred until their results are actually needed. Using lambda expressions and functional programming techniques, we will explore how laziness can be achieved effectively in Java 8.
+
+## Decorator using Lambda Expressions
+
+The Decorator pattern provides a way to dynamically add new behavior to objects at runtime. In this section, we will demonstrate how to implement the Decorator pattern using lambda expressions, enabling more flexible and concise code.
+
+## Creating Fluent Interfaces
+
+Fluent interfaces enhance the readability and expressiveness of code by providing a fluent and method-chaining style of constructing objects. We will discuss the concept of fluent interfaces and how they can be created using Java 8 functional programming features.
+
+## Execute Around Method Pattern
+
+The Execute Around Method pattern allows a method to control the execution of a block of code. We will explore the implementation of this pattern using functional programming techniques, leveraging the power of lambda expressions and higher-order functions.
+
+We hope this repository provides you with a deep understanding of design patterns and their implementation using Java 8 functional programming. Each topic will be covered in a detailed manner, with code examples and explanations to facilitate your learning journey. Feel free to explore the code, experiment with the examples, and expand your knowledge of design patterns in a functional programming context.
+
+Happy learning!
+