Vector class size limitation

Question

Hi guys,
Does anyone know how big a Vector class can be?
I'm planning to have a Vector object of size ~200,000 to 500,000 elements.
I would really want to use the vector in my design and benefit from its sync feature. The only concern is how reliable it will be..
Has anyone have an idea?
Thanks!

Answer 1

Shouldn't that response be qualified? Somethinglike,
where your datastructure doesn't need to be thread
safe, use an ArrayList? I thought that was theonly
real reason to use ArrayList over Vector. Arethere
other reasons? Anyhow, his answer to your questionis
correct, afaik.If you need synchronization... use ArrayList and the
Collections.synchronizedList() method. Vector has too
many non-List methods.
I still say that is wrong, if your data structure needs to be thread safe, then you should use the synchronize on it where ever you use it.
Is this code thread safe?
Vector memberVector = new Vector();
public void addToVector(Object c, Class cType ) {
memberVector.add( c );
memberVector.add(cType);
}This should produce a vector with alternating objects and then a class that is associated with that object. However, will this code always work?
The answer is no, even though the vector is 'thread safe' this operation is not. If 2 threads call this function on the same instance of the object, then you can get a situation where 2 objects appear in the list one after another. or 2 classes, it really depends on the thread task scheduler. The only difference between this and an ArrayList is that if you had used an ArrayList the internal structure might get messed up and you might get only one of the objects, and 2 classes or some other combination.
So the answer to this problem is this
Vector memberVector = new Vector();
public void addToVector(Object c, Class cType ) {
synchronized ( memberVector ) {
memberVector.add( c );
memberVector.add(cType);
}You must sync on the member vector, but in this case, syncing on 'this' would work as well assuming that you used data encapsulation.
I can't 'prove' it, but if you use proper syncing, then Vector, or any 'thread safe' data structure is no better then a non-thread safe version. It may be that it's easier to debug (sometimes) when dealing with vectors, since no elements will accidently be overwritten ,etc. But it's still unsafe.