Updating JDK to 17 and GSON to 2.8.9

pom.xml

@@ -13,8 +13,8 @@
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
                 <configuration>
-                    <source>16</source>
-                    <target>16</target>
+                    <source>17</source>
+                    <target>17</target>
                 </configuration>
             </plugin>
         </plugins>
@@ -26,7 +26,7 @@
         <guava.version>31.0.1-jre</guava.version>
         <j.assert.version>3.21.0</j.assert.version>
         <junit.version>5.8.1</junit.version>
-        <gson.version>2.8.8</gson.version>
+        <gson.version>2.8.9</gson.version>
         <commons-io.version>2.11.0</commons-io.version>
     </properties>
 

src/main/java/com/amigoscode/examples/Filtering.java

@@ -0,0 +1,24 @@
+package com.amigoscode.examples;
+
+import com.amigoscode.beans.Car;
+
+import java.util.List;
+import java.util.function.Predicate;
+
+class Filtering {
+
+    private final Predicate<Car> price = car -> car.getPrice() < 20_000.00;
+    private final Predicate<Car> color = car -> car.getColor().equals("Yellow");
+    private final List<Car> cars;
+
+    Filtering(List<Car> cars) {
+        this.cars = cars;
+    }
+
+    List<Car> getYellowCarsUnder20k() {
+        return cars.stream()
+                .filter(price)
+                .filter(color)
+                .toList();
+    }
+}

src/main/java/com/amigoscode/examples/GettingStarted.java

@@ -0,0 +1,38 @@
+package com.amigoscode.examples;
+
+import com.amigoscode.beans.Person;
+
+import java.util.ArrayList;
+import java.util.List;
+
+class GettingStarted {
+
+    private final List<Person> people;
+
+    GettingStarted(List<Person> people) {
+        this.people = people;
+    }
+
+    List<Person> imperativeApproach() {
+        var youngPeople = new ArrayList<Person>();
+        var limit = 10;
+        var counter = 0;
+        for (Person person : people) {
+            if (person.getAge() <= 18) {
+                youngPeople.add(person);
+                counter++;
+            }
+            if (counter == limit) {
+                break;
+            }
+        }
+        return youngPeople;
+    }
+
+    List<Person> declarativeApproachUsingStreams() {
+        return people.stream()
+                .filter(person -> person.getAge() <= 18)
+                .limit(10)
+                .toList();
+    }
+}

src/test/java/com/amigoscode/examples/Filtering.java → src/test/java/com/amigoscode/examples/FilteringTest.java

@@ -1,37 +1,39 @@
 package com.amigoscode.examples;
 
-import com.amigoscode.beans.Car;
-import com.amigoscode.beans.Person;
 import com.amigoscode.mockdata.MockData;
 import org.junit.jupiter.api.Test;
 
-import java.util.Arrays;
-import java.util.List;
-import java.util.OptionalInt;
-import java.util.function.Predicate;
-import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-public class Filtering {
+import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+
+class FilteringTest {
 
     @Test
-    public void filter() throws Exception {
-        List<Car> cars = MockData.getCars();
+    void get_all_yellow_cars_under_20k() throws Exception {
+        var cars = MockData.getCars();
+        var filtering = new Filtering(cars);
+
+        var carsUnder20k = filtering.getYellowCarsUnder20k();
+
+        assertThat(carsUnder20k.size()).isEqualTo(9);
+        carsUnder20k.forEach(car ->
+                assertThat(car.getPrice()).isLessThan(20_000.00));
     }
 
     @Test
-    public void dropWhile() throws Exception {
-        System.out.println("using filter");
+    void dropWhile() throws Exception {
+        System.out.println("using filtering");
         Stream.of(2, 4, 6, 8, 9, 10, 12).filter(n -> n % 2 == 0)
                 .forEach(n -> System.out.print(n + " "));
         System.out.println();
         System.out.println("using dropWhile");
     }
 
     @Test
-    public void takeWhile() throws Exception {
-        // using filter
-        System.out.println("using filter");
+    void takeWhile() throws Exception {
+        // using filtering
+        System.out.println("using filtering");
         Stream.of(2, 4, 6, 8, 9, 10, 12).filter(n -> n % 2 == 0)
                 .forEach(n -> System.out.print(n + " "));
 
@@ -40,22 +42,22 @@ public void takeWhile() throws Exception {
     }
 
     @Test
-    public void findFirst() throws Exception {
+    void findFirst() throws Exception {
         int[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
     }
 
     @Test
-    public void findAny() throws Exception {
+    void findAny() throws Exception {
         int[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 9, 10};
     }
 
     @Test
-    public void allMatch() throws Exception {
+    void allMatch() throws Exception {
         int[] even = {2, 4, 6, 8, 10};
     }
 
     @Test
-    public void anyMatch() throws Exception {
+    void anyMatch() throws Exception {
         int[] evenAndOneOdd = {2, 4, 6, 8, 10, 11};
     }
 

src/test/java/com/amigoscode/examples/GettingStartedTest.java

@@ -0,0 +1,56 @@
+package com.amigoscode.examples;
+
+import com.amigoscode.beans.Person;
+import com.amigoscode.mockdata.MockData;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.util.List;
+
+import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+import static org.assertj.core.api.AssertionsForClassTypes.fail;
+
+
+class GettingStartedTest {
+
+    private static final String FAILED_TO_FETCH_MOCK_DATA_FOR_THE_TEST = "Failed to fetch mock data for the test";
+    private GettingStarted gettingStarted;
+    private List<Person> people;
+
+    @BeforeEach
+    void setup() {
+        try {
+            people = MockData.getPeople();
+        } catch (IOException e) {
+            fail(FAILED_TO_FETCH_MOCK_DATA_FOR_THE_TEST);
+        }
+        gettingStarted = new GettingStarted(people);
+    }
+
+    @Test
+    void imperative_approach() {
+        // 1. Find people aged less or equal 18
+        // 2. Then change implementation to find first 10 people
+
+        var youngPeople = gettingStarted.imperativeApproach();
+
+        assertThat(youngPeople.size()).isEqualTo(10);
+        for (Person person : youngPeople) {
+            assertThat(person.getAge()).isLessThanOrEqualTo(18);
+        }
+    }
+
+    @Test
+    void declarativeApproachUsingStreams() {
+        // 1. Find people aged less or equal 18
+        // 2. Then change implementation to find first 10 people
+
+        var youngPeople = gettingStarted.declarativeApproachUsingStreams();
+
+        assertThat(youngPeople.size()).isEqualTo(10);
+        for (Person person : youngPeople) {
+            assertThat(person.getAge()).isLessThanOrEqualTo(18);
+        }
+    }
+}

src/test/java/com/amigoscode/examples/TransformationsMapAndReduceTest.java

@@ -0,0 +1,56 @@
+package com.amigoscode.examples;
+
+import com.amigoscode.beans.Car;
+import com.amigoscode.beans.Person;
+import com.amigoscode.beans.PersonDTO;
+import com.amigoscode.mockdata.MockData;
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+
+class TransformationsMapAndReduceTest {
+
+    @Test
+    void yourFirstTransformationWithMap() throws IOException {
+        List<Person> people = MockData.getPeople();
+
+        var peopleDTos = people.stream()
+                .map(PersonDTO::map)
+                .toList();
+
+        assertThat(people.size()).isEqualTo(peopleDTos.size());
+        peopleDTos.forEach(personDTO -> {
+            long count = people.stream()
+                    .filter(person -> person.getId() == personDTO.getId())
+                    .count();
+            assertThat(count).isEqualTo(1);
+        });
+    }
+
+    @Test
+    void mapToDoubleAndFindAverageCarPrice() throws IOException {
+        var cars = MockData.getCars();
+
+        double averageCarPrice = cars.stream()
+                .mapToDouble(Car::getPrice)
+                .average()
+                .getAsDouble();
+
+        assertThat(averageCarPrice).isEqualTo(52693.19979);
+    }
+
+    @Test
+    void reduce() {
+        int[] integers = {1, 2, 3, 4, 99, 100, 121, 1302, 199};
+
+        var reduced = Arrays.stream(integers)
+                .reduce(0, Integer::sum);
+
+        assertThat(reduced).isEqualTo(1831);
+    }
+}
+

src/test/java/com/amigoscode/examples/WorkingWithStreamsTest.java

@@ -0,0 +1,23 @@
+package com.amigoscode.examples;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+
+class WorkingWithStreamsTest {
+
+    @Test
+    void count_items_on_stream() {
+        var names = List.of("Amigoscode", "Alex", "Zara", "Sarah", "Alan");
+        var stream = names.stream();
+
+        var count = stream
+                .filter(name -> name.charAt(0) == 'A')
+                .limit(2)
+                .count();
+
+        assertThat(count).isEqualTo(2);
+    }
+}