Week 05 - Assignment on Lecture 09 and 10

.gitignore

@@ -1 +1,2 @@
-target
+target
+Help.md

Week 02/Lecture 03/Assignment 05/ListToMap.java

@@ -1,7 +1,7 @@
 import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
-import java.util.stream.Collectors;
+import java.util.TreeMap;
 
 // Assume Employee class with fields: int employeeID, String name, String department
 class Employee {
@@ -46,11 +46,15 @@ public static void main(String[] args) {
                 new Employee(3, "Charlie", "Finance")
         );
 
-        // Convert List to Map using employeeID as key
-        Map<Integer, Employee> employeeMap = employees.stream()
-                .collect(Collectors.toMap(Employee::getEmployeeID, emp -> emp));
+        // Creating employeeMap using TreeMap
+        Map<Integer, String> employeesMap = new TreeMap<>();
+
+        // Convert List to Map
+        for (Employee emp : employees){
+            employeesMap.put(emp.getEmployeeID(), emp.getName());
+        }
 
         // Print the resulting Map
-        employeeMap.forEach((id, emp) -> System.out.println("Employee ID: " + id + ", Employee: " + emp));
+        employeesMap.forEach((id, emp) -> System.out.println("Employee ID: " + id + ", Employee: " + emp));
     }
 }

Week 02/Lecture 03/Assignment 05/README.md

@@ -80,7 +80,7 @@ To remove duplicate lines from a file:
 4. **Writing Unique Lines**: Write only those lines to a new file that haven't been seen before (not in the `HashSet`).
 
 #### 📋 Case CSV Content
-In this program, i use CSV file [`input.csv`](/Week%2002%20-%20Jun%2017-21/Lecture%2003/Assignment%205/data/input.csv) with content like this.
+In this program, i use CSV file [`input.csv`](/Week%2002/Lecture%2003/Assignment%2005/RemoveDuplicates.java) with content like this.
 ```csv
 employeeID,name,department
 1,Alice,HR
@@ -106,6 +106,16 @@ Detail implementation is written on [this code](/Week%2002%20-%20Jun%2017-21/Lec
 
 The output of the program shows on this [`output.csv`](/Week%2002%20-%20Jun%2017-21/Lecture%2003/Assignment%205/data/output.csv)
 
+Here is how to run the updated code of program
+```bash
+$ java RemoveDuplicates <inputFile> <outputFile> <keyFieldIndex>
+```
+
+for example.
+```bash
+java RemoveDuplicates data/input.csv data/output.csv 0
+```
+
 <br>
 
 ### 🖨️ Task 4 - Get a Shallow Copy of a `HashMap`
@@ -166,7 +176,7 @@ Here i implement class `BankAccount` and `BankAccountDemo`.
 3. **Use Java Streams for Transformation**: Utilize Java Streams API to transform the `List` into a `Map`.
 4. **Collect into Map**: Use the `Collectors.toMap()` method to collect elements of the `List` into a `Map` using the specified key and value mappings.
 
-Detail implementation is written on [this code](/Week%2002%20-%20Jun%2017-21/Lecture%2003/Assignment%205/ListToMap.java), and the output of the program shows like this.
+Detail implementation is written on [this code](/Week%2002/Lecture%2003/Assignment%2005/ListToMap.java), and the output of the program shows like this (updated based on comment).
 
 ![Screenshot](img/Task5.png)
 

Week 02/Lecture 03/Assignment 05/RemoveDuplicates.java

@@ -3,29 +3,42 @@
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.PrintWriter;
+import java.util.ArrayList;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Set;
 
 public class RemoveDuplicates {
     public static void main(String[] args) {
-        String inputFileName = "data/input.csv";
-        String outputFileName = "data/output.csv";
-        String delimiter = ","; // Parse CSV format
-
-        // Set to store unique keys (employeeID in this case)
+        if (args.length < 3) {
+            System.out.println("Usage: java RemoveDuplicates <inputFile> <outputFile> <keyFieldIndex>");
+            return;
+        }
+
+        String inputFileName = args[0];
+        String outputFileName = args[1];
+        int keyFieldIndex;
+        try {
+            keyFieldIndex = Integer.parseInt(args[2]);
+        } catch (NumberFormatException e) {
+            System.out.println("Invalid keyFieldIndex. It must be an integer.");
+            return;
+        }
+
+        // Set to store unique keys
         Set<String> seenKeys = new HashSet<>();
-        
+
         try (BufferedReader reader = new BufferedReader(new FileReader(inputFileName));
              PrintWriter writer = new PrintWriter(new FileWriter(outputFileName))) {
 
             String line;
             while ((line = reader.readLine()) != null) {
-                // Split the line into fields
-                String[] fields = line.split(delimiter);
-                
-                // Ensure there are enough fields and key field is valid
-                if (fields.length > 1) {
-                    String key = fields[0]; // Assuming employeeID is the first field
+                // Properly split the line respecting quoted commas
+                String[] fields = parseCsvLine(line);
+
+                // Ensure key field index is valid
+                if (fields.length > keyFieldIndex) {
+                    String key = fields[keyFieldIndex];
                     if (!seenKeys.contains(key)) {
                         seenKeys.add(key); // Add the key to set (marks as seen)
                         writer.println(line); // Write the line to output
@@ -36,7 +49,36 @@ public static void main(String[] args) {
             System.out.println("Duplicates removed successfully. Output written to " + outputFileName);
 
         } catch (IOException e) {
-            System.out.println("I/O Error occured:" + e);
+            System.out.println("I/O Error occurred: " + e);
         }
     }
-}
+
+    // Function to parse CSV line while handling commas within quotes
+    private static String[] parseCsvLine(String line) {
+        boolean inQuotes = false;
+        StringBuilder field = new StringBuilder();
+        List<String> fields = new ArrayList<>();
+
+        for (char c : line.toCharArray()) {
+            switch (c) {
+                case '"':
+                    inQuotes = !inQuotes; // Toggle the inQuotes flag
+                    break;
+                case ',':
+                    if (inQuotes) {
+                        field.append(c); // Inside quotes, include comma
+                    } else {
+                        fields.add(field.toString());
+                        field.setLength(0); // Reset the field buffer
+                    }
+                    break;
+                default:
+                    field.append(c); // Add character to field buffer
+                    break;
+            }
+        }
+        fields.add(field.toString()); // Add last field
+
+        return fields.toArray(new String[0]);
+    }
+}

Week 02/Lecture 04/Assignment 06/README.md

@@ -119,11 +119,22 @@ Here’s a detailed process on how to remove duplicate lines from files based on
 4. **Write the Output**: Write the processed, duplicate-free data to a new file.
 
 #### 👨🏻‍💻 Implementation
-Detail implementation is written on [this code](/Week%2002%20-%20Jun%2017-21/Lecture%2004/Assignment%206/RemoveDuplicatesCSV.java). Here’s what the program actually done.
-1. **Read All Lines**: `Files.readAllLines(Paths.get(inputFilePath))` reads the CSV file into a list of strings.
-2. **Extract Header**: The first line is treated as the header to determine the key field's index.
-3. **Stream Processing**: The stream skips the header, then collects lines into a map using the key field (`id`). If a duplicate key is found, the first occurrence is retained.
-4. **Write Results**: The header is re-added, and the list is written to the new file.
+Detail implementation is written on [this code](/Week%2002/Lecture%2004/Assignment%2006/RemoveDuplicatesCSV.java). Here’s what the program actually done (updated based on comment).
+1. **Initialize Readers and Writers**
+    - `BufferedReader` is used to read the input CSV file line by line.
+    - `BufferedWriter` is used to write the unique lines to the output CSV file.
+2. **Extract and Write Header**
+    - The first line, which is the header, is read using `reader.readLine()`.
+    - This header is written immediately to the output file using `writer.write(header)`.
+3. **Determine Key Field Index**
+    - The header is split to determine the index of the key field (`id`).
+    - This is done by iterating through the headers to find the matching field.
+4. **Stream Processing and Duplicate Removal**
+    - A `Set<String>` is used to keep track of the keys that have already been processed.
+    - For each subsequent line, the key field's value is checked against the `Set`. If the key is unique, the line is written to the output file.
+5. **Read and Write Lines**
+    - The program continues to read each line from the input file, splits it to get the key field, and checks the key against the `Set`.
+    - If the key is not in the `Set`, the line is written to the output file and the key is added to the `Set`.
 
 **Best Practices Highlighted**
 1. **`BufferedReader` for Large Files**: Using `BufferedReader` with `lines()` streams data efficiently.

Week 02/Lecture 04/Assignment 06/RemoveDuplicatesCSV.java

@@ -1,46 +1,55 @@
 import java.io.BufferedReader;
+import java.io.BufferedWriter;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Paths;
-import java.util.Arrays;
-import java.util.List;
-import java.util.stream.Collectors;
+import java.util.HashSet;
+import java.util.Set;
 
 public class RemoveDuplicatesCSV {
     public static void main(String[] args) {
         String inputFilePath = "data/data.csv";
         String outputFilePath = "data/unique.csv";
         String keyFieldName = "id";
 
-        try (BufferedReader reader = Files.newBufferedReader(Paths.get(inputFilePath))) {
-            List<String> lines = reader.lines().collect(Collectors.toList());
-            if (lines.isEmpty()) return;
+        try (BufferedReader reader = Files.newBufferedReader(Paths.get(inputFilePath));
+             BufferedWriter writer = Files.newBufferedWriter(Paths.get(outputFilePath))) {
+
+            String header = reader.readLine();
+            if (header == null) return;
 
-            // Extract header and determine the key field index
-            String header = lines.get(0);
-            List<String> headers = Arrays.asList(header.split(","));
-            int keyIndex = headers.indexOf(keyFieldName);
-            if (keyIndex == -1) throw new IllegalArgumentException("Invalid key field name");
+            // Write header to the output file
+            writer.write(header);
+            writer.newLine();
 
-            // Process lines and remove duplicates based on the key field
-            List<String> uniqueLines = lines.stream()
-                                            .skip(1) // Skip header
-                                            .collect(Collectors.toMap(
-                                                line -> line.split(",")[keyIndex],    // Use the key field
-                                                line -> line,                               // Use the line as value
-                                                (existing, replacement) -> existing         // Keep the first occurrence
-                                            ))
-                                            .values()
-                                            .stream()
-                                            .collect(Collectors.toList());
+            // Determine the key field index
+            String[] headers = header.split(",");
+            int keyIndex = -1;
+            for (int i = 0; i < headers.length; i++) {
+                if (headers[i].trim().equals(keyFieldName)) {
+                    keyIndex = i;
+                    break;
+                }
+            }
+            if (keyIndex == -1) throw new IllegalArgumentException("Invalid key field name");
 
-            // Add header back to the list
-            uniqueLines.add(0, header);
+            // Use a Set to track unique keys
+            Set<String> seenKeys = new HashSet<>();
 
-            // Write the results to a new file
-            Files.write(Paths.get(outputFilePath), uniqueLines);
+            // Read and process each line
+            String line;
+            while ((line = reader.readLine()) != null) {
+                String[] fields = line.split(",");
+                if (fields.length > keyIndex) {
+                    String key = fields[keyIndex];
+                    if (seenKeys.add(key)) { // Add returns false if the key was already present
+                        writer.write(line);
+                        writer.newLine();
+                    }
+                }
+            }
         } catch (IOException e) {
-            System.out.println("I/O Error occured:" + e);
+            System.out.println("I/O Error occurred: " + e);
         }
     }
-}
+}

Week 05/Lecture 09/Assignment 01/README.md

@@ -0,0 +1,115 @@
+# 👨🏻‍🏫 Lecture 09 - Spring MVC
+> This repository is created as a part of assignment for Lecture 09 - Spring MVC
+
+## 🔎 Assignment 01 - Practice the Example
+### 🌳 Project Structure
+```bash
+lecture_9
+├── .mvn/wrapper/
+│   └── maven-wrapper.properties
+├── src/main/
+│   ├── java/com/example/lecture_9/
+│   │   ├── controller/
+│   │   │   └── EmployeeController.java
+│   │   ├── model/
+│   │   │   └── Employee.java
+│   │   ├── repository/
+│   │   │   └── EmployeeRepository.java
+│   │   ├── service/
+│   │   │   ├── impl/
+│   │   │   │   └─ EmployeeServiceImpl.java
+│   │   │   └── EmployeeService.java
+│   │   └── Lecture9Application.java
+│   └── resources/
+│       ├── static/
+│       │   └── index.html
+│       ├── templates/employees/
+│       │   ├── employee-form.html
+│       │   └── list-employees.html
+│       └── application.properties
+├── .gitignore
+├── mvnw
+├── mvnw.cmd
+├── pom.xml
+├── run.bat
+└── run.sh
+```
+
+### 🧩 SQL Query Data
+Here is the SQL query to create the database, table, and instantiate some data, given by the [reference repository](https://github.com/NguyenVanTrieu/spring-mvc).
+```sql
+-- Create the database
+CREATE DATABASE week5_lecture9;
+
+-- Use the database
+USE week5_lecture9;
+
+-- Create the employee table
+CREATE TABLE `employee` (
+    `id` int NOT NULL AUTO_INCREMENT,
+    `first_name` varchar(45) DEFAULT NULL,
+    `last_name` varchar(45) DEFAULT NULL,
+    `email` varchar(45) DEFAULT NULL,
+    PRIMARY KEY (`id`)
+) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=latin1;
+
+-- Insert dummy data into the employee table
+INSERT INTO `employee` VALUES
+(1,'Leslie','Andrews','leslie@luv2code.com'),
+(2,'Emma','Baumgarten','emma@luv2code.com'),
+(3,'Avani','Gupta','avani@luv2code.com'),
+(4,'Yuri','Petrov','yuri@luv2code.com'),
+(5,'Juan','Vega','juan@luv2code.com');
+```
+
+and here is the query to drop the database
+```sql
+-- Drop the database
+DROP DATABASE IF EXISTS week5_lecture9;
+```
+
+Also don't forget to configure [application properties](/Week%2005/Lecture%2009/Assignment%2001/lecture_9/src/main/resources/application.properties) with this format
+```java
+spring.datasource.driver-class-name=com.mysql.jdbc.Driver
+spring.datasource.url=jdbc:mysql://localhost:3306/<your_database>
+spring.datasource.username=<your_user_name>
+spring.datasource.password=<your_password>
+```
+
+### ⚙️ How to run the program
+1. Go to the `lecture_9` directory by using this command
+    ```bash
+    $ cd lecture_9
+    ```
+2. Make sure you have maven installed on your computer, use `mvn -v` to check the version.
+3. If you are using windows, you can run the program by using this command.
+    ```bash
+    $ ./run.bat
+    ```
+    And if you are using Linux, you can run the program by using this command.
+    ```bash
+    $ chmod +x run.sh
+    $ ./run.sh
+    ```
+
+If all the instruction is well executed, the main-view will be something like this.
+
+![Screenshot](img/start.png)
+
+### 📸 Screenshots
+Here is some result of the views and APIs created based on simple MVC architecture. 
+<br>
+#### Initial state
+
+1. **Get All Employees**
+
+    ![Screenshot](img/api1.png)
+2. **Add New Employee**
+
+    ![Screenshot](img/api2.png)
+3. **Edit Existing Employee Data**
+
+    ![Screenshot](img/api3.png)
+4. **Delete Employee**
+
+    ![Screenshot](img/api4.png)