rubinaworkspace
diff --git a/‎src/test/java/com/serenitydojo/maps/WhenWorkingWithMaps.java
Lines changed: 0 additions & 21 deletions b/‎src/test/java/com/serenitydojo/maps/WhenWorkingWithMaps.java
Lines changed: 0 additions & 21 deletions
diff --git a/‎src/test/java/com/serenitydojo/strings/WhenWorkingWithStrings.java
Lines changed: 96 additions & 4 deletions b/‎src/test/java/com/serenitydojo/strings/WhenWorkingWithStrings.java
Lines changed: 96 additions & 4 deletions
@@ -1,7 +1,12 @@
 package com.serenitydojo.strings;
 
+import org.assertj.core.api.Assertions;
 import org.junit.Test;
 
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
 import static org.assertj.core.api.Assertions.assertThat;
 
 public class WhenWorkingWithStrings {
@@ -29,7 +34,29 @@ public void reverseAPairOfStrings() {
 
         var result = reverse("Duck", "Orange");
         assertThat(result).isEqualTo("Orange Duck");
+    }
 
+    @Test
+    public void reverseAListOfStrings() {
+        var result = reverseList("Duck", "Orange");
+        assertThat(result).containsExactly("Orange","Duck");
+    }
+
+    private String reverse(String... values) {
+        StringBuilder reversedValue = new StringBuilder();
+        for(int i = values.length - 1; i >= 0; i--) {
+            reversedValue.append(values[i]);
+            reversedValue.append(" ");
+        }
+        return reversedValue.toString().trim();
+    }
+
+    private List<String> reverseList(String... values) {
+        List<String> reversed = new ArrayList<>();
+        for(int i = values.length - 1; i >= 0; i--) {
+            reversed.add(values[i]);
+        }
+        return reversed;
     }
 
     /**
@@ -49,16 +76,81 @@ private String capitalise(String... words) {
             var lowerCaseEnding = word.toLowerCase().substring(1);
             var capitalisedWord = upperCaseFirstLetter + lowerCaseEnding;
             result.append(capitalisedWord);
+            result.append(" ");
         }
-        return result.toString();
+        return result.toString().trim();
     }
 
+    /**
+     * Replace all of the red shirts by orange shirts
+     */
     @Test
-    public void reverseAListOfStrings() {
+    public void colourSwitch() {
+        List<String> colouredShirts = List.of("red shirt", "light red shirt", "blue shirt", "green shirt");
+
+        List<String> updatedShirts = new ArrayList<>();
+        for(String shirt : colouredShirts) {
+            updatedShirts.add(shirt.replace("red", "orange"));
+        }
 
+        assertThat(updatedShirts).containsExactly("orange shirt", "light orange shirt", "blue shirt", "green shirt");
     }
 
-    private String reverse(String a, String b) {
-        return b + " " + a;
+    /**
+     * Find all the string values that contain red (reguardless of case)
+     */
+    @Test
+    public void colourFilter() {
+        List<String> terms = List.of("red", "Light Red", "Orange-red wash", "green","ruby red", "blue");
+
+        List<String> reds = new ArrayList<>();
+
+        for(String color : terms) {
+            if (color.toLowerCase().contains("red")) {
+                reds.add(color);
+            }
+        }
+        assertThat(reds).containsExactly("red", "Light Red", "Orange-red wash", "ruby red");
     }
+
+    //
+    // Using the Collections utility class
+    //
+    @Test
+    public void sortingElementsInAList() {
+        List<String> terms = List.of("red", "yellow", "orange", "green","ruby red", "blue");
+
+        List<String> sortedTerms = new ArrayList<>(terms);
+
+        Collections.sort(sortedTerms);
+
+        assertThat(sortedTerms).containsExactly("blue", "green", "orange", "red", "ruby red", "yellow");
+
+    }
+
+    @Test
+    public void replacingElements() {
+        List<String> terms = List.of("red", "yellow", "orange", "green","ruby red", "blue");
+
+        List<String> sortedTerms = new ArrayList<>(terms);
+
+        Collections.replaceAll(sortedTerms,"yellow","beige");
+
+        assertThat(sortedTerms).containsExactly("red", "beige", "orange", "green","ruby red", "blue");
+
+    }
+
+
+    @Test
+    public void findingMaximumAndMinimums() {
+        List<Integer> numbers = List.of(10,20,30,40,50);
+
+        int max = Collections.max(numbers);
+        int min = Collections.min(numbers);
+
+        assertThat(max).isEqualTo(50);
+        assertThat(min).isEqualTo(10);
+
+    }
+
 }