Why ArrayList, not Hashtable

[Bruce]

Hi
I am having a problem understanding the exact advantages of using an
ArrayList over a Hashtable in any situation.
In most areas of an application I am working on, lookup needs to be
fast. If I use a hashtable
Addition - O(1) - same as ArrayList
Removal - O(1) - same as ArrayList
Lookup- O(1) - ArrayList is O(n)
Memory - Maybe slightly more than ArrayList since we have a hash to
store.

And even if I need lookup by index which is easy using ArrayList, I
could simply use a Hashtable with the array index as the key and value
as my object.

The only other thing I do not know about is serialization efficiency.

So, my question is, anywhere I need lookup, I can just blindly use a
hashtable? In which situation would it be better to use an ArrayList?

Thanks
Bruce

[Michael Nemtsev]

Hello Bruce,

BSo, my question is, anywhere I need lookup, I can just blindly use a
Bhashtable? In which situation would it be better to use an ArrayList?

Yep. the hashlist advantage over the arraylist in the way of getting value
by key

---
WBR, Michael Nemtsev [C# MVP].
My blog: http://spaces.live.com/laflour
Team blog: http://devkids.blogspot.com/

"The greatest danger for most of us is not that our aim is too high and we
miss it, but that it is too low and we reach it" (c) Michelangelo

[Alun Harford]

Bruce wrote:

Hi
I am having a problem understanding the exact advantages of using an
ArrayList over a Hashtable in any situation.
In most areas of an application I am working on, lookup needs to be
fast. If I use a hashtable
Addition - O(1) - same as ArrayList

Not true. The worst case is O(n). If you have a very bad hash, there
will be n hash collisions when you try to add your element to the
hashtable. (Hashtables in C# also grow automatically, and this may
involve copying all the data in the old hashtable. You get this problem
also with an arraylist, so that's O(n) too).

Removal - O(1) - same as ArrayList

The worst case is O(n). Again, if your hash is very bad.

Lookup- O(1) - ArrayList is O(n)

Again, it's O(n) in the worst case. (If your hash is very bad).

Memory - Maybe slightly more than ArrayList since we have a hash to
store.

The constant of proportionality, k, is likely to be *much* larger in the
case of the hashtable (that's the really big problem).

I think you should read up on O(...) notation, and how hashtables and
arraylists work. You'd probably find it more useful than the answers
you'll get by asking in newsgroups.

Alun Harford