Hi guys, I'm the author of fastUtil.
There are a lot of issues in this thread, so I'll just try to give my perspective.
1) I wrote this stuff because I needed hash-based sets and maps with high performance and small memory footprint for a web crawler I'm developing with other people. We already use several type-specific classes in the COLT distribution, but it did not contain everything we needed.
2) Genericity in Java *as currently specified* is useful syntactic sugar, but no more; certainly it does not apply to primitive types, certainly does not solve the wrap/unwrap problem, and possibly (but I wouldn't bet on it) could even reduce performance.
3) fastUtil is clearly "inspired" by C++ templates. There is however a major difference: because of the way Java handles classes, you can precompile everything (you will end up loading only the class you use anyway). This has a number of advantages.
4) The speed gain with fastUtil is certainly also due to less garbage collection but for the most to better algorithms. Sincerely, I haven't seen in the last years anyone implementing closed addressing (as Sun did). Its only advantage is that it handles slightly better deletions. Probably they also thought that since they had to wrap primitive types, there would have been no real disadvantage in wrapping *again* the wrapper in an Entry object. I don't know--I just know that those classes are completely useless for my needs. The algorithms used in fastUtil are simple but effective. They use all the known theory about hash tables to squeeze every bit of performance (e.g., using twin primes). Moreover, the important functions are willingly coded as tight loops contained in a single method, so that they end up being optimised very soon.
5) fastUtil uses theory, but tries to be pragmatic. Yes, you can use an additional pointer per entry to keep a list of entries, so that iteration is linear in the number of entries. However, in the real world a 75% filled table scanned with a tight loop will always give faster iteration, even if you have a slight overhead due to empty/deleted buckets. This can hinder performance if the table contains mostly deleted entries, but again, fastUtil is optimised for the *general* case.
I have almost finished developing a replacement for sorted sets and maps. It consumes only one integer and two references per stored element (against three references and one boolean for java.util). Of course, it doesn't need wrappers.
If anyone is interested in beta testing, please let me know.