Write explanation for the Optional concept, as well as the test file, the stub implementation, the reference solution and other required files. Some files must be modified. This is a draft.

Author: josealonso

config.json

@@ -308,6 +308,13 @@
           "generic-types"
         ],
         "status": "beta"
+      },
+      {
+        "slug": "tim-from-marketing-2",
+        "name": "tim-from-marketing-2",
+        "uuid": "a6cfc286-8c62-4f5b-8e59-f6bfc4374092",
+        "concepts": [],
+        "prerequisites": []
       }
     ],
     "practice": [

exercises/concept/tim-from-marketing-2/.docs/hints.md

@@ -0,0 +1,45 @@
+# Instructions
+
+In this exercise you will be writing code to print all the names of the factory employees.
+
+Employees have an ID, a name and a department name, like in [tim-from-marketing](/exercises/concept/tim-from-marketing). 
+Assume that the ID of the first employee is 1, the ID of the second employee is 2, and so on. If an employee has an ID, the other two fields, name and department name, have valid values.
+
+Two methods are already implemented:
+
+- `getAllTheEmployeesById()` returns an Optional<List<Employee>> object. Notice this method does NOT receive any parameter.
+- `getEmployeeById(id)` returns an Optional<Employee> object for the given ID, being Employee the following class:
+
+```java
+class Employee {
+    private int id;
+    private String name;
+    private String departmentName;
+    // Getters and setters
+}
+```
+
+## 1.- Print the names of all the employees
+
+Implement the `printAllEmployeesNamesById()` method to print the names of all the employees, together with their id. If the employee does not exist, print "[id] - This employee does not exist".
+
+```java
+"1 - Tim"
+"2 - Bill"
+"3 - Steve"
+"4 - This employee does not exist"
+"5 - Charlotte"
+```
+
+## 2.- Print the name and department of a given employee
+
+Implement the `printEmployeeNameAndDepartmentById(id)` method to print the name and department of a given employee, together with their id. If the employee does not exist, print "[id] - This employee does not exist":
+
+```java
+printEmployeeNameAndDepartmentById(1) => "1 - Tim - Marketing"
+printEmployeeNameAndDepartmentById(2) => "2 - Bill - Sales"
+printEmployeeNameAndDepartmentById(3) => "3 - Steve - Engineering"
+printEmployeeNameAndDepartmentById(4) => "4 - This employee does not exist"
+printEmployeeNameAndDepartmentById(5) => "5 - Charlotte - Owner"
+```
+

exercises/concept/tim-from-marketing-2/.docs/instructions.md

@@ -0,0 +1,55 @@
+# Introduction
+
+## Optional
+
+## Introduction
+
+The Optional<T> type was introduced in Java 8 as a way to indicate that a method will return an object of type T or a null value. It is present in type signatures of many core Java methods. 
+
+Before Java 8, developers had to implement null checks:
+
+```java
+public Employee getEmployee(String name) {
+    // Assume that getEmployeeByName retrieves an Employee from a data base
+    Employee employee = getEmployeeByName(name);
+    if (employee != null) {
+        return employee;
+    } else {
+        return throw new IllegalArgumentException("Employee not found");
+    }
+}
+```
+
+With the Optional API, the code above can be simplified to:
+
+```java
+public Optional<Employee> getEmployee(String name) {
+    // Assume that getEmployeeByName returns an Optional<Employee>
+    return getEmployeeByName(name)
+           .orElseThrow(() -> new IllegalArgumentException("Employee not found"));
+}
+```
+
+If a default value must be returned, the `orElse` method can be used.
+
+```java
+public Optional<Employee> getEmployee(String name) {
+    // Assume that getEmployeeByName returns an Optional<Employee>
+    return getEmployeeByName(name)
+           .orElse(new Employee("Daniel"));
+}
+```
+
+Provided all the invoked methods return Optional objects, many methods can be chained without having to worry about null checking:
+
+```java
+public Optional<Integer> getEmployeeAge(String name) {
+    Optional<Employee> optionalEmployee = getEmployeeByName(name);
+    return getEmployeeByName(name)
+               .map(Employee::getAge)
+               .orElse(0);
+}
+```
+
+It is important to understand that the Optional API does not eliminate the null values. It defers the null checking until the end of a series of methods, as long as all those methods return an optional object. 
+

exercises/concept/tim-from-marketing-2/.docs/introduction.md

@@ -0,0 +1,5 @@
+# Introduction
+
+## Optional
+
+%{concept:optional}

exercises/concept/tim-from-marketing-2/.docs/introduction.md.tpl

@@ -0,0 +1,13 @@
+{
+  "authors": ["josealonso"],
+  "files": {
+    "solution": [
+      "src/main/java/TimFromMarketing2.java"
+    ],
+    "test": [
+      "src/test/java/TimFromMarketing2Test.java"
+    ],
+    "exemplar": []
+  },
+  "blurb": ""
+}

exercises/concept/tim-from-marketing-2/.meta/config.json

@@ -0,0 +1,130 @@
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Optional;
+import java.util.stream.*;
+
+
+public class Main {
+    public static void main(String[] args) {
+        System.out.println("Hello");
+
+        var employeeService = new EmployeeService();
+        System.out.println(employeeService.printAllEmployeesNamesById());
+        System.out.println(employeeService.printEmployeeNameAndDepartmentById(1));
+        System.out.println(employeeService.printEmployeeNameAndDepartmentById(2));
+        System.out.println(employeeService.printEmployeeNameAndDepartmentById(3));
+        System.out.println(employeeService.printEmployeeNameAndDepartmentById(4));
+    }
+}
+
+class EmployeeService {
+  
+    private Utils utils = new Utils();
+
+    public List<Optional<Employee>> getAllTheEmployeesById() {
+        return utils.getAllTheEmployeesById()
+        .stream()
+        .map(employee -> Optional.ofNullable(employee))
+        .collect(Collectors.toList());
+    }
+
+    public Optional<Employee> getEmployeeById(int employeeId) {
+       /* Solution using Streams
+        
+        return getAllTheEmployeesById(employeesList).stream()
+                                     .filter(employee -> employee.getId() == id)
+                                     .orElse("Employee not found");
+        */
+
+        return Optional.ofNullable(utils.getEmployeeById(employeeId));
+    }
+
+    public String printAllEmployeesNamesById() {
+        List<Optional<Employee>> nullableEmployeesList = getAllTheEmployeesById();
+        // var employee = new Employee();
+        StringBuilder stringBuilder = new StringBuilder();
+        for (int i = 0; i < nullableEmployeesList.size(); i++) {
+            stringBuilder.append(i).append(" - ");
+
+            nullableEmployeesList.get(i)
+                .flatMap(employee -> employee.getName())
+                // .map(nullableEmployee -> nullableEmployee.get())  // Compile error
+                .ifPresentOrElse(
+                    name -> stringBuilder.append(name).append("\n"),
+                    () -> stringBuilder.append("No employee found\n")
+                );
+              //  .ifPresent(name -> stringBuilder.append(name))
+              //  .orElse("No employee found");    // compile error
+        }
+        return stringBuilder.toString();
+    }
+
+    public String printEmployeeNameAndDepartmentById(int employeeId) {
+
+        var employee = getEmployeeById(employeeId);
+        StringBuilder stringBuilder = new StringBuilder();
+        stringBuilder.append(employeeId).append(" - ");
+        employee.ifPresentOrElse(
+            e -> {
+                // Handle Optional values
+                e.getName().ifPresentOrElse(
+                    name -> stringBuilder.append(name).append(" - "),
+                    () -> {}
+                );
+                e.getDepartment().ifPresentOrElse(
+                    department -> stringBuilder.append(department),
+                    () -> {}
+                );
+            },
+            () -> stringBuilder.append("No employee found")
+        );
+        return stringBuilder.toString();
+    }       
+
+}
+
+class Utils {
+
+    private List<Employee> listOfEmployees = new ArrayList<>();
+    // List.of(   // Immutable lists do not allow null elements
+{ 
+    listOfEmployees.add(new Employee(0, "Tim", "Direction"));
+    listOfEmployees.add(new Employee(1, "Mark", "Sales"));
+    listOfEmployees.add(new Employee(2, "John", "Engineering"));
+    listOfEmployees.add(null); // Adding a null element
+    listOfEmployees.add(new Employee(4, "Jane", "Sales"));
+}
+
+    public List<Employee> getAllTheEmployeesById() {
+        return listOfEmployees;
+    }
+
+    public Employee getEmployeeById(int employeeId) {
+        return listOfEmployees.get(employeeId);
+    }
+}
+
+
+class Employee {
+    private final int id;  // It can't be final due to the empty constructor
+    private final String name;
+    private final String department;
+
+    public Employee(int id, String name, String department) {
+        this.id = id;
+        this.name = name;
+        this.department = department;
+    }
+
+    public Optional<Integer> getId() {
+        return Optional.ofNullable(id); 
+    }
+
+    public Optional<String> getName() {
+        return Optional.ofNullable(name);
+    }
+
+    public Optional<String> getDepartment() {
+        return Optional.ofNullable(department);
+    }
+}

exercises/concept/tim-from-marketing-2/.meta/design.md

@@ -0,0 +1,66 @@
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Optional;
+import java.util.stream.*;
+
+
+class EmployeeService {
+  
+    public List<Optional<Employee>> getAllTheEmployeesById() {
+        return getAllTheEmployeesById()
+        .stream()
+        .map(employee -> Optional.ofNullable(employee))
+        .collect(Collectors.toList());
+    }
+
+    public Optional<Employee> getEmployeeById(int employeeId) {
+       /* Solution using Streams
+        
+        return getAllTheEmployeesById(employeesList).stream()
+                                     .filter(employee -> employee.getId() == id)
+                                     .orElse("Employee not found");
+        */
+
+        return Optional.ofNullable(getEmployeeById(employeeId));
+    }
+
+    public String printAllEmployeesNamesById() {
+        List<Optional<Employee>> nullableEmployeesList = getAllTheEmployeesById();
+        StringBuilder stringBuilder = new StringBuilder();
+        for (int i = 0; i < nullableEmployeesList.size(); i++) {
+            stringBuilder.append(i).append(" - ");
+
+            nullableEmployeesList.get(i)
+                .flatMap(employee -> employee.getName())
+                .ifPresentOrElse(
+                    name -> stringBuilder.append(name).append("\n"),
+                    () -> stringBuilder.append("No employee found\n")
+                );
+        }
+        return stringBuilder.toString();
+    }
+
+    public String printEmployeeNameAndDepartmentById(int employeeId) {
+
+        var employee = getEmployeeById(employeeId);
+        StringBuilder stringBuilder = new StringBuilder();
+        stringBuilder.append(employeeId).append(" - ");
+        employee.ifPresentOrElse(
+            e -> {
+                // Handle Optional values
+                e.getName().ifPresentOrElse(
+                    name -> stringBuilder.append(name).append(" - "),
+                    () -> {}
+                );
+                e.getDepartment().ifPresentOrElse(
+                    department -> stringBuilder.append(department),
+                    () -> {}
+                );
+            },
+            () -> stringBuilder.append("No employee found")
+        );
+        return stringBuilder.toString();
+    }       
+
+}
+