Comp 271 lab 1 - Lists of Strings
- Introduction to Arrays
- Introduction to for loops
In this lab you will build (or finish building) a class StrList,
which is supposed to work a lot like ArrayList<String>.
I have given you a starter version, but some things need fixing. After you
get this version working, you are to implement the generic version
TList<T>, in which the type is supplied as a parameter.
The strings themselves are stored in an array elements[
]. Not all of the array is necessarily used; only the first currsize
slots are (elements through elements[currsize-1]). The variable currsize
thus represents the active length of the StrList, not elements.length.
This way our StrList can easily grow in length, at least up until the hard
limit of elements.length. The
main task of this lab is to implement growing past
I've given you a starter/demo project in IntelliJ for both StrList and
These contain the following methods:
The project also contains class WordTest to add a bunch of words to a list,
thus testing your add() method. The main()
entry point is in WordTest.
- add(string y)
- String get(String n)
- void set(int n, String val)
- int size()
- void print()
You are to do the following:
1. Make add() work even when elements is full
The trick here is to allocate a new array, say newelements,
of larger size (doubling works, or increasing by 10, or increasing by 1.5
although that's trickier because of the floating-point conversions):
 newelements = new string[newsize];
Next you copy from elements[i]
for i<currsize. This is done
with a straightforward for or while loop. Finally, you
replace elements by newelements:
elements = newelements
does it. Note that in Java there is no need to do anything with the "old" elements. In C++ you should call delete on it; see the destructor
~StrList for an example.
At this point, you now have space to add the new item, so you go ahead
and do it. The overall add structure looks like:
if (currsize ==
// do the space expansion as above
to ensure room
// now add the usual way; one way or another we know there
elements[currsize] = y;
currsize += 1;
Once you do this, the program should behave quite differently; you
shouldn't get those "no more room to add ...." messages, and the entire
list should print out.
You can ignore the equals()
and hashCode() methods. For
2. Add a fill() method
Create a method void fill(string val) that is like Add(val)
until the current capacity is reached. That is, element[i]
is set to val provided i>currsize and i<elements.Length
(or i<capacity in the C++
version). I suppose calling it Fill()
rather than fill() would be
With this, the following combination would create a list of 10 empty
StrList sl = new
StrList(10); // currsize = 0 but potential capacity =
3. The generic version: this
should be pretty straightforward. Here I encourage you to write an expand()
method; you might want to do this for the StrList version as well. Note that
get(n) returns null if n is out of range; this works because null is
compatible with any object type.
Note that in the generic version you cannot create an array T elements. Arrays in Java have
to have a "specific" type. It is not clear if there is a good reason for
this. What we do instead is create an array Object
elements. Assigning a value of type T to a component of this array
(as in set()) is legal; Object
variables can be assigned values of type T. But get()
is a little trickier; we take the value out of the array and have to cast
it to type T.
Submit your work on Sakai (or via email) by putting it all into a zip file.
Zip the whole project.