1. Users should be able to use to populate the following arrays:
Array Contents
Developer Contains the names of all the developers
assigned to tasks
Task Names Contains the names of all the created tasks
Task ID Contains the generated taskID’s for all tasks
Task Duration Contains the Duration of all tasks
Task Status Contains the Status of all tasks
2. Users should be able to use these arrays to:
a. Display the Developer, Task Names and Task Duration for all tasks with the status of
done.
b. Display the Developer and Duration of the class with the longest duration.
c. Search for a task with a Task Name and display the Task Name, Developer and Task
Status.
d. Search for all tasks assigned to a developer and display the Task Name and Task
Status.
e. Delete a task using the Task Name.
f. Display a report that lists the full details of all captured tasks.
in java
To implement the functionality described above in Java, you can create a class called TaskManager. Here's an example implementation:
```java
import java.util.ArrayList;
import java.util.List;
public class TaskManager {
private List<String> developers;
private List<String> taskNames;
private List<Integer> taskIDs;
private List<Integer> taskDuration;
private List<String> taskStatus;
public TaskManager() {
this.developers = new ArrayList<>();
this.taskNames = new ArrayList<>();
this.taskIDs = new ArrayList<>();
this.taskDuration = new ArrayList<>();
this.taskStatus = new ArrayList<>();
}
public void populateArrays() {
// Code to populate the arrays
}
public void displayDoneTasks() {
for (int i = 0; i < taskStatus.size(); i++) {
if (taskStatus.get(i).equals("done")) {
System.out.println("Developer: " + developers.get(i));
System.out.println("Task Name: " + taskNames.get(i));
System.out.println("Task Duration: " + taskDuration.get(i));
}
}
}
public void displayLongestTask() {
int longestDuration = 0;
int longestTaskIndex = -1;
for (int i = 0; i < taskDuration.size(); i++) {
if (taskDuration.get(i) > longestDuration) {
longestDuration = taskDuration.get(i);
longestTaskIndex = i;
}
}
if (longestTaskIndex != -1) {
System.out.println("Developer: " + developers.get(longestTaskIndex));
System.out.println("Task Duration: " + taskDuration.get(longestTaskIndex));
}
}
public void searchTaskByName(String taskName) {
for (int i = 0; i < taskNames.size(); i++) {
if (taskNames.get(i).equals(taskName)) {
System.out.println("Task Name: " + taskNames.get(i));
System.out.println("Developer: " + developers.get(i));
System.out.println("Task Status: " + taskStatus.get(i));
}
}
}
public void searchTasksByDeveloper(String developer) {
for (int i = 0; i < developers.size(); i++) {
if (developers.get(i).equals(developer)) {
System.out.println("Task Name: " + taskNames.get(i));
System.out.println("Task Status: " + taskStatus.get(i));
}
}
}
public void deleteTask(String taskName) {
int taskIndex = taskNames.indexOf(taskName);
if (taskIndex != -1) {
developers.remove(taskIndex);
taskNames.remove(taskIndex);
taskIDs.remove(taskIndex);
taskDuration.remove(taskIndex);
taskStatus.remove(taskIndex);
} else {
System.out.println("Task not found");
}
}
public void displayAllTasks() {
for (int i = 0; i < taskNames.size(); i++) {
System.out.println("Task Name: " + taskNames.get(i));
System.out.println("Task ID: " + taskIDs.get(i));
System.out.println("Task Duration: " + taskDuration.get(i));
System.out.println("Task Status: " + taskStatus.get(i));
}
}
}
```
You can then use the TaskManager class to perform the desired operations. Here's an example usage:
```java
public class Main {
public static void main(String[] args) {
TaskManager taskManager = new TaskManager();
taskManager.populateArrays();
// Example usage of the methods
System.out.println("Tasks with status done:");
taskManager.displayDoneTasks();
System.out.println("\nTask with longest duration:");
taskManager.displayLongestTask();
System.out.println("\nSearch task by name:");
taskManager.searchTaskByName("Task 1");
System.out.println("\nSearch tasks by developer:");
taskManager.searchTasksByDeveloper("John");
System.out.println("\nDelete task:");
taskManager.deleteTask("Task 1");
System.out.println("\nAll tasks:");
taskManager.displayAllTasks();
}
}
```
Note that you will need to implement the populateArrays() method to actually populate the arrays with data.
Sure! Here's an example code in Java that implements the functionalities mentioned:
```java
import java.util.ArrayList;
import java.util.List;
public class TaskManager {
private List<String> developers;
private List<String> taskNames;
private List<String> taskIDs;
private List<Integer> taskDuration;
private List<String> taskStatus;
public TaskManager() {
developers = new ArrayList<>();
taskNames = new ArrayList<>();
taskIDs = new ArrayList<>();
taskDuration = new ArrayList<>();
taskStatus = new ArrayList<>();
}
// Populating the arrays
public void addTask(String developer, String taskName, String taskID, int duration, String status) {
developers.add(developer);
taskNames.add(taskName);
taskIDs.add(taskID);
taskDuration.add(duration);
taskStatus.add(status);
}
// Display tasks with status "done"
public void displayDoneTasks() {
for (int i = 0; i < taskStatus.size(); i++) {
if (taskStatus.get(i).equals("done")) {
System.out.println("Developer: " + developers.get(i));
System.out.println("Task Name: " + taskNames.get(i));
System.out.println("Task Duration: " + taskDuration.get(i) + " days");
System.out.println("------------------------");
}
}
}
// Display developer and duration of the longest task
public void displayLongestTask() {
int longestDuration = 0;
int index = -1;
for (int i = 0; i < taskDuration.size(); i++) {
if (taskDuration.get(i) > longestDuration) {
longestDuration = taskDuration.get(i);
index = i;
}
}
if (index != -1) {
System.out.println("Developer: " + developers.get(index));
System.out.println("Task Duration: " + taskDuration.get(index) + " days");
}
}
// Search for a task by task name and display details
public void searchTaskByName(String taskName) {
for (int i = 0; i < taskNames.size(); i++) {
if (taskNames.get(i).equals(taskName)) {
System.out.println("Task Name: " + taskNames.get(i));
System.out.println("Developer: " + developers.get(i));
System.out.println("Task Status: " + taskStatus.get(i));
System.out.println("------------------------");
return;
}
}
System.out.println("Task not found");
}
// Search tasks assigned to a developer and display details
public void searchTasksByDeveloper(String developerName) {
for (int i = 0; i < developers.size(); i++) {
if (developers.get(i).equals(developerName)) {
System.out.println("Task Name: " + taskNames.get(i));
System.out.println("Task Status: " + taskStatus.get(i));
System.out.println("------------------------");
}
}
}
// Delete a task by task name
public void deleteTask(String taskName) {
for (int i = 0; i < taskNames.size(); i++) {
if (taskNames.get(i).equals(taskName)) {
developers.remove(i);
taskNames.remove(i);
taskIDs.remove(i);
taskDuration.remove(i);
taskStatus.remove(i);
System.out.println("Task deleted successfully");
return;
}
}
System.out.println("Task not found");
}
// Display the full report of all tasks
public void displayFullReport() {
for (int i = 0; i < developers.size(); i++) {
System.out.println("Developer: " + developers.get(i));
System.out.println("Task Name: " + taskNames.get(i));
System.out.println("Task ID: " + taskIDs.get(i));
System.out.println("Task Duration: " + taskDuration.get(i) + " days");
System.out.println("Task Status: " + taskStatus.get(i));
System.out.println("------------------------");
}
}
public static void main(String[] args) {
TaskManager taskManager = new TaskManager();
// Adding sample tasks
taskManager.addTask("John Doe", "Task 1", "T001", 5, "done");
taskManager.addTask("Jane Smith", "Task 2", "T002", 3, "in progress");
taskManager.addTask("John Doe", "Task 3", "T003", 7, "done");
// Display done tasks
System.out.println("Tasks with status 'done':");
taskManager.displayDoneTasks();
// Display developer and duration of the longest task
System.out.println("Longest task:");
taskManager.displayLongestTask();
// Search for a task by name
System.out.println("Search for task by name:");
taskManager.searchTaskByName("Task 2");
// Search tasks assigned to a developer
System.out.println("Tasks assigned to John Doe:");
taskManager.searchTasksByDeveloper("John Doe");
// Delete a task
taskManager.deleteTask("Task 2");
// Display full report
System.out.println("Full report:");
taskManager.displayFullReport();
}
}
```
Hope this helps! Let me know if you have any questions.