Обсуждение: Cleanup patch: Change from Vector/Hashtable to ArrayList/HashMap
Hi, Here are two small cleanup patches. First one replaces all Vector references with List (usage) and ArrayList (creation). Second replaces all Hashtable references with Map (usage) and HashMap (creation). Reasons: * Theoretically faster since the ArrayList/HashMap are not synchronized * Using interfaces makes changing of List/Map implementations easier at later time * Vector/Hashtable were deprecated already in Java 1.2 -Mikko
Mikko Tiihonen wrote: > Hi, > > Here are two small cleanup patches. > > First one replaces all Vector references with List (usage) and ArrayList > (creation). > Second replaces all Hashtable references with Map (usage) and HashMap > (creation). > > Reasons: > * Theoretically faster since the ArrayList/HashMap are not synchronized > * Using interfaces makes changing of List/Map implementations easier at > later time > * Vector/Hashtable were deprecated already in Java 1.2 My JDK 6 documentation gives no indication that either Vector or Hashtable as being deprecated. Rather them being retrofitted into the Collectionss Framework at 1.2. The main difference being that as you said they are synchronized, which a developer may wish to have for that type of data structure. danap. > > -Mikko
> My JDK 6 documentation gives no indication that either Vector or Hashtable
> as being deprecated. Rather them being retrofitted into the Collectionss
> Framework at 1.2. The main difference being that as you said they are
> synchronized, which a developer may wish to have for that type of data
> structure.
> as being deprecated. Rather them being retrofitted into the Collectionss
> Framework at 1.2. The main difference being that as you said they are
> synchronized, which a developer may wish to have for that type of data
> structure.
They were indeed not officially deprecated as some other things in the JDK are, but they were most definitely 'effectively' deprecated. No programmer in his or her right might has used those structures since.
dmp skrev 2012-05-06 20.03: > Mikko Tiihonen wrote: > > Hi, > > > > Here are two small cleanup patches. > > > > First one replaces all Vector references with List (usage) and ArrayList > > (creation). > > Second replaces all Hashtable references with Map (usage) and HashMap > > (creation). > > > > Reasons: > > * Theoretically faster since the ArrayList/HashMap are not synchronized > > * Using interfaces makes changing of List/Map implementations easier at > > later time > > * Vector/Hashtable were deprecated already in Java 1.2 > > My JDK 6 documentation gives no indication that either Vector or Hashtable > as being deprecated. Rather them being retrofitted into the Collectionss > Framework at 1.2. The main difference being that as you said they are > synchronized, which a developer may wish to have for that type of data > structure. They are not deprecated in the "this might go away" sense, but it was discovered that having self-synchronized collection classes rarely is enough to provide thread safety, rather synchronization usually has to be handled in a larger scope than the individual method call. Therefore, if you think Vector makes your code thread-safe, you need to think again. Even if works it usually a very expensive way of accomplishing the goal. -- robin
dmp skrev 2012-05-06 20.03: > Mikko Tiihonen wrote: > > Hi, > > > > Here are two small cleanup patches. > > > > First one replaces all Vector references with List (usage) and ArrayList > > (creation). > > Second replaces all Hashtable references with Map (usage) and HashMap > > (creation). > > > > Reasons: > > * Theoretically faster since the ArrayList/HashMap are not synchronized > > * Using interfaces makes changing of List/Map implementations easier at > > later time > > * Vector/Hashtable were deprecated already in Java 1.2 > > My JDK 6 documentation gives no indication that either Vector or Hashtable > as being deprecated. Rather them being retrofitted into the Collectionss > Framework at 1.2. The main difference being that as you said they are > synchronized, which a developer may wish to have for that type of data > structure. They are not deprecated in the "this might go away" sense, but it was discovered that having self-synchronized collection classes rarely is enough to provide thread safety, rather synchronization usually has to be handled in a larger scope than the individual method call. Therefore, if you think Vector makes your code thread-safe, you need to think again. Even if works it usually a very expensive way of accomplishing the goal. -- robin
Some old 1.0 'Collections' (namely Vector and HashTable) where marked obsolete, they won't disappear beacause they are too widely used, but they are very inefficient, so they have better alternatives (ArrayList and HashMap), event if you want an synchronized List or Map you should use Collections.synchronized[Collection|Map|List|Set] and not use the old classes.
However same uses of Vector don't work with newer classes, for example, the method set won't work on ArrayList (ArrayList with size 10 and set at position 20, you get Exception, on Vector it works).
So, excluding the example above, it is a good thing to replace Vector by List/ArrayList and Hashtable by Map/HashMap.
In some case LinkedList is better than ArrayList.
Luis Flores
On Sun, May 6, 2012 at 8:59 PM, Robin Rosenberg <robin.rosenberg@dewire.com> wrote:
dmp skrev 2012-05-06 20.03:Mikko Tiihonen wrote:
> Hi,
>
> Here are two small cleanup patches.
>
> First one replaces all Vector references with List (usage) and ArrayList
> (creation).
> Second replaces all Hashtable references with Map (usage) and HashMap
> (creation).
>
> Reasons:
> * Theoretically faster since the ArrayList/HashMap are not synchronized
> * Using interfaces makes changing of List/Map implementations easier at
> later time
> * Vector/Hashtable were deprecated already in Java 1.2
My JDK 6 documentation gives no indication that either Vector or Hashtable
as being deprecated. Rather them being retrofitted into the Collectionss
Framework at 1.2. The main difference being that as you said they are
synchronized, which a developer may wish to have for that type of data
structure.They are not deprecated in the "this might go away" sense, but it was discovered
that having self-synchronized collection classes rarely is enough to provide
thread safety, rather synchronization usually has to be handled in a larger
scope than the individual method call. Therefore, if you think Vector makes
your code thread-safe, you need to think again. Even if works it usually a
very expensive way of accomplishing the goal.
-- robin--
Sent via pgsql-jdbc mailing list (pgsql-jdbc@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-jdbc
Luis Flores wrote: > So, excluding the example above, it is a good thing to replace Vector by > List/ArrayList and Hashtable by Map/HashMap. > In some case LinkedList is better than ArrayList. Which is exactly why _usage_ of the list should be through the 'List' interface regardless of the implementation class. -- Lew Honi soit qui mal y pense. http://upload.wikimedia.org/wikipedia/commons/c/cf/Friz.jpg
On Sun, May 6, 2012 at 12:25 PM, Mikko Tiihonen <mikko.tiihonen@nitorcreations.com> wrote: > Hi, > > Here are two small cleanup patches. > > First one replaces all Vector references with List (usage) and ArrayList > (creation). > Second replaces all Hashtable references with Map (usage) and HashMap > (creation). > > Reasons: > * Theoretically faster since the ArrayList/HashMap are not synchronized > * Using interfaces makes changing of List/Map implementations easier at > later time > * Vector/Hashtable were deprecated already in Java 1.2 > > -Mikko > > > -- > Sent via pgsql-jdbc mailing list (pgsql-jdbc@postgresql.org) > To make changes to your subscription: > http://www.postgresql.org/mailpref/pgsql-jdbc > Mikko, Thanks for the patch it has been applied to master Dave Cramer dave.cramer(at)credativ(dot)ca http://www.credativ.ca