IN JAVA

Task Organizer

Objective:

Write a program in which the user can manage a collection of tasks. Each task has an associated action a priority. The tasks must be organized into a collection of different lists based on their priority value, where the highest priority is $0$ and the lowest is $4.$

Requirements:

$$ Functionality.

o No Syntax, Major Run$-$Time, or Major Logic Errors.

$*$Code that cannot be compiled due to syntax errors is nonfunctional code and will receive no points for this entire section.

$*$Code that cannot be executed or tested due to major run$-$time or logic errors is nonfunctional code and will receive no points for this entire section.

o Use only a Generic Linked List of your own creation.

$*$Other built in types like ArrayLists, LinkedLists, etc will receive no points for this entire section.

$$ You may add, remove, or modify functionality in your generic linked list.

o Clear and Easy$-$To$-$Use Interface.

$$ Users should easily understand what the program does and how to use it$.$

$$ Users should be prompted for input and should be able to enter data easily.

$$ Users should be presented with output after major functions, operations, or calculations.

$$ Users should be able to perform any number of the required functions. In addition, users should be able to choose when to terminate the program.

$$ All the above must apply for full credit.

o Tasks

$$ The program must group together the task$$s action along with its priority.

$$ The action is a simple non$-$null String value that explains the tasks and its default value is $$none$.$

$$ The priority is a whole number value from $0$ to $4$ inclusively where its default value is $4.$

$$ All must apply for full credit.

o Organizing Tasks

$$ The tasks must then be organized into a collection of Lists of tasks based on their priority.

$$ This collection must be an Array of Linked Lists of Tasks.

$$ HINT: This is very similar to multidimensional arrays $($array of arrays of objects$)$ except now it is an array of lists of objects. To declare this kind of structure simple requires creating an Array of the Linked Lists of the Tasks similar to this

GenLL$[]$ organizedTasks;

$$ HINT: While the above declares the array, we also must construct it too by providing the size. Luckily we know that the size has to be $5$ based on the above description, so the code would be similar to this

organizedTasks $=$ new GenLL$[5]$;

$$ HINT: Keep in mind this only constructed the Array and NOT all of the linked lists. Now we need to do that using a simple for$-$loop similar to this

for$($int i$=0$;i$()$;

$\}$

$$ HINT: If you are encountered a $$NullPointerException$$ then make sure the above has been done correctly.

$$ All must apply for full credit.

o Adding Tasks

$$ The user must be able to add a task by specifying the action and its priority.

$$ The task then must be organized in its correct location based on its priority.

$$ The priority must directly correspond to the index of the list, and only add it to the list if it is not already contained.

$$ If there is a duplicate task, then the user must be informed there was a duplicate task and it was not added.

$$ While the task$$s priority specifies which list the task must be added, the lists themselves do not need to be sorted in any way.

$$ All must apply for full credit.

o Removing Tasks

$$ The user must be able to remove a task by specifying the action and its priority.

$$ The program must use the tasks priority to quickly search for and remove the task if it exists.

$$ All must apply for full credit.

o Printing Tasks to the Console

$$ The program must print all the tasks to the console upon request.

$$ It must display both the task$$s priority and its action.

$$ It must print the lists in priority order starting with the highest and ending with the lowest $($priority $0$ to priority $4).$

$$ All must apply for full credit.

o Reading a Tasks File

$$ The program must be able to read from a $$Tasks File$$ and using that information it must populate the collection of lists.

$$ The user must be able to provide the name of the file.

$$ Each task in the file has a priority and an action an end line $($

$).$

$$ Each task$$s priority and action are separated by a tab $(\backslash$t$)$

$$ The $$Tasks File$$ format is:

t

t

$...$

$$ The program should ignore items that do not strictly follow the previously stated format.

$$ Example Task File

$$ The user must be able to load a different task file at any time, and this should replace the information previously stored.

$$ All the above must apply for full credit.

$.$

o Printing a Task File. $(10$pts$)$

$$ The program must be able to print all tasks to a Task File.

$$ All task information including their priority and action must be included and must be formatted in the same way mentioned above.

$$ All must apply for full credit.