New concept: Optional

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,11 @@
+# Hints
+
+## 1.- Print the name of all the employees
+
+WIP
+
+
+## 2.- Print the name and department of a given employee
+
+WIP
+

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

@@ -0,0 +1,35 @@
+# 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. The three fields of an employee may be empty, That's why they are declared as Optional<T> types.
+
+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:
+
+## 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/introduction.md

@@ -0,0 +1,77 @@
+# 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 an empty 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 database
+    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 -> employee.getAge())
+               .orElse(0);
+}
+```
+
+It is important to understand that the Optional API does not eliminate the null checking, but it defers it until the end of a series of methods, as long as all those methods return an optional object. 
+
+## Flatmap operation
+
+The **flatMap** method flattens a List of Optional objects into a List of those objects. In other words, extracts the value of each list element, discarding empty Optionals. For example:
+
+```java
+List<Optional<String>> listOfOptionals = Arrays.asList(
+    Optional.of("Java"),
+    Optional.empty(),
+    Optional.of("Kotlin")
+);
+```
+
+```java
+// Using flatMap to extract present values
+        List<String> result = listOfOptionals.stream()
+            .flatMap(Optional::stream)
+            .collect(Collectors.toList());
+
+        System.out.println(result); // Output: [Java, Kotlin]
+    }
+}
+```

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

@@ -0,0 +1,5 @@
+# Introduction
+
+%{concept:optional-types}
+
+%{concept:flatMap-operation}

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

@@ -0,0 +1,18 @@
+{
+  "authors": [
+    "josealonso"
+  ],
+  "files": {
+    "solution": [
+      "src/main/java/EmployeeService.java"
+    ],
+    "test": [
+      "src/test/java/EmployeeServiceTest.java"
+    ],
+    "exemplar": [
+      ".meta/src/reference/java/EmployeeService.java"
+    ],
+  },
+  "icon": "language-list",
+  "blurb": "Learn to use the Optional class by helping Tim print details of his company employees."
+}

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

@@ -0,0 +1,51 @@
+# Design
+
+## Goal
+
+The goal of this exercise is to teach the student how to use the Optional API.
+We will use the most common methods: `ifPresent`, `orElse`, `ifPresentOrElse`, `orElseThrown`. 
+The `isPresent` and `get` methods are not presented, since they do not provide any value over an ordinary null check.
+
+Some methods of the Stream API are needed. This is a bit problematic, since they have not been explained in the current Java track.
+
+## Learning objectives
+
+- Know what optional types are.
+- Know how to use Optional<T> fields.
+- Know how to use methods that return an Optional<T> type.
+- See the utility of some Stream methods, `flatMap` specifically.
+
+## Out of scope
+
+- Streams API.
+
+## Concepts
+
+This Concepts Exercise's Concepts are:
+
+- `Optional<T>` class and some methods that mimic a null check.
+
+## Prerequisites
+
+This Concept Exercise's prerequisites Concepts are:
+
+- `custom classes`.
+- `generic-types`.
+- `streams`.
+
+## Analyzer
+
+wip
+
+This exercise could benefit from the following rules in the [analyzer]:
+
+- `actionable`: If the solution did not use `contains` in the method `containsLanguage`, instruct the student to do so.
+- `actionable`: If the solution did not use `isEmpty` in the method `isEmpty`, instruct the student to do so.
+- `informative`: If the student did not reuse the implementation of the `containsLanguage` method in the `isExciting` method, instruct them to do so.
+  Explain that reusing existing code instead of copy-pasting can help make code easier to maintain.
+- `informative`: If the solution uses an `if statement` in the `containsLanguage` method, instruct the student to return directly the `contains` method.
+
+If the solution does not receive any of the above feedback, it must be exemplar.
+Leave a `celebratory` comment to celebrate the success!
+
+[analyzer]: https://github.com/exercism/java-analyzer

exercises/concept/tim-from-marketing-2/.meta/src/reference/java/EmployeeService.java

@@ -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();
+    }       
+
+}
+

exercises/concept/tim-from-marketing-2/src/main/java/Employee.java

@@ -0,0 +1,23 @@
+class Employee {
+    private final int id;  
+    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/src/main/java/EmployeeService.java

@@ -0,0 +1,33 @@
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.*;
+
+class EmployeeService {
+
+    /*
+     The getAllTheEmployeesById and getEmployeeById methods are already implemented.
+     */
+
+    // Convert the list of employees to a list of Optional<Employee>
+    public List<Optional<Employee>> getAllTheEmployeesById() {
+        return getAllTheEmployeesById()
+                .stream()
+                .map(employee -> Optional.ofNullable(employee))
+                .collect(Collectors.toList());
+    }
+
+    public Optional<Employee> getEmployeeById(int id) {
+        return Optional.ofNullable(getEmployeeById(employeeId));
+    }
+
+
+    public String printAllEmployeesNamesById() {
+        throw new UnsupportedOperationException("Please implement the EmployeeService.printAllEmployeesNamesById() method");
+    }
+
+    public String printEmployeeNameAndDepartmentById(int employeeId) {
+        throw new UnsupportedOperationException("Please implement the EmployeeService.printEmployeeNameAndDepartmentById(id) method");
+    }
+
+
+}