feat(constructor-reference): demonstrate object creation using constructor references with streams

What
- Added `MobilePhone` class with:
  - A single-argument constructor accepting `String name`.
  - Overridden `toString()` method for human-readable output.
- Added `ConstructorReference` class to showcase:
  - Using `MobilePhone::new` as a constructor reference in a stream pipeline.
  - Mapping a list of `String` names into a list of `MobilePhone` objects.
  - Printing the resulting list with readable `toString()` output.

Why
- Constructor references (`ClassName::new`) provide a concise alternative to lambdas like `s -> new MobilePhone(s)`.
- Improves code readability and avoids repetitive boilerplate when object construction aligns with functional interface signatures.
- Demonstrates synergy between Java Streams and method references for elegant data transformations.

Logic
1. Input Preparation:
   - Created `List<String> names = Arrays.asList("A", "B", "C")`.
2. Stream Transformation:
   - `names.stream()` → opens pipeline for processing.
   - `.map(MobilePhone::new)` → for each string, invokes `new MobilePhone(String)` using constructor reference.
   - `.collect(Collectors.toList())` → gathers all MobilePhone objects into a list.
3. Output:
   - `System.out.println(mobilePhoneList)` → prints list contents.
   - Because `toString()` was overridden, output is clear:
     `[MobilePhone{name='A'}, MobilePhone{name='B'}, MobilePhone{name='C'}]`.

Real-life applications
- Converting raw data (e.g., CSV strings, JSON fields) into domain objects via constructor references.
- Creating DTOs or entity objects from IDs, names, or primitive values.
- Useful in stream-heavy data pipelines for object instantiation without verbose lambdas.

Notes
- Equivalent lambda for `.map(MobilePhone::new)` is `.map(name -> new MobilePhone(name))`.
- Overriding `toString()` is crucial for readable debugging and logging; otherwise, only memory references would appear.
- Constructor references require the functional interface signature (here, `Function<String, MobilePhone>`) to match the constructor signature.

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

Author: Someshdiwan

Java 8 Crash Course/Functional Interface/Static Methods/src/Constructor Reference In Java.txt

@@ -0,0 +1,72 @@
+Constructor Reference in Java
+
+What is a Constructor Reference?
+- A constructor reference (ClassName::new) is shorthand to tell the compiler
+  to use a specific constructor when creating objects.
+- Example: MobilePhone::new refers to the constructor of MobilePhone that takes a String parameter.
+- Equivalent to a lambda expression: name -> new MobilePhone(name).
+- More concise and expressive than writing the lambda manually.
+
+Step-by-Step Explanation:
+
+1. Creating a List of Names:
+   List<String> names = Arrays.asList("A", "B", "C");
+   → Creates a list with values "A", "B", "C".
+
+2. Mapping Each String to a MobilePhone:
+   List<MobilePhone> mobilePhoneList = names.stream()
+                                            .map(MobilePhone::new)
+                                            .collect(Collectors.toList());
+   - names.stream(): Converts list into a Stream.
+   - map(MobilePhone::new): Creates a MobilePhone for each string using the constructor reference.
+   - collect(Collectors.toList()): Collects MobilePhone objects into a List.
+
+3. Printing the List:
+   System.out.println(mobilePhoneList);
+   - By default, prints object references (MobilePhone@hashcode).
+   - To make output readable, override toString() in MobilePhone class.
+
+Improving the Code:
+- Override toString() to display MobilePhone{name='A'} instead of default reference.
+*/
+
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+class MobilePhone {
+    String name;
+
+    public MobilePhone(String name) {
+        this.name = name;
+    }
+
+    @Override
+    public String toString() {
+        return "MobilePhone{name='" + name + "'}";
+    }
+}
+
+public class ConstructorReference {
+    public static void main(String[] args) {
+        // List of names
+        List<String> names = Arrays.asList("A", "B", "C");
+
+        // Constructor reference to create MobilePhone objects
+        List<MobilePhone> mobilePhoneList = names.stream()
+                                                 .map(MobilePhone::new)
+                                                 .collect(Collectors.toList());
+
+        // Print the MobilePhone objects
+        System.out.println(mobilePhoneList);
+    }
+}
+
+Expected Output:
+[MobilePhone{name='A'}, MobilePhone{name='B'}, MobilePhone{name='C'}]
+
+Quick Recap:
+✔ Constructor reference simplifies object creation (MobilePhone::new).
+✔ Stream map() transforms Strings into MobilePhone objects.
+✔ Overriding toString() makes printed output readable.