diff --git a/compilers/eclipse/src/main/java/org/apache/commons/jci/compilers/EclipseJavaCompiler.java b/compilers/eclipse/src/main/java/org/apache/commons/jci/compilers/EclipseJavaCompiler.java
index 7c74dfe..fb96d41 100644
--- a/compilers/eclipse/src/main/java/org/apache/commons/jci/compilers/EclipseJavaCompiler.java
+++ b/compilers/eclipse/src/main/java/org/apache/commons/jci/compilers/EclipseJavaCompiler.java
@@ -61,7 +61,7 @@
         this(new EclipseJavaCompilerSettings());
     }
 
-    public EclipseJavaCompiler( final Map pSettings ) {
+    public EclipseJavaCompiler( final Map<String, String> pSettings ) {
         defaultSettings = new EclipseJavaCompilerSettings(pSettings);
     }
 
@@ -139,7 +139,7 @@
 
         final Map settingsMap = new EclipseJavaCompilerSettings(pSettings).toNativeSettings();
 
-        final Collection problems = new ArrayList();
+        final Collection<CompilationProblem> problems = new ArrayList<CompilationProblem>();
 
         final ICompilationUnit[] compilationUnits = new ICompilationUnit[pSourceFiles.length];
         for (int i = 0; i < compilationUnits.length; i++) {
@@ -345,9 +345,7 @@
         final ICompilerRequestor compilerRequestor = new ICompilerRequestor() {
             public void acceptResult( final CompilationResult pResult ) {
                 if (pResult.hasProblems()) {
-                    final IProblem[] iproblems = pResult.getProblems();
-                    for (int i = 0; i < iproblems.length; i++) {
-                        final IProblem iproblem = iproblems[i];
+                    for (IProblem iproblem : pResult.getProblems()) {
                         final CompilationProblem problem = new EclipseCompilationProblem(iproblem);
                         if (problemHandler != null) {
                             problemHandler.handle(problem);
@@ -357,8 +355,7 @@
                 }
                 if (!pResult.hasErrors()) {
                     final ClassFile[] clazzFiles = pResult.getClassFiles();
-                    for (int i = 0; i < clazzFiles.length; i++) {
-                        final ClassFile clazzFile = clazzFiles[i];
+                    for (ClassFile clazzFile : clazzFiles) {
                         final char[][] compoundName = clazzFile.getCompoundName();
                         final StringBuilder clazzName = new StringBuilder();
                         for (int j = 0; j < compoundName.length; j++) {
diff --git a/compilers/eclipse/src/main/java/org/apache/commons/jci/compilers/EclipseJavaCompilerSettings.java b/compilers/eclipse/src/main/java/org/apache/commons/jci/compilers/EclipseJavaCompilerSettings.java
index 66c0bdf..8b03783 100644
--- a/compilers/eclipse/src/main/java/org/apache/commons/jci/compilers/EclipseJavaCompilerSettings.java
+++ b/compilers/eclipse/src/main/java/org/apache/commons/jci/compilers/EclipseJavaCompilerSettings.java
@@ -29,7 +29,7 @@
  */
 public final class EclipseJavaCompilerSettings extends JavaCompilerSettings {
 
-    final private Map defaultEclipseSettings = new HashMap();
+    final private Map<String, String> defaultEclipseSettings = new HashMap<String, String>();
 
     public EclipseJavaCompilerSettings() {
         defaultEclipseSettings.put(CompilerOptions.OPTION_LineNumberAttribute, CompilerOptions.GENERATE);
@@ -46,11 +46,11 @@
     	}
     }
     
-    public EclipseJavaCompilerSettings( final Map pMap ) {
+    public EclipseJavaCompilerSettings( final Map<String, String> pMap ) {
         defaultEclipseSettings.putAll(pMap);
     }
 
-    private static Map nativeVersions = new HashMap() {
+    private static Map<String, String> nativeVersions = new HashMap<String, String>() {
 		private static final long serialVersionUID = 1L;
 	{
     	put("1.1", CompilerOptions.VERSION_1_1);
@@ -63,7 +63,7 @@
     }};
     
     private String toNativeVersion( final String pVersion ) {
-    	final String nativeVersion = (String) nativeVersions.get(pVersion);
+    	final String nativeVersion = nativeVersions.get(pVersion);
     	
     	if (nativeVersion == null) {
     		throw new RuntimeException("unknown version " + pVersion);
@@ -72,8 +72,8 @@
     	return nativeVersion;
     }
     
-    Map toNativeSettings() {
-        final Map map = new HashMap(defaultEclipseSettings);
+    Map<String, String> toNativeSettings() {
+        final Map<String, String> map = new HashMap<String, String>(defaultEclipseSettings);
 
         map.put(CompilerOptions.OPTION_SuppressWarnings, isWarnings()?CompilerOptions.GENERATE:CompilerOptions.DO_NOT_GENERATE);
         map.put(CompilerOptions.OPTION_ReportDeprecation, isDeprecations()?CompilerOptions.GENERATE:CompilerOptions.DO_NOT_GENERATE);
diff --git a/compilers/groovy/src/main/java/org/apache/commons/jci/compilers/GroovyJavaCompiler.java b/compilers/groovy/src/main/java/org/apache/commons/jci/compilers/GroovyJavaCompiler.java
index ab63eed..0f872e9 100644
--- a/compilers/groovy/src/main/java/org/apache/commons/jci/compilers/GroovyJavaCompiler.java
+++ b/compilers/groovy/src/main/java/org/apache/commons/jci/compilers/GroovyJavaCompiler.java
@@ -21,7 +21,6 @@
 
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.Iterator;
 import java.util.List;
 
 import org.apache.commons.jci.problems.CompilationProblem;
@@ -80,24 +79,22 @@
             unit.addSource(source[i]);
         }
         
-        final Collection problems = new ArrayList();
+        final Collection<CompilationProblem> problems = new ArrayList<CompilationProblem>();
 
         try {
             log.debug("compiling");
             unit.compile(Phases.CLASS_GENERATION);
             
-            final List classes = unit.getClasses();
-            for (final Iterator it = classes.iterator(); it.hasNext();) {
-                final GroovyClass clazz = (GroovyClass) it.next();
+            final List<GroovyClass> classes = (List<GroovyClass>) unit.getClasses();
+            for (GroovyClass clazz : classes) {
                 final byte[] bytes = clazz.getBytes();
                 pStore.write(ConversionUtils.convertClassToResourcePath(clazz.getName()), bytes);
             }
         } catch (final MultipleCompilationErrorsException e) {
             final ErrorCollector col = e.getErrorCollector();
-            final Collection warnings = col.getWarnings();
+            final Collection<WarningMessage> warnings = (Collection<WarningMessage>) col.getWarnings();
             if (warnings != null) {
-                for (final Iterator it = warnings.iterator(); it.hasNext();) {
-                    final WarningMessage warning = (WarningMessage) it.next();
+                for (WarningMessage warning : warnings) {
                     final CompilationProblem problem = new GroovyCompilationProblem(warning); 
                     if (problemHandler != null) {
                         problemHandler.handle(problem);
@@ -106,10 +103,9 @@
                 }
             }
 
-            final Collection errors = col.getErrors();
+            final Collection<Message> errors = (Collection<Message>) col.getErrors();
             if (errors != null) {
-                for (final Iterator it = errors.iterator(); it.hasNext();) {
-                    final Message message = (Message) it.next();
+                for (Message message : errors) {
                     final CompilationProblem problem = new GroovyCompilationProblem(message); 
                     if (problemHandler != null) {
                         problemHandler.handle(problem);
diff --git a/compilers/janino/src/main/java/org/apache/commons/jci/compilers/JaninoJavaCompiler.java b/compilers/janino/src/main/java/org/apache/commons/jci/compilers/JaninoJavaCompiler.java
index c418c2f..068503f 100644
--- a/compilers/janino/src/main/java/org/apache/commons/jci/compilers/JaninoJavaCompiler.java
+++ b/compilers/janino/src/main/java/org/apache/commons/jci/compilers/JaninoJavaCompiler.java
@@ -104,7 +104,7 @@
     
     public CompilationResult compile( final String[] pSourceNames, final ResourceReader pResourceReader, final ResourceStore pStore, final ClassLoader pClassLoader, final JavaCompilerSettings pSettings ) {
 
-    	final Collection problems = new ArrayList();
+    	final Collection<CompilationProblem> problems = new ArrayList<CompilationProblem>();
     	
     	final StringPattern[] pattern = StringPattern.PATTERNS_NONE;
 
diff --git a/compilers/rhino/src/main/java/org/apache/commons/jci/compilers/RhinoJavaCompiler.java b/compilers/rhino/src/main/java/org/apache/commons/jci/compilers/RhinoJavaCompiler.java
index 0d949d7..3781129 100644
--- a/compilers/rhino/src/main/java/org/apache/commons/jci/compilers/RhinoJavaCompiler.java
+++ b/compilers/rhino/src/main/java/org/apache/commons/jci/compilers/RhinoJavaCompiler.java
@@ -24,6 +24,7 @@
 import java.io.Reader;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.List;
 
 import org.apache.commons.jci.problems.CompilationProblem;
 import org.apache.commons.jci.readers.ResourceReader;
@@ -67,7 +68,7 @@
         private final ResourceReader reader;
         private final ResourceStore store;
 
-        private final Collection problems = new ArrayList();
+        private final Collection<CompilationProblem> problems = new ArrayList<CompilationProblem>();
         
         private final class ProblemCollector implements ErrorReporter {
 
@@ -109,7 +110,7 @@
             Context.exit();
         }
 
-        public Collection getProblems() {
+        public Collection<CompilationProblem> getProblems() {
             return problems;
         }
 
@@ -143,7 +144,7 @@
                 superclass = Class.forName((String) baseClassName);
             }
 
-            final ArrayList interfaceClasses = new ArrayList();
+            final List<Class> interfaceClasses = new ArrayList<Class>();
 
             final Object interfaceNames = ScriptableObject.getProperty(target, "__implements__");
 
@@ -265,7 +266,7 @@
             }
         }
 
-        final Collection problems = cl.getProblems();
+        final Collection<CompilationProblem> problems = cl.getProblems();
         final CompilationProblem[] result = new CompilationProblem[problems.size()];
         problems.toArray(result);
         return new CompilationResult(result);
diff --git a/compilers/rhino/src/test/java/org/apache/commons/jci/compilers/RhinoJavaCompilerTestCase.java b/compilers/rhino/src/test/java/org/apache/commons/jci/compilers/RhinoJavaCompilerTestCase.java
index c21cf47..7e0b139 100644
--- a/compilers/rhino/src/test/java/org/apache/commons/jci/compilers/RhinoJavaCompilerTestCase.java
+++ b/compilers/rhino/src/test/java/org/apache/commons/jci/compilers/RhinoJavaCompilerTestCase.java
@@ -41,7 +41,7 @@
         final JavaCompiler compiler = createJavaCompiler(); 
 
         final ResourceReader reader = new ResourceReader() {
-            final private Map sources = new HashMap() {
+            final private Map<String, byte[]> sources = new HashMap<String, byte[]>() {
                 private static final long serialVersionUID = 1L;
                 {
                     put("jci/Simple.js", (
@@ -51,7 +51,7 @@
                 }};
 
             public byte[] getBytes( final String pResourceName ) {
-                return (byte[]) sources.get(pResourceName);
+                return sources.get(pResourceName);
             }
 
             public boolean isAvailable( final String pResourceName ) {
@@ -84,7 +84,7 @@
         final JavaCompiler compiler = createJavaCompiler(); 
 
         final ResourceReader reader = new ResourceReader() {
-            final private Map sources = new HashMap() {
+            final private Map<String, byte[]> sources = new HashMap<String, byte[]>() {
                 private static final long serialVersionUID = 1L;
                 {
                     put("Jci/Simple.js", (
@@ -94,7 +94,7 @@
                 }};
 
             public byte[] getBytes( final String pResourceName ) {
-                return (byte[]) sources.get(pResourceName);
+                return sources.get(pResourceName);
             }
 
             public boolean isAvailable( final String pResourceName ) {
diff --git a/core/src/main/java/org/apache/commons/jci/compilers/CompilationResult.java b/core/src/main/java/org/apache/commons/jci/compilers/CompilationResult.java
index fadadc3..21a1480 100644
--- a/core/src/main/java/org/apache/commons/jci/compilers/CompilationResult.java
+++ b/core/src/main/java/org/apache/commons/jci/compilers/CompilationResult.java
@@ -35,11 +35,10 @@
     private final CompilationProblem[] warnings;
         
     public CompilationResult( final CompilationProblem[] pProblems ) {
-        final Collection errorsColl = new ArrayList();
-        final Collection warningsColl = new ArrayList();
+        final Collection<CompilationProblem> errorsColl = new ArrayList<CompilationProblem>();
+        final Collection<CompilationProblem> warningsColl = new ArrayList<CompilationProblem>();
 
-        for (int i = 0; i < pProblems.length; i++) {
-            final CompilationProblem problem = pProblems[i];
+        for (CompilationProblem problem : pProblems) {
             if (problem.isError()) {
                 errorsColl.add(problem);
             } else {
diff --git a/core/src/main/java/org/apache/commons/jci/compilers/JavaCompilerFactory.java b/core/src/main/java/org/apache/commons/jci/compilers/JavaCompilerFactory.java
index 337e273..9d2ba5c 100644
--- a/core/src/main/java/org/apache/commons/jci/compilers/JavaCompilerFactory.java
+++ b/core/src/main/java/org/apache/commons/jci/compilers/JavaCompilerFactory.java
@@ -37,7 +37,7 @@
      */
     private static final JavaCompilerFactory INSTANCE = new JavaCompilerFactory();
 
-    private final Map classCache = new HashMap();
+    private final Map<String, Class> classCache = new HashMap<String, Class>();
     
     /**
      * @deprecated will be remove after the next release, please create an instance yourself
diff --git a/core/src/main/java/org/apache/commons/jci/listeners/CompilingListener.java b/core/src/main/java/org/apache/commons/jci/listeners/CompilingListener.java
index bdf7141..e92cd17 100644
--- a/core/src/main/java/org/apache/commons/jci/listeners/CompilingListener.java
+++ b/core/src/main/java/org/apache/commons/jci/listeners/CompilingListener.java
@@ -20,7 +20,6 @@
 import java.io.File;
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.Iterator;
 
 import org.apache.commons.jci.compilers.CompilationResult;
 import org.apache.commons.jci.compilers.JavaCompiler;
@@ -99,20 +98,18 @@
     }
 
     public String[] getResourcesToCompile( final FilesystemAlterationObserver pObserver ) {
-        final Collection created = getCreatedFiles();
-        final Collection changed = getChangedFiles();
+        final Collection<File> created = getCreatedFiles();
+        final Collection<File> changed = getChangedFiles();
 
-        final Collection resourceNames = new ArrayList();
+        final Collection<String> resourceNames = new ArrayList<String>();
         
-        for (final Iterator it = created.iterator(); it.hasNext();) {
-            final File createdFile = (File) it.next();
+        for (File createdFile : created) {
             if (createdFile.getName().endsWith(getSourceFileExtension())) {
                 resourceNames.add(getSourceNameFromFile(pObserver, createdFile));
             }
         }
         
-        for (final Iterator it = changed.iterator(); it.hasNext();) {
-            final File changedFile = (File) it.next();
+        for (File changedFile : changed) {
             if (changedFile.getName().endsWith(getSourceFileExtension())) {
                 resourceNames.add(getSourceNameFromFile(pObserver, changedFile));
             }
@@ -126,16 +123,14 @@
     public boolean isReloadRequired( final FilesystemAlterationObserver pObserver ) {
         boolean reload = false;
 
-        final Collection created = getCreatedFiles();
-        final Collection changed = getChangedFiles();
-        final Collection deleted = getDeletedFiles();
+        final Collection<File> created = getCreatedFiles();
+        final Collection<File> changed = getChangedFiles();
+        final Collection<File> deleted = getDeletedFiles();
         
         log.debug("created:" + created.size() + " changed:" + changed.size() + " deleted:" + deleted.size() + " resources");
 
         if (deleted.size() > 0) {
-            for (Iterator it = deleted.iterator(); it.hasNext();) {
-                final File deletedFile = (File) it.next();
-
+            for (File deletedFile : deleted) {
                 final String resourceName = ConversionUtils.getResourceNameFromFileName(ConversionUtils.relative(pObserver.getRootDirectory(), deletedFile));
                 
                 if (resourceName.endsWith(getSourceFileExtension())) {
diff --git a/core/src/main/java/org/apache/commons/jci/listeners/ReloadingListener.java b/core/src/main/java/org/apache/commons/jci/listeners/ReloadingListener.java
index 15c64eb..9668b5a 100644
--- a/core/src/main/java/org/apache/commons/jci/listeners/ReloadingListener.java
+++ b/core/src/main/java/org/apache/commons/jci/listeners/ReloadingListener.java
@@ -21,7 +21,6 @@
 import java.io.FileInputStream;
 import java.util.Collection;
 import java.util.HashSet;
-import java.util.Iterator;
 import java.util.Set;
 
 import org.apache.commons.io.IOUtils;
@@ -44,7 +43,7 @@
 
     private final Log log = LogFactory.getLog(ReloadingListener.class);
     
-    private final Set notificationListeners = new HashSet();
+    private final Set<ReloadNotificationListener> notificationListeners = new HashSet<ReloadNotificationListener>();
     private final ResourceStore store;
     
     public ReloadingListener() {
@@ -71,15 +70,14 @@
     public boolean isReloadRequired( final FilesystemAlterationObserver pObserver ) {
         boolean reload = false;
 
-        final Collection created = getCreatedFiles();
-        final Collection changed = getChangedFiles();
-        final Collection deleted = getDeletedFiles();
+        final Collection<File> created = getCreatedFiles();
+        final Collection<File> changed = getChangedFiles();
+        final Collection<File> deleted = getDeletedFiles();
         
         log.debug("created:" + created.size() + " changed:" + changed.size() + " deleted:" + deleted.size() + " resources");
 
         if (deleted.size() > 0) {
-            for (Iterator it = deleted.iterator(); it.hasNext();) {
-                final File file = (File) it.next();
+            for (File file : deleted) {
                 final String resourceName = ConversionUtils.getResourceNameFromFileName(ConversionUtils.relative(pObserver.getRootDirectory(), file));
                 store.remove(resourceName);
             }
@@ -87,8 +85,7 @@
         }
 
         if (created.size() > 0) {
-            for (Iterator it = created.iterator(); it.hasNext();) {
-                final File file = (File) it.next();
+            for (File file : created) {
                 FileInputStream is = null;
                 try {
                     is = new FileInputStream(file);
@@ -104,8 +101,7 @@
         }
 
         if (changed.size() > 0) {
-            for (Iterator it = changed.iterator(); it.hasNext();) {
-                final File file = (File) it.next();
+            for (File file : changed) {
                 FileInputStream is = null;
                 try {
                     is = new FileInputStream(file);
@@ -145,10 +141,7 @@
     }
 
     void notifyReloadNotificationListeners() {
-        
-        for (Iterator it = notificationListeners.iterator(); it.hasNext();) {
-            final ReloadNotificationListener listener = (ReloadNotificationListener) it.next();
-
+        for (ReloadNotificationListener listener : notificationListeners) {
             log.debug("notifying listener " + listener);
 
             listener.handleNotification();
diff --git a/core/src/main/java/org/apache/commons/jci/readers/FileResourceReader.java b/core/src/main/java/org/apache/commons/jci/readers/FileResourceReader.java
index c5c86c1..6d48bb4 100644
--- a/core/src/main/java/org/apache/commons/jci/readers/FileResourceReader.java
+++ b/core/src/main/java/org/apache/commons/jci/readers/FileResourceReader.java
@@ -52,7 +52,7 @@
      * @deprecated
      */
     public String[] list() {
-        final List files = new ArrayList();
+        final List<String> files = new ArrayList<String>();
         list(root, files);
         return (String[]) files.toArray(new String[files.size()]);
     }
@@ -60,7 +60,7 @@
     /**
      * @deprecated
      */
-    private void list( final File pFile, final List pFiles ) {
+    private void list( final File pFile, final List<String> pFiles ) {
         if (pFile.isDirectory()) {
             final File[] directoryFiles = pFile.listFiles();
             for (int i = 0; i < directoryFiles.length; i++) {
diff --git a/core/src/main/java/org/apache/commons/jci/readers/MemoryResourceReader.java b/core/src/main/java/org/apache/commons/jci/readers/MemoryResourceReader.java
index 6347b23..26b836b 100644
--- a/core/src/main/java/org/apache/commons/jci/readers/MemoryResourceReader.java
+++ b/core/src/main/java/org/apache/commons/jci/readers/MemoryResourceReader.java
@@ -27,7 +27,7 @@
  */
 public class MemoryResourceReader implements ResourceReader {
     
-    private Map resources = null;
+    private Map<String, byte[]> resources = null;
 
     public boolean isAvailable( final String pResourceName ) {
         if (resources == null) {
@@ -39,7 +39,7 @@
     
     public void add( final String pResourceName, final byte[] pContent ) {
         if (resources == null) {
-            resources = new HashMap();
+            resources = new HashMap<String, byte[]>();
         }
         
         resources.put(pResourceName, pContent);
@@ -53,7 +53,7 @@
     
 
     public byte[] getBytes( final String pResourceName ) {
-        return (byte[]) resources.get(pResourceName);
+        return resources.get(pResourceName);
     }
 
     /**
diff --git a/core/src/main/java/org/apache/commons/jci/stores/FileResourceStore.java b/core/src/main/java/org/apache/commons/jci/stores/FileResourceStore.java
index 133d7ba..89bbe37 100644
--- a/core/src/main/java/org/apache/commons/jci/stores/FileResourceStore.java
+++ b/core/src/main/java/org/apache/commons/jci/stores/FileResourceStore.java
@@ -87,7 +87,7 @@
      * @deprecated
      */
     public String[] list() {
-        final List files = new ArrayList();
+        final List<String> files = new ArrayList<String>();
         list(root, files);
         return (String[]) files.toArray(new String[files.size()]);
     }
@@ -95,7 +95,7 @@
     /**
      * @deprecated
      */
-    private void list(final File pFile, final List pFiles) {
+    private void list(final File pFile, final List<String> pFiles) {
         if (pFile.isDirectory()) {
             final File[] directoryFiles = pFile.listFiles();
             for (int i=0; i < directoryFiles.length; i++) {
diff --git a/core/src/main/java/org/apache/commons/jci/stores/MemoryResourceStore.java b/core/src/main/java/org/apache/commons/jci/stores/MemoryResourceStore.java
index 98d2895..313ee6f 100644
--- a/core/src/main/java/org/apache/commons/jci/stores/MemoryResourceStore.java
+++ b/core/src/main/java/org/apache/commons/jci/stores/MemoryResourceStore.java
@@ -19,7 +19,6 @@
 
 import java.util.ArrayList;
 import java.util.HashMap;
-import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import org.apache.commons.logging.Log;
@@ -35,11 +34,11 @@
 
     private final Log log = LogFactory.getLog(MemoryResourceStore.class);
 
-    private final Map store = new HashMap();
+    private final Map<String, byte[]> store = new HashMap<String, byte[]>();
 
     public byte[] read( final String pResourceName ) {
         log.debug("reading resource " + pResourceName);
-        return (byte[]) store.get(pResourceName);
+        return store.get(pResourceName);
     }
 
     public void write( final String pResourceName, final byte[] pData ) {
@@ -59,10 +58,9 @@
         if (store == null) {
             return new String[0];
         }
-        final List names = new ArrayList();
+        final List<String> names = new ArrayList<String>();
         
-        for (final Iterator it = store.keySet().iterator(); it.hasNext();) {
-            final String name = (String) it.next();
+        for (String name : store.keySet()) {
             names.add(name);
         }
 
diff --git a/core/src/main/java/org/apache/commons/jci/stores/ResourceStoreClassLoader.java b/core/src/main/java/org/apache/commons/jci/stores/ResourceStoreClassLoader.java
index a3ead5f..953ad80 100644
--- a/core/src/main/java/org/apache/commons/jci/stores/ResourceStoreClassLoader.java
+++ b/core/src/main/java/org/apache/commons/jci/stores/ResourceStoreClassLoader.java
@@ -42,8 +42,7 @@
     private Class fastFindClass(final String name) {
         
         if (stores != null) {
-            for (int i = 0; i < stores.length; i++) {
-                final ResourceStore store = stores[i];
+            for (ResourceStore store : stores) {
                 final byte[] clazzBytes = store.read(ConversionUtils.convertClassToResourcePath(name));
                 if (clazzBytes != null) {
                     log.debug(getId() + " found class: " + name  + " (" + clazzBytes.length + " bytes)");
diff --git a/core/src/test/java/org/apache/commons/jci/compilers/AbstractCompilerTestCase.java b/core/src/test/java/org/apache/commons/jci/compilers/AbstractCompilerTestCase.java
index 25d33e3..c68d343 100644
--- a/core/src/test/java/org/apache/commons/jci/compilers/AbstractCompilerTestCase.java
+++ b/core/src/test/java/org/apache/commons/jci/compilers/AbstractCompilerTestCase.java
@@ -49,7 +49,7 @@
         final JavaCompiler compiler = createJavaCompiler();
 
         final ResourceReader reader = new ResourceReader() {
-            final private Map sources = new HashMap() {
+            final private Map<String, byte[]> sources = new HashMap<String, byte[]>() {
                 private static final long serialVersionUID = 1L;
                 {
                     put("jci/Simple.java", (
@@ -62,7 +62,7 @@
                 }};
 
             public byte[] getBytes( final String pResourceName ) {
-                return (byte[]) sources.get(pResourceName);
+                return sources.get(pResourceName);
             }
 
             public boolean isAvailable( final String pResourceName ) {
@@ -89,7 +89,7 @@
         final JavaCompiler compiler = createJavaCompiler();
 
         final ResourceReader reader = new ResourceReader() {
-            final private Map sources = new HashMap() {
+            final private Map<String, byte[]> sources = new HashMap<String, byte[]>() {
                 private static final long serialVersionUID = 1L;
                 {
                     put("jci/Simple.java", (
@@ -109,7 +109,7 @@
                 }};
 
             public byte[] getBytes( final String pResourceName ) {
-                return (byte[]) sources.get(pResourceName);
+                return sources.get(pResourceName);
             }
 
             public boolean isAvailable( final String pResourceName ) {
@@ -141,7 +141,7 @@
         final JavaCompiler compiler = createJavaCompiler();
 
         final ResourceReader reader = new ResourceReader() {
-            final private Map sources = new HashMap() {
+            final private Map<String, byte[]> sources = new HashMap<String, byte[]>() {
                 private static final long serialVersionUID = 1L;
                 {
                     put("jci/Simple.java", (
@@ -157,7 +157,7 @@
                 }};
 
             public byte[] getBytes( final String pResourceName ) {
-                return (byte[]) sources.get(pResourceName);
+                return sources.get(pResourceName);
             }
 
             public boolean isAvailable( final String pResourceName ) {
@@ -189,7 +189,7 @@
         final JavaCompiler compiler = createJavaCompiler();
 
         final ResourceReader reader = new ResourceReader() {
-            final private Map sources = new HashMap() {
+            final private Map<String, byte[]> sources = new HashMap<String, byte[]>() {
                 private static final long serialVersionUID = 1L;
                 {
                     put("Jci/Simple.java", (
@@ -202,7 +202,7 @@
                 }};
 
             public byte[] getBytes( final String pResourceName ) {
-                return (byte[]) sources.get(pResourceName);
+                return sources.get(pResourceName);
             }
 
             public boolean isAvailable( final String pResourceName ) {
@@ -239,7 +239,7 @@
       final JavaCompiler compiler = createJavaCompiler();
 
         final ResourceReader reader = new ResourceReader() {
-            final private Map sources = new HashMap() {
+            final private Map<String, byte[]> sources = new HashMap<String, byte[]>() {
                 private static final long serialVersionUID = 1L;
                 {
                     put("jci/Func1.java", (
@@ -261,7 +261,7 @@
                 }};
 
             public byte[] getBytes( final String pResourceName ) {
-                return (byte[]) sources.get(pResourceName);
+                return sources.get(pResourceName);
             }
 
             public boolean isAvailable( final String pResourceName ) {
@@ -300,7 +300,7 @@
         final JavaCompiler compiler = createJavaCompiler(); 
     
         final ResourceReader reader = new ResourceReader() {
-           final private Map sources = new HashMap() {
+           final private Map<String, byte[]> sources = new HashMap<String, byte[]>() {
                private static final long serialVersionUID = 1L;
                {
                    put("jci/Simple.java", (
@@ -318,7 +318,7 @@
                }};
     
            public byte[] getBytes( final String pResourceName ) {
-               return (byte[]) sources.get(pResourceName);
+               return sources.get(pResourceName);
            }
     
            public boolean isAvailable( final String pResourceName ) {
@@ -348,8 +348,7 @@
     public final String toString( final CompilationProblem[] pProblems ) {
         final StringBuilder sb = new StringBuilder();
 
-        for (int i = 0; i < pProblems.length; i++) {
-            final CompilationProblem problem = pProblems[i];
+        for (CompilationProblem problem : pProblems) {
             sb.append(problem.getMessage()).append(", ");
         }
 
diff --git a/examples/src/main/java/org/apache/commons/jci/examples/commandline/CommandlineCompiler.java b/examples/src/main/java/org/apache/commons/jci/examples/commandline/CommandlineCompiler.java
index 8bae395..9bdeaca 100644
--- a/examples/src/main/java/org/apache/commons/jci/examples/commandline/CommandlineCompiler.java
+++ b/examples/src/main/java/org/apache/commons/jci/examples/commandline/CommandlineCompiler.java
@@ -20,7 +20,6 @@
 import java.io.File;
 import java.net.URL;
 import java.net.URLClassLoader;
-import java.util.Iterator;
 
 import org.apache.commons.cli.CommandLine;
 import org.apache.commons.cli.CommandLineParser;
@@ -115,9 +114,7 @@
         final JavaCompilerSettings settings = compiler.createDefaultSettings();
 
 
-        for (Iterator it = cmd.iterator(); it.hasNext();) {
-            final Option option = (Option) it.next();
-
+        for (Option option : cmd) {
             if ("classpath".equals(option.getOpt())) {
                 final String[] values = option.getValues();
                 final URL[] urls = new URL[values.length];
diff --git a/examples/src/main/java/org/apache/commons/jci/examples/configuration/ConfigurationReloading.java b/examples/src/main/java/org/apache/commons/jci/examples/configuration/ConfigurationReloading.java
index 4e5c861..e197633 100644
--- a/examples/src/main/java/org/apache/commons/jci/examples/configuration/ConfigurationReloading.java
+++ b/examples/src/main/java/org/apache/commons/jci/examples/configuration/ConfigurationReloading.java
@@ -23,7 +23,6 @@
 import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.Iterator;
 import java.util.Properties;
 
 import org.apache.commons.jci.listeners.FileChangeListener;
@@ -45,7 +44,7 @@
 
         System.out.println("Watching " + configFile.getAbsolutePath());
 
-        final Collection configurables = new ArrayList();
+        final Collection<Configurable> configurables = new ArrayList<Configurable>();
 
         final FilesystemAlterationListener listener = new FileChangeListener() {
             public void onStop(FilesystemAlterationObserver pObserver) {
@@ -62,8 +61,7 @@
 
                         System.out.println("Notifying about configuration change " + configFile);
 
-                        for (Iterator it = configurables.iterator(); it.hasNext();) {
-                            final Configurable configurable = (Configurable) it.next();
+                        for (Configurable configurable : configurables) {
                             configurable.configure(props);
                         }
 
diff --git a/examples/src/main/java/org/apache/commons/jci/examples/serverpages/JspReader.java b/examples/src/main/java/org/apache/commons/jci/examples/serverpages/JspReader.java
index 207d923..a2e8caa 100644
--- a/examples/src/main/java/org/apache/commons/jci/examples/serverpages/JspReader.java
+++ b/examples/src/main/java/org/apache/commons/jci/examples/serverpages/JspReader.java
@@ -26,11 +26,11 @@
  */
 public final class JspReader implements ResourceReader {
 
-    private final Map sources;
+    private final Map<String, byte[]> sources;
     private final ResourceReader reader;
 
 
-    public JspReader( final Map pSources, final ResourceReader pReader ) {
+    public JspReader( final Map<String, byte[]> pSources, final ResourceReader pReader ) {
         reader = pReader;
         sources = pSources;
     }
@@ -38,7 +38,7 @@
 
     public byte[] getBytes( String pResourceName ) {
 
-        final byte[] bytes = (byte[]) sources.get(pResourceName);
+        final byte[] bytes = sources.get(pResourceName);
 
         if (bytes != null) {
             return bytes;
diff --git a/examples/src/main/java/org/apache/commons/jci/examples/serverpages/ServerPageServlet.java b/examples/src/main/java/org/apache/commons/jci/examples/serverpages/ServerPageServlet.java
index f465343..8e47611 100644
--- a/examples/src/main/java/org/apache/commons/jci/examples/serverpages/ServerPageServlet.java
+++ b/examples/src/main/java/org/apache/commons/jci/examples/serverpages/ServerPageServlet.java
@@ -20,9 +20,9 @@
 import java.io.File;
 import java.io.IOException;
 import java.io.PrintWriter;
+import java.lang.String;
 import java.util.HashMap;
 import java.util.HashSet;
-import java.util.Iterator;
 import java.util.Map;
 import java.util.Set;
 
@@ -70,23 +70,21 @@
 
         final TransactionalResourceStore store = new TransactionalResourceStore(new MemoryResourceStore()) {
 
-            private Set newClasses;
-            private Map newServletsByClassname;
+            private Set<String> newClasses;
+            private Map<String, HttpServlet> newServletsByClassname;
 
             public void onStart() {
                 super.onStart();
 
-                newClasses = new HashSet();
-                newServletsByClassname = new HashMap(servletsByClassname);
+                newClasses = new HashSet<String>();
+                newServletsByClassname = new HashMap<String, HttpServlet>(servletsByClassname);
             }
 
             public void onStop() {
                 super.onStop();
 
                 boolean reload = false;
-                for (Iterator it = newClasses.iterator(); it.hasNext();) {
-                    final String clazzName = (String) it.next();
-
+                for (String clazzName : newClasses) {
                     try {
                         final Class clazz = classloader.loadClass(clazzName);
 
@@ -127,8 +125,8 @@
         jspListener = new CompilingListener(new JavaCompilerFactory().createCompiler("eclipse"), store) {
 
             private final JspGenerator transformer = new JspGenerator();
-            private final Map sources = new HashMap();
-            private final Set resourceToCompile = new HashSet();
+            private final Map<String, File> sources = new HashMap<String, File>();
+            private final Set<String> resourceToCompile = new HashSet<String>();
 
             public void onStart(FilesystemAlterationObserver pObserver) {
                 super.onStart(pObserver);
diff --git a/fam/src/main/java/org/apache/commons/jci/listeners/AbstractFilesystemAlterationListener.java b/fam/src/main/java/org/apache/commons/jci/listeners/AbstractFilesystemAlterationListener.java
index d76a7f9..1ec9c78 100644
--- a/fam/src/main/java/org/apache/commons/jci/listeners/AbstractFilesystemAlterationListener.java
+++ b/fam/src/main/java/org/apache/commons/jci/listeners/AbstractFilesystemAlterationListener.java
@@ -35,12 +35,12 @@
 
     private final Log log = LogFactory.getLog(AbstractFilesystemAlterationListener.class);
 
-    private final Collection createdFiles = new ArrayList();
-    private final Collection changedFiles = new ArrayList();
-    private final Collection deletedFiles = new ArrayList();
-    private final Collection createdDirectories = new ArrayList();
-    private final Collection changedDirectories = new ArrayList();
-    private final Collection deletedDirectories = new ArrayList();
+    private final Collection<File> createdFiles = new ArrayList<File>();
+    private final Collection<File> changedFiles = new ArrayList<File>();
+    private final Collection<File> deletedFiles = new ArrayList<File>();
+    private final Collection<File> createdDirectories = new ArrayList<File>();
+    private final Collection<File> changedDirectories = new ArrayList<File>();
+    private final Collection<File> deletedDirectories = new ArrayList<File>();
 
     
     private final static class Signal {
@@ -73,11 +73,11 @@
     }
 
 
-    public Collection getChangedDirectories() {
+    public Collection<File> getChangedDirectories() {
         return changedDirectories;
     }
 
-    public Collection getChangedFiles() {
+    public Collection<File> getChangedFiles() {
         return changedFiles;
     }
 
@@ -85,15 +85,15 @@
         return createdDirectories;
     }
 
-    public Collection getCreatedFiles() {
+    public Collection<File> getCreatedFiles() {
         return createdFiles;
     }
 
-    public Collection getDeletedDirectories() {
+    public Collection<File> getDeletedDirectories() {
         return deletedDirectories;
     }
 
-    public Collection getDeletedFiles() {
+    public Collection<File> getDeletedFiles() {
         return deletedFiles;
     }
 
diff --git a/fam/src/main/java/org/apache/commons/jci/monitor/FilesystemAlterationMonitor.java b/fam/src/main/java/org/apache/commons/jci/monitor/FilesystemAlterationMonitor.java
index c10aaf1..88f002f 100644
--- a/fam/src/main/java/org/apache/commons/jci/monitor/FilesystemAlterationMonitor.java
+++ b/fam/src/main/java/org/apache/commons/jci/monitor/FilesystemAlterationMonitor.java
@@ -20,7 +20,6 @@
 import java.io.File;
 import java.util.Collections;
 import java.util.HashMap;
-import java.util.Iterator;
 import java.util.Map;
 
 import org.apache.commons.logging.Log;
@@ -37,7 +36,7 @@
     private final Log log = LogFactory.getLog(FilesystemAlterationMonitor.class);
 
     private final Object observersLock = new Object();
-    private Map observers = Collections.unmodifiableMap(new HashMap());    
+    private Map<File, FilesystemAlterationObserver> observers = Collections.unmodifiableMap(new HashMap<File, FilesystemAlterationObserver>());    
     private long delay = 3000;
     private Thread thread = null;
 
@@ -76,7 +75,7 @@
             observer = (FilesystemAlterationObserver)observers.get(pRoot);
 
             if (observer == null) {
-                final Map newObservers = new HashMap(observers);
+                final Map<File, FilesystemAlterationObserver> newObservers = new HashMap<File, FilesystemAlterationObserver>(observers);
                 observer = new FilesystemAlterationObserverImpl(pRoot);
                 newObservers.put(pRoot, observer);
                 observers = Collections.unmodifiableMap(newObservers);
@@ -88,8 +87,7 @@
    
     public void removeListener( final FilesystemAlterationListener pListener ) {
         synchronized (observersLock) {
-            for (Iterator it = observers.values().iterator(); it.hasNext();) {
-                final FilesystemAlterationObserver observer = (FilesystemAlterationObserver) it.next();
+            for (FilesystemAlterationObserver observer : observers.values()) {
                 observer.removeListener(pListener);
                 // FIXME: remove observer if there are no listeners?
             }
@@ -115,10 +113,7 @@
                 break;
             }
 
-            final Map currentObservers = observers;
-            
-            for (Iterator it = currentObservers.values().iterator(); it.hasNext();) {
-                final FilesystemAlterationObserver observer = (FilesystemAlterationObserver) it.next();
+            for (FilesystemAlterationObserver observer : observers.values()) {
                 observer.checkAndNotify();
             }
 
diff --git a/fam/src/main/java/org/apache/commons/jci/monitor/FilesystemAlterationObserverImpl.java b/fam/src/main/java/org/apache/commons/jci/monitor/FilesystemAlterationObserverImpl.java
index fa7d1ba..5b7a2f3 100644
--- a/fam/src/main/java/org/apache/commons/jci/monitor/FilesystemAlterationObserverImpl.java
+++ b/fam/src/main/java/org/apache/commons/jci/monitor/FilesystemAlterationObserverImpl.java
@@ -20,7 +20,6 @@
 import java.io.File;
 import java.util.HashMap;
 import java.util.HashSet;
-import java.util.Iterator;
 import java.util.Map;
 import java.util.Set;
 
@@ -95,7 +94,7 @@
         private final MonitorFile file;
         private long lastModified = -1;
         private int lastType = TYPE_UNKNOWN;
-        private Map childs = new HashMap();
+        private Map<String, Entry> childs = new HashMap<String, Entry>();
 
         public Entry(final MonitorFile pFile) {
             file = pFile;
@@ -117,9 +116,8 @@
             }
 
             final MonitorFile[] files = file.listFiles();
-            final Set deleted = new HashSet(childs.values());
-            for (int i = 0; i < files.length; i++) {
-                final MonitorFile f = files[i];
+            final Set<Entry> deleted = new HashSet<Entry>(childs.values());
+            for (MonitorFile f : files) {
                 final String name = f.getName();
                 final Entry entry = (Entry)childs.get(name);
                 if (entry != null) {
@@ -140,8 +138,7 @@
 
             // the ones not found on disk anymore
 
-            for (Iterator it = deleted.iterator(); it.hasNext();) {
-                final Entry entry = (Entry) it.next();
+            for (Entry entry : deleted) {
                 entry.deleteChildsAndNotify();
                 childs.remove(entry.getName());
             }
@@ -149,9 +146,7 @@
 
 
         private void deleteChildsAndNotify() {
-            for (Iterator it = childs.values().iterator(); it.hasNext();) {
-                final Entry entry = (Entry) it.next();
-
+            for (Entry entry : childs.values()) {
                 entry.deleteChildsAndNotify();
             }
             childs.clear();
@@ -244,7 +239,7 @@
     private final Entry rootEntry;
 
     private FilesystemAlterationListener[] listeners = new FilesystemAlterationListener[0];
-    private Set listenersSet = new HashSet();
+    private Set<FilesystemAlterationListener> listenersSet = new HashSet<FilesystemAlterationListener>();
 
     public FilesystemAlterationObserverImpl( final File pRootDirectory ) {
         rootDirectory = pRootDirectory;
@@ -255,59 +250,51 @@
 
     private void notifyOnStart() {
         log.debug("onStart " + rootEntry);
-        for (int i = 0; i < listeners.length; i++) {
-            final FilesystemAlterationListener listener = listeners[i];
+        for (FilesystemAlterationListener listener : listeners) {
             listener.onStart(this);
         }
     }
     private void notifyOnStop() {
         log.debug("onStop " + rootEntry);
-        for (int i = 0; i < listeners.length; i++) {
-            final FilesystemAlterationListener listener = listeners[i];
+        for (FilesystemAlterationListener listener : listeners) {
             listener.onStop(this);
         }
     }
 
     private void notifyOnFileCreate( final Entry pEntry ) {
         log.debug("onFileCreate " + pEntry);
-        for (int i = 0; i < listeners.length; i++) {
-            final FilesystemAlterationListener listener = listeners[i];
+        for (FilesystemAlterationListener listener : listeners) {
             listener.onFileCreate(((MonitorFileImpl)pEntry.getFile()).file );
         }
     }
     private void notifyOnFileChange( final Entry pEntry ) {
         log.debug("onFileChange " + pEntry);
-        for (int i = 0; i < listeners.length; i++) {
-            final FilesystemAlterationListener listener = listeners[i];
+        for (FilesystemAlterationListener listener : listeners) {
             listener.onFileChange(((MonitorFileImpl)pEntry.getFile()).file );
         }
     }
     private void notifyOnFileDelete( final Entry pEntry ) {
         log.debug("onFileDelete " + pEntry);
-        for (int i = 0; i < listeners.length; i++) {
-            final FilesystemAlterationListener listener = listeners[i];
+        for (FilesystemAlterationListener listener : listeners) {
             listener.onFileDelete(((MonitorFileImpl)pEntry.getFile()).file );
         }
     }
 
     private void notifyOnDirectoryCreate( final Entry pEntry ) {
         log.debug("onDirectoryCreate " + pEntry);
-        for (int i = 0; i < listeners.length; i++) {
-            final FilesystemAlterationListener listener = listeners[i];
+        for (FilesystemAlterationListener listener : listeners) {
             listener.onDirectoryCreate(((MonitorFileImpl)pEntry.getFile()).file );
         }
     }
     private void notifyOnDirectoryChange( final Entry pEntry ) {
         log.debug("onDirectoryChange " + pEntry);
-        for (int i = 0; i < listeners.length; i++) {
-            final FilesystemAlterationListener listener = listeners[i];
+        for (FilesystemAlterationListener listener : listeners) {
             listener.onDirectoryChange(((MonitorFileImpl)pEntry.getFile()).file );
         }
     }
     private void notifyOnDirectoryDelete( final Entry pEntry ) {
         log.debug("onDirectoryDelete " + pEntry);
-        for (int i = 0; i < listeners.length; i++) {
-            final FilesystemAlterationListener listener = listeners[i];
+        for (FilesystemAlterationListener listener : listeners) {
             listener.onDirectoryDelete(((MonitorFileImpl)pEntry.getFile()).file );
         }
     }
