If you come from the good ol' days of Turing, you're probably familiar with the idea of a 'flexible array.' A collection of items whose capacity to store information can be increased and decreased at whim. Upon arriving at Java, you'll quickly realize that Java's "Array" object has no such feature. Worry not, though! Java has an alternative, one which is easy to use and has all the features you could want. I introduce to you, Java hopefuls, the Vector.
Importing
This is easy. Vectors are a part of the java.util package. Therefore, all you need to add Vectors to your program is:
| Java: |
import java.util.Vector;
|
Creating a New Vector
The Vector has a few constructor methods. I'll go over the more complex one over with you, and it really should be the only one you ever use.
| Java: |
The first arg, initialCapacity, sets the original size of the Vector. The second arg, incr, means increment -- how much will be added to the capacity every time it needs to be expanded. For example
| Java: |
This will create a new Vector that has a size of 5 -- it can store 5 pieces of information. If you try to store a sixth piece, it will automatically jump to 8 (5+3). If you add nine, it'll jump to 12, and so on. How does one add to a Vector, you ask?
Adding to a Vector
There are actually three ways to do this, all of them very simple. This should be a breeze for someone as smart as you, right?
First of all, the easiest way to add to a vector is
| Java: |
This will simply take your Object (such as a String, Integer, Float, or just about anything else) and append it to the next slot in the Vector. If the Vector is at its full capacity, it will expand the Vector by whatever amount you set in the constructor method. If you used one of the other constructor methods that did not require an increment, it will double whatever capacity it had before. The return type of this method is 'boolean' but it will always return true as long as the operation was carried out succesfully.
Of course, sometimes you'll want to stick an object into a Vector in some place besides the very end of it. So we have:
| Java: |
This looks a lot like the other add, except now we're telling it where in the array to place the Object (that's what the first argument is). If the index already has something in it, then add will shift all of the elements following this array down (by adding 1 to their indices). So, for example:
| Java: |
v.add(5,"Five"); |
will add the string "Five" to the fifth position in the vector. The previous fifth element will become the sixth element, the previous sixth will become the seventh, and so on. Careful, though-- this method can throw an ArrayIndexOutOfBoundsException if the index is not valid.
The last main way of adding to a Vector is by replacing a specific index with some other data without affecting any of the indices after it.
| Java: |
This should be pretty obvious. setElementAt will replace whatever was at index 'index' with 'o' and leave the rest of the Vector untouched. So, continuing our previous example,
| Java: |
v.setElementAt("Six",5); |
will replace the "Five" object we just added in the last step to "Six."
Removing Elements in a Vector
Removing elements in an array works a lot like adding them.
| Java: |
This will remove whatever object was at 'index' from the Vector, and shifts all the indices after it back one position (subtracts 1 from their position). It returns the Object that was removed. The complement to this method is:
| Java: |
This method, very useful, will look through a vector for the first occurence of Object o, remove it, shift all the remaining indices down one, and return the position that was removed. And finally,
| Java: |
protected void removeRange(int lowerBound, int upperBound){ |
This method will remove an entire range of indices. For example, if you have a Vector of 10 indices, and the objects contained is a String containing the word that represents it's index (5 = "Five", etc) then
| Java: |
foo.removeRange(3,6); |
will leave you with a vector that looks like ("One","Two","Six","Seven","Eight","Nine","Ten"). The lower bound is inclusive, the upper bound is EXclusive.
To Be Continued...
Well, there's lots more to Vectors than this, of course
But first I want to get some feedback on what I have so far, and see if anyone's interested in the rest of this. Coming up next: How to have your vectors interact with Collections and Arrays directly! Also, some important vector diagnostic tools (finding it's current size, capacity, etc).
See you next time!
