08-03. Shopping list

This programme will allow the user to keep a shopping list as a text file and sort it into alphabetical order.

We have our usual boilerplate and we'll need to use collections for storing the shopping list in memory and I O for reading and writing it to a file.

In our main programme, we will simply call the menu subprogram.

Let's write the code for that now.

Static void menu.

We'll hold the user's choice in a variable identified as choice and assign that to be an empty string to start.

There will be four options, with the fourth being to end the programme.

So while choice is not, four will allow the programme to keep going, presenting options to the user until they close the programme.

Remember, all inputs are strings, so this is qualified with double Quotes.

Output the four options to the user 1 add an item, 2 output the shopping list, 3 sort the list and 4 quit.

The user may make an invalid input when we collect it in a moment.

So we could use a while loop to keep asking until we get a valid input while choice not in the list Of Valid inputs 1, 2, 3, 3 or 4.

This isn't very scalable.

That means if the number of options increased, this would not be a good way to code this.

We'd want to do something less tedious.

One way could be to store the valid options in an array and cheque if the input is in the array.

You might also recognise that this while loop isn't really needed at all, since we're looping until the user inputs are 4 anyway and you'd be correct.

Prompt the user for their choice and store that in choice.

Switch from the user's choice.

If it's one, then call the add item subprogram and reset the choice.

If it's two, then call the output items subprogram and reset the choice.

And if it's three then call the sortitems subprogram and reset the choice.

That's the menu written.

And this code is a pretty standard algorithm.

You can use it in all situations where you want a user selection.

Coding it in a subprogram means we've created a reusable programme component.

We can copy and paste it into other programmes and it will work just fine.

Ok.

On, to adding an item.

Next, static void Add item.

The new item will become what is input by the user with a helpful prompt.

The items will be stored in a file so the user can close the programme, open it later, and continue writing their shopping list.

A stream writer provides a pipe file writer.

to the file shopping Txt with True as a second argument.

So we don't overwrite the data that's already there.

We can now, use filewriter, writeline to put the new item into the file and finally we close our file.

Next, we want a routine to output all the items.

Static void output items.

Now, if this is the first time the programme is run or the user has deleted the shopping list, the file might not exist, which would cause the programme to crash.

We can trap that using what is called exception handling.

Anything that can happen when the programme is running that could cause a problem is known as an exception.

This could be printing when there's no ink in the printer, writing a file to a drive that's full.

Lots of different things that should be foreseen when we write programmes.

We didn't cheque if this was likely to be an issue with the drive when we added the items.

And really we should have done so.

So let's do that this time.

Instead we want to try and open the shopping list file and if we can't, instead of crashing, do something else.

The command for that is try, followed by what we want to try.

So assigning the file pipe and reading the contents of the file.

Here we're going to take another new approach just to show you different ways of achieving the same thing.

We read the contents of the file into a variable called filecontent and then we're going to split it up using the end of line markers into an array identified as item.

Don't worry if this all looks a little complicated.

We could have read the text file in a line at a time and added each line to a list as we go.

Instead, this way isn't any better and could actually be more of a problem.

With large files then we handle our exceptions with the command catch.

There are lots of built in constants for different kinds of errors.

The one we want is filenotfoundexception for a file that cannot be found.

In that case, we want to make a blank file to assign the file pipe for writing to shopping Txt instead and close the file.

That will put an empty file on our drive.

Finally, sorting our, shopping list into alphabetical order.

Static void sort items.

You can't sort items directly in the file, so the process is to read the data in from the file into an array or list and then sort the array or list before outputting it back to the file.

For exams you need to know how sorting algorithms actually work, but we'll use array sort for that to take away the work.

Our file might not exist, so try to assign a pipe identified as file reader to the shopping.

Txt file read in the data.

If you can, close the file and then split it up into an array called items.

Then use the array sort method to sort the data in memory before writing it back out to the file, this time overwriting what was already there.

Catch an error if this happens because the file doesn't exist and, write an empty file instead.

That's the programme for our shopping list written.

Give it a try and cheque it works.