The programming team have decided to replace the array of `Item`objects `(pl)`and the array of `Payment`objects `(tables)`with either a linked list or an ArrayList.

Memory space for the exact number of objects can be assigned;
Whereas the array will (inevitably) waste space/allot more memory than is needed/may run out of allotted memory/there is no need to determine array size;

Award marks as follows, up to $6 max$.
Award $1$ for correct signature.
_Award $1$ for correct initialization of the length of the loop/size of the linked list/_Boolean/Iterator object as appropriate to the solution and appropriate message__displayed at end;
Award $1$ for correct loop.
Award $1$ for correct comparison, with or without getmethods.
Award $1$ for correct updating, with or without get methods.
Award $1$ for early exit if found.
Award $1$ for answer completely correct.

Example 1

public void changePrice(LinkedList pll, String c,
double newPrice)
{
int i = 0;
boolean found = false;
int size = pll.size();
while (i < size && !found)
{
if (pll.get(i).getCode().equals(c)) // allow “=”
{
pll.get(i).setPrice(newPrice);
found = true;
}
i = i + 1;
}
}

Example 2

public void changePrice(LinkedList pll, String c,
double newPrice)
{
Iterator iter = pll.iterator();
boolean found = false;
while (iter.hasNext() && !found)
{
Item current = iter.next();
if (current.getCode().equals(c)) // allow “=”
{
current.setPrice(newPrice);
found = true;
}
}
}

The plarray/Itemobjects could be read into a binary tree;
And placed in order of the Itemcode;
(Successive) comparisons between the search item and tree item will reduce the search space by a half (each time);
Which results in a faster search than a linear search/Olog(n)is better than O(n);
As a linear search might have to loop through the whole list;