docs(Operator): add explanation and examples of UnaryOperator and BinaryOperator in Java

What
- Documented UnaryOperator and BinaryOperator functional interfaces in Java.
- Included:
  1. UnaryOperator:
     - Definition: takes one argument, returns a value of the same type.
     - Specialized form of Function<T, T>.
     - Example: incrementing integer by 1 using UnaryOperator<Integer> increment = x -> x + 1.
     - Demonstration: increment.apply(5) → 6.
  2. BinaryOperator:
     - Definition: takes two arguments of the same type, returns same type.
     - Specialized form of BiFunction<T, T, T>.
     - Example: adding two integers with BinaryOperator<Integer> add = (x, y) -> x + y.
     - Demonstration: add.apply(5, 10) → 15.
  3. Usage guidelines:
     - Use UnaryOperator<T> for transforming or modifying a single value (increment, uppercase, squaring).
     - Use BinaryOperator<T> for combining two values (sum, max, concatenation).
- Summary:
  - UnaryOperator<T> → one input, same-type output.
  - BinaryOperator<T> → two inputs, same-type output.
  - Both are common in stream operations like map and reduce.

Why
- Provides clear and practical explanation of UnaryOperator and BinaryOperator.
- Helps developers understand when to use each in functional programming contexts.
- Bridges theory with working code examples for quick learning.

How
- Explained interfaces and their relationship to Function and BiFunction.
- Provided standalone Java classes with code and output.
- Annotated examples with explanations for clarity.
- Highlighted real use cases: transformation vs combination.

Logic
- Inputs: integers 5 (for unary) and 5,10 (for binary).
- Outputs: 6 for UnaryOperator; 15 for BinaryOperator.
- Flow:
  1. Define lambda using operator interface.
  2. Call apply() with input(s).
  3. Print result.
- Edge cases:
  - Operators assume non-null inputs.
  - Arithmetic overflow possible for large numbers.
- Complexity / performance: O(1).
- Concurrency / thread-safety: lambdas shown are stateless and thread-safe.
- Error handling: not needed in examples.

Real-life applications
- UnaryOperator:
  - Transforming numbers, normalizing strings, incrementing counters.
  - Used with Stream.map for element-wise transformations.
- BinaryOperator:
  - Summing values, combining strings, computing min/max.
  - Used with Stream.reduce to combine elements into one.

Notes
- Prefer method references for readability when possible (e.g., Integer::sum).
- UnaryOperator and BinaryOperator improve clarity compared to generic Function/BiFunction.
- Widely used in functional programming patterns introduced in Java 8.

Signed-off-by: https://github.com/Someshdiwan <[email protected]>

Author: Someshdiwan

Java 8 Crash Course/Unary operators and Binary operators/src/Unary Operators and Binary Operators.txt

@@ -0,0 +1,68 @@
+Unary and Binary Operators in Java:
+
+1. Unary Operator
+- A unary operator takes a single argument and returns a value of the same type.
+- In Java, this is represented by the `UnaryOperator<T>` interface.
+- It is a specialized version of `Function<T, T>`.
+
+Example: Incrementing an integer by 1
+
+import java.util.function.UnaryOperator;
+
+public class UnaryOperatorDemo {
+    public static void main(String[] args) {
+        // Define a unary operator that increments its input by 1
+        UnaryOperator<Integer> increment = x -> x + 1;
+
+        // Apply the operator
+        int result = increment.apply(5);
+        System.out.println("Increment 5: " + result);  // Output: Increment 5: 6
+    }
+}
+
+Explanation:
+- UnaryOperator<Integer> increment: Defines a function taking Integer → Integer.
+- Lambda expression (x -> x + 1): Adds 1 to the input.
+- increment.apply(5): Returns 6.
+
+
+2. Binary Operator
+- A binary operator takes two arguments of the same type and returns a result of the same type.
+- In Java, this is represented by the `BinaryOperator<T>` interface.
+- It is a specialized version of `BiFunction<T, T, T>`.
+
+Example: Adding two integers
+
+import java.util.function.BinaryOperator;
+
+public class BinaryOperatorDemo {
+    public static void main(String[] args) {
+        // Define a binary operator that adds two integers
+        BinaryOperator<Integer> add = (x, y) -> x + y;
+
+        // Apply the operator
+        int result = add.apply(5, 10);
+        System.out.println("Add 5 and 10: " + result);  // Output: 15
+    }
+}
+
+Explanation:
+- BinaryOperator<Integer> add: Takes (Integer, Integer) → Integer.
+- Lambda expression ((x, y) -> x + y): Adds the two integers.
+- add.apply(5, 10): Returns 15.
+
+
+3. When to Use
+- Use UnaryOperator<T> when:
+  - You need to transform or modify a single value of type T.
+  - Example: Incrementing numbers, converting strings to uppercase, squaring a value.
+
+- Use BinaryOperator<T> when:
+  - You need to combine two values of the same type into one.
+  - Example: Summing numbers, finding the maximum of two values, concatenating strings.
+
+
+Summary
+- UnaryOperator<T> → One input, same type output. (Function<T, T>)
+- BinaryOperator<T> → Two inputs, same type output. (BiFunction<T, T, T>)
+- Both are widely used in streams (map, reduce, collect) and functional programming in Java.