6990106: FindBugs scan - Malicious code vulnerability Warnings in com.sun.java.util.jar.pack.*

Reviewed-by: mduigou, briangoetz

src/share/classes/com/sun/java/util/jar/pack/AdaptiveCoding.java

 /*
- * Copyright (c) 2003, 2005, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -29,13 +29,14 @@ import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
+import static com.sun.java.util.jar.pack.Constants.*;
 
 /**
  * Adaptive coding.
  * See the section "Adaptive Encodings" in the Pack200 spec.
  * @author John Rose
  */
-class AdaptiveCoding implements Constants, CodingMethod {
+class AdaptiveCoding implements CodingMethod {
     CodingMethod headCoding;
     int          headLength;
     CodingMethod tailCoding;
@@ -147,7 +148,6 @@ class AdaptiveCoding implements Constants, CodingMethod {
         }
         if (KX == KX_MAX)  return Integer.MAX_VALUE;
         KX += 1;
-        int unit2 = 1      << (KX * KX_LG2BASE);
         int mask2 = KB_MAX << (KX * KX_LG2BASE);
         K1 |= (mask & ~mask2);
         K1 += unit;
@@ -250,7 +250,7 @@ class AdaptiveCoding implements Constants, CodingMethod {
         return m.toString();
     }
     public String toString() {
-        StringBuffer res = new StringBuffer(20);
+        StringBuilder res = new StringBuilder(20);
         AdaptiveCoding run = this;
         res.append("run(");
         for (;;) {

src/share/classes/com/sun/java/util/jar/pack/Attribute.java

@@ -36,6 +36,7 @@ import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import static com.sun.java.util.jar.pack.Constants.*;
 
 /**
  * Represents an attribute in a class-file.
@@ -44,7 +45,7 @@ import java.util.Map;
  * attribute layouts.
  * @author John Rose
  */
-class Attribute implements Comparable, Constants {
+class Attribute implements Comparable {
     // Attribute instance fields.
 
     Layout def;     // the name and format of this attr
@@ -103,7 +104,6 @@ class Attribute implements Comparable, Constants {
         return this.def.compareTo(that.def);
     }
 
-    private static final byte[] noBytes = {};
     private static final Map<List<Attribute>, List<Attribute>> canonLists = new HashMap<>();
     private static final Map<Layout, Attribute> attributes = new HashMap<>();
     private static final Map<Layout, Attribute> standardDefs = new HashMap<>();
@@ -112,7 +112,7 @@ class Attribute implements Comparable, Constants {
     // are used by trimToSize, in order to reduce footprint
     // of some common cases.  (Note that Code attributes are
     // always zero size.)
-    public static List getCanonList(List<Attribute> al) {
+    public static List<Attribute> getCanonList(List<Attribute> al) {
         synchronized (canonLists) {
             List<Attribute> cl = canonLists.get(al);
             if (cl == null) {
@@ -465,7 +465,9 @@ class Attribute implements Comparable, Constants {
             return ConstantPool.getUtf8Entry(name());
         }
 
-        public boolean isEmpty() { return layout == ""; }
+        public boolean isEmpty() {
+            return layout.isEmpty();
+        }
 
         public Layout(int ctype, String name, String layout) {
             this.ctype = ctype;
@@ -479,19 +481,19 @@ class Attribute implements Comparable, Constants {
                 } else {
                     String[] bodies = splitBodies(layout);
                     // Make the callables now, so they can be linked immediately.
-                    Element[] elems = new Element[bodies.length];
-                    this.elems = elems;
-                    for (int i = 0; i < elems.length; i++) {
+                    Element[] lelems = new Element[bodies.length];
+                    this.elems = lelems;
+                    for (int i = 0; i < lelems.length; i++) {
                         Element ce = this.new Element();
                         ce.kind = EK_CBLE;
                         ce.removeBand();
                         ce.bandIndex = NO_BAND_INDEX;
                         ce.layout = bodies[i];
-                        elems[i] = ce;
+                        lelems[i] = ce;
                     }
                     // Next fill them in.
-                    for (int i = 0; i < elems.length; i++) {
-                        Element ce = elems[i];
+                    for (int i = 0; i < lelems.length; i++) {
+                        Element ce = lelems[i];
                         ce.body = tokenizeLayout(this, i, bodies[i]);
                     }
                     //System.out.println(Arrays.asList(elems));
@@ -525,11 +527,12 @@ class Attribute implements Comparable, Constants {
         }
 
         public boolean equals(Object x) {
-            return x instanceof Layout && equals((Layout)x);
+            return ( x != null) && ( x.getClass() == Layout.class ) &&
+                    equals((Layout)x);
         }
         public boolean equals(Layout that) {
-            return this.name == that.name
-                && this.layout == that.layout
+            return this.name.equals(that.name)
+                && this.layout.equals(that.layout)
                 && this.ctype == that.ctype;
         }
         public int hashCode() {
@@ -589,14 +592,14 @@ class Attribute implements Comparable, Constants {
                 return str;
             }
             private String stringForDebug() {
-                Element[] body = this.body;
+                Element[] lbody = this.body;
                 switch (kind) {
                 case EK_CALL:
-                    body = null;
+                    lbody = null;
                     break;
                 case EK_CASE:
                     if (flagTest(EF_BACK))
-                        body = null;
+                        lbody = null;
                     break;
                 }
                 return layout
@@ -604,7 +607,7 @@ class Attribute implements Comparable, Constants {
                     + "<"+ (flags==0?"":""+flags)+kind+len
                     + (refKind==0?"":""+refKind) + ">"
                     + (value==0?"":"("+value+")")
-                    + (body==null?"": ""+Arrays.asList(body));
+                    + (lbody==null?"": ""+Arrays.asList(lbody));
             }
         }
 
@@ -613,16 +616,19 @@ class Attribute implements Comparable, Constants {
         }
         static private final Element[] noElems = {};
         public Element[] getCallables() {
-            if (hasCallables())
-                return elems;
-            else
+            if (hasCallables()) {
+                Element[] nelems = Arrays.copyOf(elems, elems.length);
+                return nelems;
+            } else
                 return noElems;  // no callables at all
         }
         public Element[] getEntryPoint() {
             if (hasCallables())
                 return elems[0].body;  // body of first callable
-            else
-                return elems;  // no callables; whole body
+            else {
+                Element[] nelems = Arrays.copyOf(elems, elems.length);
+                return nelems;  // no callables; whole body
+            }
         }
 
         /** Return a sequence of tokens from the given attribute bytes.
@@ -674,7 +680,7 @@ class Attribute implements Comparable, Constants {
         }
     }
 
-    void visitRefs(Holder holder, int mode, final Collection refs) {
+    void visitRefs(Holder holder, int mode, final Collection<Entry> refs) {
         if (mode == VRM_CLASSIC) {
             refs.add(getNameRef());
         }
@@ -720,7 +726,7 @@ class Attribute implements Comparable, Constants {
      */
     static public
     String normalizeLayoutString(String layout) {
-        StringBuffer buf = new StringBuffer();
+        StringBuilder buf = new StringBuilder();
         for (int i = 0, len = layout.length(); i < len; ) {
             char ch = layout.charAt(i++);
             if (ch <= ' ') {
@@ -832,14 +838,14 @@ class Attribute implements Comparable, Constants {
     */
     static //private
     Layout.Element[] tokenizeLayout(Layout self, int curCble, String layout) {
-        ArrayList<Layout.Element> col = new ArrayList<>(layout.length());
+        List<Layout.Element> col = new ArrayList<>(layout.length());
         tokenizeLayout(self, curCble, layout, col);
         Layout.Element[] res = new Layout.Element[col.size()];
         col.toArray(res);
         return res;
     }
     static //private
-    void tokenizeLayout(Layout self, int curCble, String layout, ArrayList<Layout.Element> col) {
+    void tokenizeLayout(Layout self, int curCble, String layout, List<Layout.Element> col) {
         boolean prevBCI = false;
         for (int len = layout.length(), i = 0; i < len; ) {
             int start = i;
@@ -897,7 +903,7 @@ class Attribute implements Comparable, Constants {
             case 'T': // union: 'T' any_int union_case* '(' ')' '[' body ']'
                 kind = EK_UN;
                 i = tokenizeSInt(e, layout, i);
-                ArrayList<Layout.Element> cases = new ArrayList<>();
+                List<Layout.Element> cases = new ArrayList<>();
                 for (;;) {
                     // Keep parsing cases until we hit the default case.
                     if (layout.charAt(i++) != '(')
@@ -1051,7 +1057,7 @@ class Attribute implements Comparable, Constants {
     }
     static //private
     String[] splitBodies(String layout) {
-        ArrayList<String> bodies = new ArrayList<>();
+        List<String> bodies = new ArrayList<>();
         // Parse several independent layout bodies:  "[foo][bar]...[baz]"
         for (int i = 0; i < layout.length(); i++) {
             if (layout.charAt(i++) != '[')
@@ -1156,7 +1162,7 @@ class Attribute implements Comparable, Constants {
     String expandCaseDashNotation(String layout) {
         int dash = findCaseDash(layout, 0);
         if (dash < 0)  return layout;  // no dashes (the common case)
-        StringBuffer result = new StringBuffer(layout.length() * 3);
+        StringBuilder result = new StringBuilder(layout.length() * 3);
         int sofar = 0;  // how far have we processed the layout?
         for (;;) {
             // for each dash, collect everything up to the dash

src/share/classes/com/sun/java/util/jar/pack/BandStructure.java

 /*
- * Copyright (c) 2001, 2005, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -44,16 +44,17 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
-import java.util.Iterator;
 import java.util.List;
+import java.util.Map;
 import java.util.jar.Pack200;
+import static com.sun.java.util.jar.pack.Constants.*;
 
 /**
  * Define the structure and ordering of "bands" in a packed file.
  * @author John Rose
  */
 abstract
-class BandStructure implements Constants {
+class BandStructure {
     static final int MAX_EFFORT = 9;
     static final int MIN_EFFORT = 1;
     static final int DEFAULT_EFFORT = 5;
@@ -251,18 +252,18 @@ class BandStructure implements Constants {
 
         null
     };
-    final private static HashMap basicCodingIndexes;
+    final private static Map<Coding, Integer> basicCodingIndexes;
     static {
         assert(basicCodings[_meta_default] == null);
         assert(basicCodings[_meta_canon_min] != null);
         assert(basicCodings[_meta_canon_max] != null);
-        HashMap map = new HashMap();
+        Map<Coding, Integer> map = new HashMap<>();
         for (int i = 0; i < basicCodings.length; i++) {
             Coding c = basicCodings[i];
             if (c == null)  continue;
             assert(i >= _meta_canon_min);
             assert(i <= _meta_canon_max);
-            map.put(c, new Integer(i));
+            map.put(c, i);
         }
         basicCodingIndexes = map;
     }
@@ -270,12 +271,12 @@ class BandStructure implements Constants {
         return i < basicCodings.length ? basicCodings[i] : null;
     }
     public static int indexOf(Coding c) {
-        Integer i = (Integer) basicCodingIndexes.get(c);
+        Integer i = basicCodingIndexes.get(c);
         if (i == null)  return 0;
         return i.intValue();
     }
     public static Coding[] getBasicCodings() {
-        return (Coding[]) basicCodings.clone();
+        return basicCodings.clone();
     }
 
     protected byte[] bandHeaderBytes;    // used for input only
@@ -687,7 +688,6 @@ class BandStructure implements Constants {
             }
             bandCoding.writeArrayTo(out, values, 0, length);
             if (out == outputCounter) {
-                long len1 = outputCounter.getCount();
                 assert(outputSize == outputCounter.getCount() - len0)
                     : (outputSize+" != "+outputCounter.getCount()+"-"+len0);
             }
@@ -1050,8 +1050,8 @@ class BandStructure implements Constants {
 
     // Bootstrap support for CPRefBands.  These are needed to record
     // intended CP indexes, before the CP has been created.
-    private ArrayList allKQBands = new ArrayList();
-    private ArrayList needPredefIndex = new ArrayList();
+    private final List<CPRefBand> allKQBands = new ArrayList<>();
+    private List<Object[]> needPredefIndex = new ArrayList<>();
 
 
     int encodeRef(Entry e, Index ix) {
@@ -1078,9 +1078,9 @@ class BandStructure implements Constants {
                 && this instanceof PackageWriter) {
                 // Twist the random state based on my first file.
                 // This sends each segment off in a different direction.
-                List classes = ((PackageWriter)this).pkg.classes;
+                List<Package.Class> classes = ((PackageWriter)this).pkg.classes;
                 if (!classes.isEmpty()) {
-                    Package.Class cls = (Package.Class) classes.get(0);
+                    Package.Class cls = classes.get(0);
                     codingChooser.addStressSeed(cls.getName().hashCode());
                 }
             }
@@ -1619,8 +1619,7 @@ class BandStructure implements Constants {
     /** Given CP indexes, distribute tag-specific indexes to bands. */
     protected void setBandIndexes() {
         // Handle prior calls to setBandIndex:
-        for (Iterator i = needPredefIndex.iterator(); i.hasNext(); ) {
-            Object[] need = (Object[]) i.next();
+        for (Object[] need : needPredefIndex) {
             CPRefBand b     = (CPRefBand) need[0];
             Byte      which = (Byte)      need[1];
             b.setIndex(getCPIndex(which.byteValue()));
@@ -1633,7 +1632,7 @@ class BandStructure implements Constants {
     }
 
     protected void setBandIndex(CPRefBand b, byte which) {
-        Object[] need = { b, new Byte(which) };
+        Object[] need = { b, Byte.valueOf(which) };
         if (which == CONSTANT_Literal) {
             // I.e., attribute layouts KQ (no null) or KQN (null ok).
             allKQBands.add(b);
@@ -1645,7 +1644,7 @@ class BandStructure implements Constants {
         }
     }
 
-    protected void setConstantValueIndex(com.sun.java.util.jar.pack.Package.Class.Field f) {
+    protected void setConstantValueIndex(Field f) {
         Index ix = null;
         if (f != null) {
             byte tag = f.getLiteralTag();
@@ -1655,8 +1654,7 @@ class BandStructure implements Constants {
             assert(ix != null);
         }
         // Typically, allKQBands is the singleton of field_ConstantValue_KQ.
-        for (Iterator i = allKQBands.iterator(); i.hasNext(); ) {
-            CPRefBand xxx_KQ = (CPRefBand) i.next();
+        for (CPRefBand xxx_KQ : allKQBands) {
             xxx_KQ.setIndex(ix);
         }
     }
@@ -1688,7 +1686,7 @@ class BandStructure implements Constants {
     protected int attrClassFileVersionMask;
 
     // Mapping from Attribute.Layout to Band[] (layout element bands).
-    protected HashMap attrBandTable = new HashMap();
+    protected Map<Attribute.Layout, Band[]> attrBandTable = new HashMap<>();
 
     // Well-known attributes:
     protected final Attribute.Layout attrCodeEmpty;
@@ -1697,15 +1695,18 @@ class BandStructure implements Constants {
     protected final Attribute.Layout attrConstantValue;
 
     // Mapping from Attribute.Layout to Integer (inverse of attrDefs)
-    HashMap attrIndexTable = new HashMap();
+    Map<Attribute.Layout, Integer> attrIndexTable = new HashMap<>();
 
     // Mapping from attribute index (<32 are flag bits) to attributes.
-    protected ArrayList[] attrDefs = new ArrayList[ATTR_CONTEXT_LIMIT];
+    protected List<List<Attribute.Layout>> attrDefs =
+            new FixedList<>(ATTR_CONTEXT_LIMIT);
     {
         for (int i = 0; i < ATTR_CONTEXT_LIMIT; i++) {
             assert(attrIndexLimit[i] == 0);
             attrIndexLimit[i] = 32;  // just for the sake of predefs.
-            attrDefs[i] = new ArrayList(Collections.nCopies(attrIndexLimit[i], null));
+            attrDefs.set(i, new ArrayList<Attribute.Layout>(Collections.nCopies(
+                    attrIndexLimit[i], (Attribute.Layout)null)));
+
         }
 
         // Add predefined attribute definitions:
@@ -1867,9 +1868,10 @@ class BandStructure implements Constants {
         for (int i = 0; i < ATTR_CONTEXT_LIMIT; i++) {
             assert(attrIndexLimit[i] == 0);  // decide on it now!
             attrIndexLimit[i] = (haveFlagsHi(i)? 63: 32);
-            assert(attrDefs[i].size() == 32);  // all predef indexes are <32
-            int addMore = attrIndexLimit[i] - attrDefs[i].size();
-            attrDefs[i].addAll(Collections.nCopies(addMore, null));
+            List<Attribute.Layout> defList = attrDefs.get(i);
+            assert(defList.size() == 32);  // all predef indexes are <32
+            int addMore = attrIndexLimit[i] - defList.size();
+            defList.addAll(Collections.nCopies(addMore, (Attribute.Layout) null));
         }
     }
 
@@ -1890,13 +1892,13 @@ class BandStructure implements Constants {
         return testBit(archiveOptions, mask);
     }
 
-    protected ArrayList getPredefinedAttrs(int ctype) {
+    protected List getPredefinedAttrs(int ctype) {
         assert(attrIndexLimit[ctype] != 0);
-        ArrayList res = new ArrayList(attrIndexLimit[ctype]);
+        List<Attribute.Layout> res = new ArrayList<>(attrIndexLimit[ctype]);
         // Remove nulls and non-predefs.
         for (int ai = 0; ai < attrIndexLimit[ctype]; ai++) {
             if (testBit(attrDefSeen[ctype], 1L<<ai))  continue;
-            Attribute.Layout def = (Attribute.Layout) attrDefs[ctype].get(ai);
+            Attribute.Layout def = attrDefs.get(ctype).get(ai);
             if (def == null)  continue;  // unused flag bit
             assert(isPredefinedAttr(ctype, ai));
             res.add(def);
@@ -1910,7 +1912,7 @@ class BandStructure implements Constants {
         if (ai >= attrIndexLimit[ctype])          return false;
         // If the bit is set, it was explicitly def'd.
         if (testBit(attrDefSeen[ctype], 1L<<ai))  return false;
-        return (attrDefs[ctype].get(ai) != null);
+        return (attrDefs.get(ctype).get(ai) != null);
     }
 
     protected void adjustSpecialAttrMasks() {
@@ -2050,8 +2052,8 @@ class BandStructure implements Constants {
             System.out.println("Removing predefined "+ATTR_CONTEXT_NAME[ctype]+
                                " attribute on bit "+index);
         }
-        List defList = attrDefs[ctype];
-        Attribute.Layout def = (Attribute.Layout) defList.get(index);
+        List<Attribute.Layout> defList = attrDefs.get(ctype);
+        Attribute.Layout def = defList.get(index);
         assert(def != null);
         defList.set(index, null);
         attrIndexTable.put(def, null);
@@ -2059,7 +2061,7 @@ class BandStructure implements Constants {
         assert(index < 64);
         attrDefSeen[ctype]  &= ~(1L<<index);
         attrFlagMask[ctype] &= ~(1L<<index);
-        Band[] ab = (Band[]) attrBandTable.get(def);
+        Band[] ab = attrBandTable.get(def);
         for (int j = 0; j < ab.length; j++) {
             ab[j].doneWithUnusedBand();
         }
@@ -2085,9 +2087,8 @@ class BandStructure implements Constants {
             long defSeen = attrDefSeen[ctype];
             // Note: attrDefSeen is always a subset of attrFlagMask.
             assert((defSeen & ~attrFlagMask[ctype]) == 0);
-            for (int i = 0; i < attrDefs[ctype].size(); i++) {
-                Attribute.Layout def = (Attribute.Layout)
-                    attrDefs[ctype].get(i);
+            for (int i = 0; i < attrDefs.get(ctype).size(); i++) {
+                Attribute.Layout def = attrDefs.get(ctype).get(i);
                 if (def == null)  continue;  // unused flag bit
                 if (def.bandCount == 0)  continue;  // empty attr
                 if (i < attrIndexLimit[ctype] && !testBit(defSeen, 1L<<i)) {
@@ -2102,7 +2103,7 @@ class BandStructure implements Constants {
                 Band[] newAB  = makeNewAttributeBands(pfx, def,
                                                       xxx_attr_bands);
                 assert(newAB.length == def.bandCount);
-                Band[] prevAB = (Band[]) attrBandTable.put(def, newAB);
+                Band[] prevAB = attrBandTable.put(def, newAB);
                 if (prevAB != null) {
                     // We won't be using these predefined bands.
                     for (int j = 0; j < prevAB.length; j++) {
@@ -2212,14 +2213,14 @@ class BandStructure implements Constants {
     protected int setAttributeLayoutIndex(Attribute.Layout def, int index) {
         int ctype = def.ctype;
         assert(ATTR_INDEX_OVERFLOW <= index && index < attrIndexLimit[ctype]);
-        List defList = attrDefs[ctype];
+        List<Attribute.Layout> defList = attrDefs.get(ctype);
         if (index == ATTR_INDEX_OVERFLOW) {
             // Overflow attribute.
             index = defList.size();
             defList.add(def);
             if (verbose > 0)
                 Utils.log.info("Adding new attribute at "+def +": "+index);
-            attrIndexTable.put(def, new Integer(index));
+            attrIndexTable.put(def, index);
             return index;
         }
 
@@ -2240,7 +2241,7 @@ class BandStructure implements Constants {
         // Remove index binding of any previous fixed attr.
         attrIndexTable.put(defList.get(index), null);
         defList.set(index, def);
-        attrIndexTable.put(def, new Integer(index));
+        attrIndexTable.put(def, index);
         return index;
     }
 
@@ -2361,7 +2362,7 @@ class BandStructure implements Constants {
     ////////////////////////////////////////////////////////////////////
 
     static int nextSeqForDebug;
-    static File dumpDir;
+    static File dumpDir = null;
     static OutputStream getDumpStream(Band b, String ext) throws IOException {
         return getDumpStream(b.name, b.seqForDebug, ext, b);
     }
@@ -2512,19 +2513,19 @@ class BandStructure implements Constants {
                            +", "+cstr+", "+ixS+"),");
     }
 
-    private HashMap prevForAssertMap;
+    private Map<Band, Band> prevForAssertMap;
 
     // DEBUG ONLY:  Record something about the band order.
     boolean notePrevForAssert(Band b, Band p) {
         if (prevForAssertMap == null)
-            prevForAssertMap = new HashMap();
+            prevForAssertMap = new HashMap<>();
         prevForAssertMap.put(b, p);
         return true;
     }
 
     // DEBUG ONLY:  Validate next input band.
     private boolean assertReadyToReadFrom(Band b, InputStream in) throws IOException {
-        Band p = (Band) prevForAssertMap.get(b);
+        Band p = prevForAssertMap.get(b);
         // Any previous band must be done reading before this one starts.
         if (p != null && phaseCmp(p.phase(), DISBURSE_PHASE) < 0) {
             Utils.log.warning("Previous band not done reading.");
@@ -2536,19 +2537,21 @@ class BandStructure implements Constants {
         String name = b.name;
         if (optDebugBands && !name.startsWith("(")) {
             // Verify synchronization between reader & writer:
-            StringBuffer buf = new StringBuffer();
+            StringBuilder buf = new StringBuilder();
             int ch;
             while ((ch = in.read()) > 0)
                 buf.append((char)ch);
             String inName = buf.toString();
             if (!inName.equals(name)) {
-                StringBuffer sb = new StringBuffer();
+                StringBuilder sb = new StringBuilder();
                 sb.append("Expected "+name+" but read: ");
                 inName += (char)ch;
-                while (inName.length() < 10)
-                    inName += (char)in.read();
-                for (int i = 0; i < inName.length(); i++)
+                while (inName.length() < 10) {
+                    inName += (char) in.read();
+                }
+                for (int i = 0; i < inName.length(); i++) {
                     sb.append(inName.charAt(i));
+                }
                 Utils.log.warning(sb.toString());
                 return false;
             }
@@ -2573,7 +2576,7 @@ class BandStructure implements Constants {
 
     // DEBUG ONLY:  Maybe write a debugging cookie to next output band.
     private boolean assertReadyToWriteTo(Band b, OutputStream out) throws IOException {
-        Band p = (Band) prevForAssertMap.get(b);
+        Band p = prevForAssertMap.get(b);
         // Any previous band must be done writing before this one starts.
         if (p != null && phaseCmp(p.phase(), DONE_PHASE) < 0) {
             Utils.log.warning("Previous band not done writing.");
@@ -2654,7 +2657,7 @@ class BandStructure implements Constants {
     protected static Object[] realloc(Object[] a) {
         return realloc(a, Math.max(10, a.length*2));
     }
-    static private int[] noInts = {};
+
     protected static int[] realloc(int[] a, int len) {
         if (len == 0)  return noInts;
         if (a == null)  return new int[len];
@@ -2665,7 +2668,7 @@ class BandStructure implements Constants {
     protected static int[] realloc(int[] a) {
         return realloc(a, Math.max(10, a.length*2));
     }
-    static private byte[] noBytes = {};
+
     protected static byte[] realloc(byte[] a, int len) {
         if (len == 0)  return noBytes;
         if (a == null)  return new byte[len];

src/share/classes/com/sun/java/util/jar/pack/ClassReader.java

@@ -38,19 +38,20 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.Map;
+import static com.sun.java.util.jar.pack.Constants.*;
 
 /**
  * Reader for a class file that is being incorporated into a package.
  * @author John Rose
  */
-class ClassReader implements Constants {
+class ClassReader {
     int verbose;
 
     Package pkg;
     Class cls;
     long inPos;
     DataInputStream in;
-    Map attrDefs;
+    Map<Attribute.Layout, Attribute> attrDefs;
     Map attrCommands;
     String unknownAttrCommand = "error";;
 
@@ -77,7 +78,7 @@ class ClassReader implements Constants {
         });
     }
 
-    public void setAttrDefs(Map attrDefs) {
+    public void setAttrDefs(Map<Attribute.Layout, Attribute> attrDefs) {
         this.attrDefs = attrDefs;
     }
 
@@ -211,27 +212,23 @@ class ClassReader implements Constants {
                     break;
                 case CONSTANT_Integer:
                     {
-                        Comparable val = new Integer(in.readInt());
-                        cpMap[i] = ConstantPool.getLiteralEntry(val);
+                        cpMap[i] = ConstantPool.getLiteralEntry(in.readInt());
                     }
                     break;
                 case CONSTANT_Float:
                     {
-                        Comparable val = new Float(in.readFloat());
-                        cpMap[i] = ConstantPool.getLiteralEntry(val);
+                        cpMap[i] = ConstantPool.getLiteralEntry(in.readFloat());
                     }
                     break;
                 case CONSTANT_Long:
                     {
-                        Comparable val = new Long(in.readLong());
-                        cpMap[i] = ConstantPool.getLiteralEntry(val);
+                        cpMap[i] = ConstantPool.getLiteralEntry(in.readLong());
                         cpMap[++i] = null;
                     }
                     break;
                 case CONSTANT_Double:
                     {
-                        Comparable val = new Double(in.readDouble());
-                        cpMap[i] = ConstantPool.getLiteralEntry(val);
+                        cpMap[i] = ConstantPool.getLiteralEntry(in.readDouble());
                         cpMap[++i] = null;
                     }
                     break;
@@ -353,16 +350,15 @@ class ClassReader implements Constants {
             if (attrCommands != null) {
                 Object lkey = Attribute.keyForLookup(ctype, name);
                 String cmd = (String) attrCommands.get(lkey);
-                if (cmd == "pass") {
-                    String message = "passing attribute bitwise in "+h;
-                    throw new Attribute.FormatException(message, ctype, name,
-                                                        cmd);
-                } else if (cmd == "error") {
-                    String message = "attribute not allowed in "+h;
-                    throw new Attribute.FormatException(message, ctype, name,
-                                                        cmd);
-                } else if (cmd == "strip") {
-                    skip(length, name+" attribute in "+h);
+                switch (cmd) {
+                    case "pass":
+                        String message1 = "passing attribute bitwise in " + h;
+                        throw new Attribute.FormatException(message1, ctype, name, cmd);
+                    case "error":
+                        String message2 = "attribute not allowed in " + h;
+                        throw new Attribute.FormatException(message2, ctype, name, cmd);
+                    case "strip":
+                        skip(length, name + " attribute in " + h);
                         continue;
                 }
             }
@@ -408,7 +404,7 @@ class ClassReader implements Constants {
                     String message = "unsupported StackMap variant in "+h;
                     throw new Attribute.FormatException(message, ctype, name,
                                                         "pass");
-                } else if (unknownAttrCommand == "strip") {
+                } else if ("strip".equals(unknownAttrCommand)) {
                     // Skip the unknown attribute.
                     skip(length, "unknown "+name+" attribute in "+h);
                     continue;
@@ -422,7 +418,7 @@ class ClassReader implements Constants {
                 a.layout() == Package.attrInnerClassesEmpty) {
                 // These are hardwired.
                 long pos0 = inPos;
-                if (a.name() == "Code") {
+                if ("Code".equals(a.name())) {
                     Class.Method m = (Class.Method) h;
                     m.code = new Code(m);
                     try {
@@ -471,7 +467,7 @@ class ClassReader implements Constants {
 
     void readInnerClasses(Class cls) throws IOException {
         int nc = readUnsignedShort();
-        ArrayList ics = new ArrayList(nc);
+        ArrayList<InnerClass> ics = new ArrayList<>(nc);
         for (int i = 0; i < nc; i++) {
             InnerClass ic =
                 new InnerClass(readClassRef(),

src/share/classes/com/sun/java/util/jar/pack/ClassWriter.java

 /*
- * Copyright (c) 2001, 2003, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -38,12 +38,12 @@ import java.io.IOException;
 import java.io.OutputStream;
 import java.util.Iterator;
 import java.util.List;
-
+import static com.sun.java.util.jar.pack.Constants.*;
 /**
  * Writer for a class file that is incorporated into a package.
  * @author John Rose
  */
-class ClassWriter implements Constants {
+class ClassWriter {
     int verbose;
 
     Package pkg;
@@ -196,8 +196,7 @@ class ClassWriter implements Constants {
             return;
         }
         writeShort(h.attributes.size());
-        for (Iterator i = h.attributes.iterator(); i.hasNext(); ) {
-            Attribute a = (Attribute) i.next();
+        for (Attribute a : h.attributes) {
             a.finishRefs(cpIndex);
             writeRef(a.getNameRef());
             if (a.layout() == Package.attrCodeEmpty ||
@@ -207,7 +206,7 @@ class ClassWriter implements Constants {
                 assert(out != bufOut);
                 buf.reset();
                 out = bufOut;
-                if (a.name() == "Code") {
+                if ("Code".equals(a.name())) {
                     Class.Method m = (Class.Method) h;
                     writeCode(m.code);
                 } else {
@@ -246,10 +245,9 @@ class ClassWriter implements Constants {
     }
 
     void writeInnerClasses(Class cls) throws IOException {
-        List ics = cls.getInnerClasses();
+        List<InnerClass> ics = cls.getInnerClasses();
         writeShort(ics.size());
-        for (Iterator i = ics.iterator(); i.hasNext(); ) {
-            InnerClass ic = (InnerClass) i.next();
+        for (InnerClass ic : ics) {
             writeRef(ic.thisClass);
             writeRef(ic.outerClass);
             writeRef(ic.name);

src/share/classes/com/sun/java/util/jar/pack/Code.java

 /*
- * Copyright (c) 2001, 2003, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -29,12 +29,13 @@ import com.sun.java.util.jar.pack.Package.Class;
 import java.lang.reflect.Modifier;
 import java.util.Arrays;
 import java.util.Collection;
+import static com.sun.java.util.jar.pack.Constants.*;
 
 /**
  * Represents a chunk of bytecodes.
  * @author John Rose
  */
-class Code extends Attribute.Holder implements Constants {
+class Code extends Attribute.Holder {
     Class.Method m;
 
     public Code(Class.Method m) {
@@ -141,15 +142,12 @@ class Code extends Attribute.Holder implements Constants {
         super.trimToSize();
     }
 
-    protected void visitRefs(int mode, Collection refs) {
+    protected void visitRefs(int mode, Collection<ConstantPool.Entry> refs) {
         int verbose = getPackage().verbose;
         if (verbose > 2)
             System.out.println("Reference scan "+this);
         Class cls = thisClass();
-        Package pkg = cls.getPackage();
-        for (int i = 0; i < handler_class.length; i++) {
-            refs.add(handler_class[i]);
-        }
+        refs.addAll(Arrays.asList(handler_class));
         if (fixups != null) {
             fixups.visitRefs(refs);
         } else {
@@ -196,11 +194,8 @@ class Code extends Attribute.Holder implements Constants {
             map[mapLen] = (short)(PClimit + Short.MIN_VALUE);
             return map;
         } else {
-            int[] map = new int[mapLen+1];
-            for (int i = 0; i < mapLen; i++) {
-                map[i] = (int) insnMap[i];
-            }
-            map[mapLen] = (int) PClimit;
+            int[] map = Arrays.copyOf(insnMap, mapLen + 1);
+            map[mapLen] = PClimit;
             return map;
         }
     }
@@ -220,10 +215,7 @@ class Code extends Attribute.Holder implements Constants {
             }
         } else {
             int[] map = (int[]) map0;
-            imap = new int[map.length-1];
-            for (int i = 0; i < imap.length; i++) {
-                imap[i] = map[i];
-            }
+            imap = Arrays.copyOfRange(map, 0, map.length - 1);
         }
         return imap;
     }
@@ -266,7 +258,7 @@ class Code extends Attribute.Holder implements Constants {
         } else {
             int[] map = (int[]) map0;
             len = map.length;
-            i = Arrays.binarySearch(map, (int)bci);
+            i = Arrays.binarySearch(map, bci);
         }
         assert(i != -1);
         assert(i != 0);
@@ -322,7 +314,7 @@ class Code extends Attribute.Holder implements Constants {
             len = map.length;
             if (bciCode < len)
                 return map[bciCode];
-            i = Arrays.binarySearch(map, (int)bciCode);
+            i = Arrays.binarySearch(map, bciCode);
             if (i < 0)  i = -i-1;
             int key = bciCode-len;
             for (;; i--) {

src/share/classes/com/sun/java/util/jar/pack/Coding.java

 /*
- * Copyright (c) 2001, 2005, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -29,14 +29,15 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.util.HashMap;
-
+import java.util.Map;
+import static com.sun.java.util.jar.pack.Constants.*;
 /**
  * Define the conversions between sequences of small integers and raw bytes.
  * This is a schema of encodings which incorporates varying lengths,
  * varying degrees of length variability, and varying amounts of signed-ness.
  * @author John Rose
  */
-class Coding implements Constants, Comparable, CodingMethod, Histogram.BitMetric {
+class Coding implements Comparable, CodingMethod, Histogram.BitMetric {
     /*
       Coding schema for single integers, parameterized by (B,H,S):
 
@@ -191,7 +192,9 @@ class Coding implements Constants, Comparable, CodingMethod, Histogram.BitMetric
         if (S == 0 || range >= (long)1<<32)
             return saturate32(range-1);
         long maxPos = range-1;
-        while (isNegativeCode(maxPos, S))  --maxPos;
+        while (isNegativeCode(maxPos, S)) {
+            --maxPos;
+        }
         if (maxPos < 0)  return -1;  // No positive codings at all.
         int smax = decodeSign32(maxPos, S);
         // check for 32-bit wraparound:
@@ -213,9 +216,10 @@ class Coding implements Constants, Comparable, CodingMethod, Histogram.BitMetric
         if (S == 0) {
             return 0;
         }
-        int Smask = (1<<S)-1;
         long maxNeg = range-1;
-        while (!isNegativeCode(maxNeg, S))  --maxNeg;
+        while (!isNegativeCode(maxNeg, S))
+            --maxNeg;
+
         if (maxNeg < 0)  return 0;  // No negative codings at all.
         return decodeSign32(maxNeg, S);
     }
@@ -395,12 +399,12 @@ class Coding implements Constants, Comparable, CodingMethod, Histogram.BitMetric
         return (del<<14)+(S<<11)+(B<<8)+(H<<0);
     }
 
-    private static HashMap codeMap;
+    private static Map<Coding, Coding> codeMap;
 
     private static synchronized Coding of(int B, int H, int S, int del) {
-        if (codeMap == null)  codeMap = new HashMap();
+        if (codeMap == null)  codeMap = new HashMap<>();
         Coding x0 = new Coding(B, H, S, del);
-        Coding x1 = (Coding) codeMap.get(x0);
+        Coding x1 = codeMap.get(x0);
         if (x1 == null)  codeMap.put(x0, x1 = x0);
         return x1;
     }
@@ -462,6 +466,7 @@ class Coding implements Constants, Comparable, CodingMethod, Histogram.BitMetric
         // %%% use byte[] buffer
         for (int i = start; i < end; i++)
             a[i] = readFrom(in);
+
         for (int dstep = 0; dstep < del; dstep++) {
             long state = 0;
             for (int i = start; i < end; i++) {
@@ -750,14 +755,14 @@ class Coding implements Constants, Comparable, CodingMethod, Histogram.BitMetric
         if (len == 0)       return true;
         if (isFullRange())  return true;
         // Calculate max, min:
-        int max = values[start];
-        int min = max;
+        int lmax = values[start];
+        int lmin = lmax;
         for (int i = 1; i < len; i++) {
             int value = values[start+i];
-            if (max < value)  max = value;
-            if (min > value)  min = value;
+            if (lmax < value)  lmax = value;
+            if (lmin > value)  lmin = value;
         }
-        return canRepresent(min, max);
+        return canRepresent(lmin, lmax);
     }
 
     public double getBitLength(int value) {  // implements BitMetric
@@ -800,21 +805,20 @@ class Coding implements Constants, Comparable, CodingMethod, Histogram.BitMetric
             //return Coding.of(B, H, S).getLength(deltas, 0, len);
             values = deltas;
             start = 0;
-            end = values.length;
         }
         int sum = len;  // at least 1 byte per
         // add extra bytes for extra-long values
         for (int n = 1; n <= B; n++) {
             // what is the coding interval [min..max] for n bytes?
-            int max = byteMax[n-1];
-            int min = byteMin[n-1];
+            int lmax = byteMax[n-1];
+            int lmin = byteMin[n-1];
             int longer = 0;  // count of guys longer than n bytes
             for (int i = 0; i < len; i++) {
                 int value = values[start+i];
                 if (value >= 0) {
-                    if (value > max)  longer++;
+                    if (value > lmax)  longer++;
                 } else {
-                    if (value < min)  longer++;
+                    if (value < lmin)  longer++;
                 }
             }
             if (longer == 0)  break;  // no more passes needed

src/share/classes/com/sun/java/util/jar/pack/CodingChooser.java

 /*
- * Copyright (c) 2002, 2005, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -34,15 +34,16 @@ import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Random;
+import java.util.Set;
 import java.util.zip.Deflater;
 import java.util.zip.DeflaterOutputStream;
-
+import static com.sun.java.util.jar.pack.Constants.*;
 /**
  * Heuristic chooser of basic encodings.
  * Runs "zip" to measure the apparent information content after coding.
  * @author John Rose
  */
-class CodingChooser implements Constants {
+class CodingChooser {
     int verbose;
     int effort;
     boolean optUseHistogram = true;
@@ -124,10 +125,10 @@ class CodingChooser implements Constants {
                 = !p200.getBoolean(Utils.COM_PREFIX+"no.population.coding");
             this.optUseAdaptiveCoding
                 = !p200.getBoolean(Utils.COM_PREFIX+"no.adaptive.coding");
-            int stress
+            int lstress
                 = p200.getInteger(Utils.COM_PREFIX+"stress.coding");
-            if (stress != 0)
-                this.stress = new Random(stress);
+            if (lstress != 0)
+                this.stress = new Random(lstress);
         }
 
         this.effort = effort;
@@ -376,9 +377,9 @@ class CodingChooser implements Constants {
                              " fewer bytes than regular "+regular+
                              "; win="+pct(zipSize1-bestZipSize, zipSize1));
         }
-        CodingMethod bestMethod = this.bestMethod;
+        CodingMethod lbestMethod = this.bestMethod;
         reset(null, 0, 0);  // for GC
-        return bestMethod;
+        return lbestMethod;
     }
     CodingMethod choose(int[] values, int start, int end, Coding regular) {
         return choose(values, start, end, regular, null);
@@ -742,9 +743,9 @@ class CodingChooser implements Constants {
         // Steps 1/2/3 are interdependent, and may be iterated.
         // Steps 4 and 5 may be decided independently afterward.
         int[] LValuesCoded = PopulationCoding.LValuesCoded;
-        ArrayList bestFits = new ArrayList();
-        ArrayList fullFits = new ArrayList();
-        ArrayList longFits = new ArrayList();
+        List<Coding> bestFits = new ArrayList<>();
+        List<Coding> fullFits = new ArrayList<>();
+        List<Coding> longFits = new ArrayList<>();
         final int PACK_TO_MAX_S = 1;
         if (bestPopFVC <= 255) {
             bestFits.add(BandStructure.BYTE1);
@@ -776,16 +777,16 @@ class CodingChooser implements Constants {
                 }
             }
             // interleave all B greater than bestB with best and full fits
-            for (Iterator i = bestFits.iterator(); i.hasNext(); ) {
-                Coding c = (Coding) i.next();
+            for (Iterator<Coding> i = bestFits.iterator(); i.hasNext(); ) {
+                Coding c = i.next();
                 if (c.B() > bestB) {
                     i.remove();
                     longFits.add(0, c);
                 }
             }
         }
-        ArrayList allFits = new ArrayList();
-        for (Iterator i = bestFits.iterator(),
+        List<Coding> allFits = new ArrayList<>();
+        for (Iterator<Coding> i = bestFits.iterator(),
                       j = fullFits.iterator(),
                       k = longFits.iterator();
              i.hasNext() || j.hasNext() || k.hasNext(); ) {
@@ -812,8 +813,7 @@ class CodingChooser implements Constants {
         }
         if (verbose > 3)
             Utils.log.info("allFits: "+allFits);
-        for (Iterator i = allFits.iterator(); i.hasNext(); ) {
-            Coding tc = (Coding) i.next();
+        for (Coding tc : allFits) {
             boolean packToMax = false;
             if (tc.S() == PACK_TO_MAX_S) {
                 // Kludge:  setS(PACK_TO_MAX_S) means packToMax here.
@@ -910,7 +910,7 @@ class CodingChooser implements Constants {
                              " tc="+pop.tokenCoding+
                              " uc="+pop.unfavoredCoding);
             //pop.hist.print("pop-hist", null, System.out);
-            StringBuffer sb = new StringBuffer();
+            StringBuilder sb = new StringBuilder();
             sb.append("fv = {");
             for (int i = 1; i <= fVlen; i++) {
                 if ((i % 10) == 0)
@@ -949,20 +949,20 @@ class CodingChooser implements Constants {
         // run occupies too much space.  ("Too much" means, say 5% more
         // than the average integer size of the band as a whole.)
         // Try to find a better coding for those segments.
-        int   start  = this.start;
-        int   end    = this.end;
-        int[] values = this.values;
-        int len = end-start;
+        int   lstart  = this.start;
+        int   lend    = this.end;
+        int[] lvalues = this.values;
+        int len = lend-lstart;
         if (plainCoding.isDelta()) {
-            values = getDeltas(0,0); //%%% not quite right!
-            start = 0;
-            end = values.length;
+            lvalues = getDeltas(0,0); //%%% not quite right!
+            lstart = 0;
+            lend = lvalues.length;
         }
         int[] sizes = new int[len+1];
         int fillp = 0;
         int totalSize = 0;
-        for (int i = start; i < end; i++) {
-            int val = values[i];
+        for (int i = lstart; i < lend; i++) {
+            int val = lvalues[i];
             sizes[fillp++] = totalSize;
             int size = plainCoding.getLength(val);
             assert(size < Integer.MAX_VALUE);
@@ -1013,22 +1013,23 @@ class CodingChooser implements Constants {
         double[] fuzzes   = new double[meshes.length];
         for (int i = 0; i < meshes.length; i++) {
             int mesh = meshes[i];
-            double fuzz;
+            double lfuzz;
             if (mesh < 10)
-                fuzz = sizeFuzz3;
+                lfuzz = sizeFuzz3;
             else if (mesh < 100)
-                fuzz = sizeFuzz2;
+                lfuzz = sizeFuzz2;
             else
-                fuzz = sizeFuzz;
-            fuzzes[i] = fuzz;
-            threshes[i] = BAND_HEADER + (int)Math.ceil(mesh * avgSize * fuzz);
+                lfuzz = sizeFuzz;
+            fuzzes[i] = lfuzz;
+            threshes[i] = BAND_HEADER + (int)Math.ceil(mesh * avgSize * lfuzz);
         }
         if (verbose > 1) {
             System.out.print("tryAdaptiveCoding ["+len+"]"+
                              " avgS="+avgSize+" fuzz="+sizeFuzz+
                              " meshes: {");
-            for (int i = 0; i < meshes.length; i++)
-                System.out.print(" "+meshes[i]+"("+threshes[i]+")");
+            for (int i = 0; i < meshes.length; i++) {
+                System.out.print(" " + meshes[i] + "(" + threshes[i] + ")");
+            }
             Utils.log.info(" }");
         }
         if (runHelper == null) {
@@ -1229,20 +1230,19 @@ class CodingChooser implements Constants {
         Histogram hist = getValueHistogram();
         int fVlen = stressLen(hist.getTotalLength());
         if (fVlen == 0)  return coding;
-        List popvals = new ArrayList();
+        List<Integer> popvals = new ArrayList<>();
         if (stress.nextBoolean()) {
             // Build the population from the value list.
-            HashSet popset = new HashSet();
+            Set<Integer> popset = new HashSet<>();
             for (int i = start; i < end; i++) {
-                Integer val = new Integer(values[i]);
-                if (popset.add(val))  popvals.add(val);
+                if (popset.add(values[i]))  popvals.add(values[i]);
             }
         } else {
             int[][] matrix = hist.getMatrix();
             for (int mrow = 0; mrow < matrix.length; mrow++) {
                 int[] row = matrix[mrow];
                 for (int mcol = 1; mcol < row.length; mcol++) {
-                    popvals.add(new Integer(row[mcol]));
+                    popvals.add(row[mcol]);
                 }
             }
         }
@@ -1269,7 +1269,7 @@ class CodingChooser implements Constants {
         fVlen = popvals.size();
         int[] fvals = new int[1+fVlen];
         for (int i = 0; i < fVlen; i++) {
-            fvals[1+i] = ((Integer)popvals.get(i)).intValue();
+            fvals[1+i] = (popvals.get(i)).intValue();
         }
         PopulationCoding pop = new PopulationCoding();
         pop.setFavoredValues(fvals, fVlen);
@@ -1283,13 +1283,13 @@ class CodingChooser implements Constants {
             }
         }
         if (pop.tokenCoding == null) {
-            int min = fvals[1], max = min;
+            int lmin = fvals[1], lmax = lmin;
             for (int i = 2; i <= fVlen; i++) {
                 int val = fvals[i];
-                if (min > val)  min = val;
-                if (max < val)  max = val;
+                if (lmin > val)  lmin = val;
+                if (lmax < val)  lmax = val;
             }
-            pop.tokenCoding = stressCoding(min, max);
+            pop.tokenCoding = stressCoding(lmin, lmax);
         }
 
         computePopSizePrivate(pop, valueCoding, valueCoding);
@@ -1310,13 +1310,13 @@ class CodingChooser implements Constants {
         try {
             assert(!disableRunCoding);
             disableRunCoding = true;  // temporary, while I decide spans
-            int[] allValues = (int[]) values.clone();
+            int[] allValues = values.clone();
             CodingMethod result = null;
             int scan  = this.end;
-            int start = this.start;
-            for (int split; scan > start; scan = split) {
+            int lstart = this.start;
+            for (int split; scan > lstart; scan = split) {
                 int thisspan;
-                int rand = (scan - start < 100)? -1: stress.nextInt();
+                int rand = (scan - lstart < 100)? -1: stress.nextInt();
                 if ((rand & 7) != 0) {
                     thisspan = (spanlen==1? spanlen: stressLen(spanlen-1)+1);
                 } else {
@@ -1325,7 +1325,7 @@ class CodingChooser implements Constants {
                     int KB = (rand >>>= 3) & AdaptiveCoding.KB_MAX;
                     for (;;) {
                         thisspan = AdaptiveCoding.decodeK(KX, KB);
-                        if (thisspan <= scan - start)  break;
+                        if (thisspan <= scan - lstart)  break;
                         // Try smaller and smaller codings:
                         if (KB != AdaptiveCoding.KB_DEFAULT)
                             KB = AdaptiveCoding.KB_DEFAULT;
@@ -1335,11 +1335,13 @@ class CodingChooser implements Constants {
                     //System.out.println("KX="+KX+" KB="+KB+" K="+thisspan);
                     assert(AdaptiveCoding.isCodableLength(thisspan));
                 }
-                if (thisspan > scan - start)  thisspan = scan - start;
-                while (!AdaptiveCoding.isCodableLength(thisspan))  --thisspan;
+                if (thisspan > scan - lstart)  thisspan = scan - lstart;
+                while (!AdaptiveCoding.isCodableLength(thisspan)) {
+                    --thisspan;
+                }
                 split = scan - thisspan;
                 assert(split < scan);
-                assert(split >= start);
+                assert(split >= lstart);
                 // Choose a coding for the span [split..scan).
                 CodingMethod sc = choose(allValues, split, scan, plainCoding);
                 if (result == null) {
@@ -1420,7 +1422,7 @@ class CodingChooser implements Constants {
                 case StreamTokenizer.TT_EOF:
                     throw new NoSuchElementException();
                 case StreamTokenizer.TT_NUMBER:
-                    return new Integer((int) in.nval);
+                    return Integer.valueOf((int) in.nval);
                 default:
                     assert(false);
                     return null;

src/share/classes/com/sun/java/util/jar/pack/ConstantPool.java

@@ -33,13 +33,14 @@ import java.util.List;
 import java.util.ListIterator;
 import java.util.Map;
 import java.util.Set;
+import static com.sun.java.util.jar.pack.Constants.*;
 
 /**
  * Representation of constant pool entries and indexes.
  * @author John Rose
  */
 abstract
-class ConstantPool implements Constants {
+class ConstantPool {
     private ConstantPool() {}  // do not instantiate
 
     static int verbose() {
@@ -155,9 +156,6 @@ class ConstantPool implements Constants {
             return null;
         }
 
-        public boolean sameTagAs(Object o) {
-            return (o instanceof Entry) && ((Entry)o).tag == tag;
-        }
         public boolean eq(Entry that) {  // same reference
             assert(that != null);
             return this == that || this.equals(that);
@@ -219,9 +217,9 @@ class ConstantPool implements Constants {
             return value.hashCode();
         }
         public boolean equals(Object o) {
-            if (!sameTagAs(o))  return false;
             // Use reference equality of interned strings:
-            return ((Utf8Entry)o).value == value;
+            return (o != null && o.getClass() == Utf8Entry.class
+                    && ((Utf8Entry) o).value.equals(value));
         }
         public int compareTo(Object o) {
             int x = superCompareTo(o);
@@ -275,8 +273,9 @@ class ConstantPool implements Constants {
         }
 
         public boolean equals(Object o) {
-            if (!sameTagAs(o))  return false;
-            return (((NumberEntry)o).value).equals(value);
+            return (o != null && o.getClass() == NumberEntry.class
+                    && ((NumberEntry) o).value.equals(value));
+
         }
         public int compareTo(Object o) {
             int x = superCompareTo(o);
@@ -310,8 +309,8 @@ class ConstantPool implements Constants {
             return ref.hashCode() + tag;
         }
         public boolean equals(Object o) {
-            if (!sameTagAs(o))  return false;
-            return ((StringEntry)o).ref.eq(ref);
+            return (o != null && o.getClass() == StringEntry.class &&
+                    ((StringEntry)o).ref.eq(ref));
         }
         public int compareTo(Object o) {
             int x = superCompareTo(o);
@@ -342,8 +341,8 @@ class ConstantPool implements Constants {
             hashCode();  // force computation of valueHash
         }
         public boolean equals(Object o) {
-            if (!sameTagAs(o))  return false;
-            return ((ClassEntry)o).ref.eq(ref);
+            return (o != null && o.getClass() == ClassEntry.class
+                    && ((ClassEntry) o).ref.eq(ref));
         }
         public int compareTo(Object o) {
             int x = superCompareTo(o);
@@ -380,7 +379,9 @@ class ConstantPool implements Constants {
             return (nameRef.hashCode() + (hc2 << 8)) ^ hc2;
         }
         public boolean equals(Object o) {
-            if (!sameTagAs(o))  return false;
+            if (o == null || o.getClass() != DescriptorEntry.class) {
+                return false;
+            }
             DescriptorEntry that = (DescriptorEntry)o;
             return this.nameRef.eq(that.nameRef)
                 && this.typeRef.eq(that.typeRef);
@@ -439,7 +440,9 @@ class ConstantPool implements Constants {
             hashCode();  // force computation of valueHash
         }
         public boolean equals(Object o) {
-            if (!sameTagAs(o))  return false;
+            if (o == null || o.getClass() != MemberEntry.class) {
+                return false;
+            }
             MemberEntry that = (MemberEntry)o;
             return this.classRef.eq(that.classRef)
                 && this.descRef.eq(that.descRef);
@@ -511,8 +514,8 @@ class ConstantPool implements Constants {
         }
 
         public boolean equals(Object o) {
-            if (!sameTagAs(o))  return false;
-            return ((SignatureEntry)o).value == value;
+            return (o != null && o.getClass() == SignatureEntry.class &&
+                    ((SignatureEntry)o).value.equals(value));
         }
         public int compareTo(Object o) {
             int x = superCompareTo(o);
@@ -724,7 +727,7 @@ class ConstantPool implements Constants {
     protected static final ClassEntry[] noClassRefs = {};
 
     /** An Index is a mapping between CP entries and small integers. */
-    public static
+    public static final
     class Index extends AbstractList {
         protected String debugName;
         protected Entry[] cpMap;
@@ -894,7 +897,7 @@ class ConstantPool implements Constants {
     }
 
     public static
-    Index makeIndex(String debugName, Collection cpMapList) {
+    Index makeIndex(String debugName, Collection<Entry> cpMapList) {
         return new Index(debugName, cpMapList);
     }
 
@@ -916,7 +919,7 @@ class ConstantPool implements Constants {
     public static
     Index[] partition(Index ix, int[] keys) {
         // %%% Should move this into class Index.
-        ArrayList<List<Entry>> parts = new ArrayList<>();
+        List<List<Entry>> parts = new ArrayList<>();
         Entry[] cpMap = ix.cpMap;
         assert(keys.length == cpMap.length);
         for (int i = 0; i < keys.length; i++) {
@@ -1094,12 +1097,12 @@ class ConstantPool implements Constants {
 
         // Inverse of getOverloadingIndex
         public MemberEntry getOverloadingForIndex(byte tag, ClassEntry classRef, String name, int which) {
-            assert(name == name.intern());
+            assert(name.equals(name.intern()));
             Index ix = getMemberIndex(tag, classRef);
             int ord = 0;
             for (int i = 0; i < ix.cpMap.length; i++) {
                 MemberEntry e = (MemberEntry) ix.cpMap[i];
-                if (e.descRef.nameRef.stringValue() == name) {
+                if (e.descRef.nameRef.stringValue().equals(name)) {
                     if (ord == which)  return e;
                     ord++;
                 }
@@ -1133,10 +1136,10 @@ class ConstantPool implements Constants {
     public static
     void completeReferencesIn(Set<Entry> cpRefs, boolean flattenSigs) {
         cpRefs.remove(null);
-        for (ListIterator work =
-                 new ArrayList(cpRefs).listIterator(cpRefs.size());
+        for (ListIterator<Entry> work =
+                 new ArrayList<Entry>(cpRefs).listIterator(cpRefs.size());
              work.hasPrevious(); ) {
-            Entry e = (Entry) work.previous();
+            Entry e = work.previous();
             work.remove();          // pop stack
             assert(e != null);
             if (flattenSigs && e.tag == CONSTANT_Signature) {

src/share/classes/com/sun/java/util/jar/pack/Constants.java

@@ -32,7 +32,10 @@ import java.util.List;
  * Shared constants
  * @author John Rose
  */
-interface Constants {
+class Constants {
+
+    private Constants(){}
+
     public final static int JAVA_MAGIC = 0xCAFEBABE;
 
     /*

src/share/classes/com/sun/java/util/jar/pack/Driver.java

@@ -59,12 +59,11 @@ class Driver {
                 ResourceBundle.getBundle("com.sun.java.util.jar.pack.DriverResource");
 
     public static void main(String[] ava) throws IOException {
-        ArrayList<String> av = new ArrayList<>(Arrays.asList(ava));
+        List<String> av = new ArrayList<>(Arrays.asList(ava));
 
         boolean doPack   = true;
         boolean doUnpack = false;
         boolean doRepack = false;
-        boolean doForceRepack = false;
         boolean doZip = true;
         String logFile = null;
         String verboseProp = Utils.DEBUG_VERBOSE;
@@ -72,17 +71,20 @@ class Driver {
         {
             // Non-standard, undocumented "--unpack" switch enables unpack mode.
             String arg0 = av.isEmpty() ? "" : av.get(0);
-            if (arg0.equals("--pack")) {
+            switch (arg0) {
+                case "--pack":
                 av.remove(0);
-            } else if (arg0.equals("--unpack")) {
+                    break;
+                case "--unpack":
                 av.remove(0);
                 doPack = false;
                 doUnpack = true;
+                    break;
             }
         }
 
         // Collect engine properties here:
-        HashMap<String,String> engProps = new HashMap<>();
+        Map<String,String> engProps = new HashMap<>();
         engProps.put(verboseProp, System.getProperty(verboseProp));
 
         String optionMap;
@@ -96,7 +98,7 @@ class Driver {
         }
 
         // Collect argument properties here:
-        HashMap<String,String> avProps = new HashMap<>();
+        Map<String,String> avProps = new HashMap<>();
         try {
             for (;;) {
                 String state = parseCommandOptions(av, optionMap, avProps);
@@ -146,7 +148,7 @@ class Driver {
                 }
 
                 // See if there is any other action to take.
-                if (state == "--config-file=") {
+                if ("--config-file=".equals(state)) {
                     String propFile = av.remove(0);
                     InputStream propIn = new FileInputStream(propFile);
                     Properties fileProps = new Properties();
@@ -157,10 +159,10 @@ class Driver {
                     for (Map.Entry<Object,Object> me : fileProps.entrySet()) {
                         engProps.put((String) me.getKey(), (String) me.getValue());
                     }
-                } else if (state == "--version") {
+                } else if ("--version".equals(state)) {
                         System.out.println(MessageFormat.format(RESOURCE.getString(DriverResource.VERSION), Driver.class.getName(), "1.31, 07/05/05"));
                     return;
-                } else if (state == "--help") {
+                } else if ("--help".equals(state)) {
                     printUsage(doPack, true, System.out);
                     System.exit(1);
                     return;
@@ -178,14 +180,20 @@ class Driver {
         // Deal with remaining non-engine properties:
         for (String opt : avProps.keySet()) {
             String val = avProps.get(opt);
-            if (opt == "--repack") {
+            switch (opt) {
+                case "--repack":
                     doRepack = true;
-            } else if (opt == "--no-gzip") {
+                    break;
+                case "--no-gzip":
                     doZip = (val == null);
-            } else if (opt == "--log-file=") {
+                    break;
+                case "--log-file=":
                     logFile = val;
-            } else {
-            throw new InternalError(MessageFormat.format(RESOURCE.getString(DriverResource.BAD_OPTION), opt, avProps.get(opt)));
+                    break;
+                default:
+                    throw new InternalError(MessageFormat.format(
+                            RESOURCE.getString(DriverResource.BAD_OPTION),
+                            opt, avProps.get(opt)));
             }
         }
 
@@ -219,7 +227,9 @@ class Driver {
             if (packfile.toLowerCase().endsWith(".pack") ||
                 packfile.toLowerCase().endsWith(".pac") ||
                 packfile.toLowerCase().endsWith(".gz")) {
-            System.err.println(MessageFormat.format(RESOURCE.getString(DriverResource.BAD_REPACK_OUTPUT),packfile));
+                System.err.println(MessageFormat.format(
+                        RESOURCE.getString(DriverResource.BAD_REPACK_OUTPUT),
+                        packfile));
                 printUsage(doPack, false, System.err);
                 System.exit(2);
             }

src/share/classes/com/sun/java/util/jar/pack/Fixups.java

 /*
- * Copyright (c) 2003, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -42,7 +42,7 @@ import java.util.Iterator;
  *
  * @author John Rose
  */
-class Fixups extends AbstractCollection implements Constants {
+final class Fixups extends AbstractCollection {
     byte[] bytes;    // the subject of the relocations
     int head;        // desc locating first reloc
     int tail;        // desc locating last reloc
@@ -99,7 +99,7 @@ class Fixups extends AbstractCollection implements Constants {
         }
     }
 
-    public void visitRefs(Collection refs) {
+    public void visitRefs(Collection<Entry> refs) {
         for (int i = 0; i < size; i++) {
             refs.add(entries[i]);
         }
@@ -124,6 +124,7 @@ class Fixups extends AbstractCollection implements Constants {
         return bytes;
     }
 
+    @SuppressWarnings("unchecked")
     public void setBytes(byte[] newBytes) {
         if (bytes == newBytes)  return;
         ArrayList old = null;
@@ -278,7 +279,7 @@ class Fixups extends AbstractCollection implements Constants {
             return new Fixup(nextDesc(), entries[thisIndex]);
         }
         int nextDesc() {
-            int thisIndex = index++;
+            index++;
             int thisDesc = next;
             if (index < size) {
                 // Fetch next desc eagerly, in case this fixup gets finalized.
@@ -310,6 +311,7 @@ class Fixups extends AbstractCollection implements Constants {
     public boolean add(Object fixup) {
         return add((Fixup) fixup);
     }
+    @SuppressWarnings("unchecked")
     public boolean addAll(Collection c) {
         if (c instanceof Fixups) {
             // Use knowledge of Itr structure to avoid building little structs.
@@ -420,7 +422,7 @@ class Fixups extends AbstractCollection implements Constants {
 
     // Iterate over all the references in this set of fixups.
     public static
-    void visitRefs(Object fixups, Collection refs) {
+    void visitRefs(Object fixups, Collection<Entry> refs) {
         if (fixups == null) {
         } else if (!(fixups instanceof Fixups)) {
             // Special convention; see above.

src/share/classes/com/sun/java/util/jar/pack/Histogram.java

 /*
- * Copyright (c) 2003, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -34,7 +34,7 @@ import java.util.Arrays;
  * Histogram derived from an integer array of events (int[]).
  * @author John Rose
  */
-class Histogram {
+final class Histogram {
     // Compact histogram representation:  4 bytes per distinct value,
     // plus 5 words per distinct count.
     protected final int[][] matrix;  // multi-row matrix {{counti,valueij...}}
@@ -304,7 +304,7 @@ class Histogram {
     public
     String[] getRowTitles(String name) {
         int totalUnique = getTotalLength();
-        int totalWeight = getTotalWeight();
+        int ltotalWeight = getTotalWeight();
         String[] histTitles = new String[matrix.length];
         int cumWeight = 0;
         int cumUnique = 0;
@@ -314,7 +314,7 @@ class Histogram {
             int weight = getRowWeight(i);
             cumWeight += weight;
             cumUnique += unique;
-            long wpct = ((long)cumWeight * 100 + totalWeight/2) / totalWeight;
+            long wpct = ((long)cumWeight * 100 + ltotalWeight/2) / ltotalWeight;
             long upct = ((long)cumUnique * 100 + totalUnique/2) / totalUnique;
             double len = getRowBitLength(i);
             assert(0.1 > Math.abs(len - getBitLength(matrix[i][1])));
@@ -346,14 +346,14 @@ class Histogram {
     public
     void print(String name, String[] histTitles, PrintStream out) {
         int totalUnique = getTotalLength();
-        int totalWeight = getTotalWeight();
+        int ltotalWeight = getTotalWeight();
         double tlen = getBitLength();
-        double avgLen = tlen / totalWeight;
-        double avg = (double) totalWeight / totalUnique;
+        double avgLen = tlen / ltotalWeight;
+        double avg = (double) ltotalWeight / totalUnique;
         String title = (name
                         +" len="+round(tlen,10)
                         +" avgLen="+round(avgLen,10)
-                        +" weight("+totalWeight+")"
+                        +" weight("+ltotalWeight+")"
                         +" unique["+totalUnique+"]"
                         +" avgWeight("+round(avg,100)+")");
         if (histTitles == null) {
@@ -363,9 +363,9 @@ class Histogram {
             StringBuffer buf = new StringBuffer();
             for (int i = 0; i < matrix.length; i++) {
                 buf.setLength(0);
-                buf.append("  "+histTitles[i]+" {");
+                buf.append("  ").append(histTitles[i]).append(" {");
                 for (int j = 1; j < matrix[i].length; j++) {
-                    buf.append(" "+matrix[i][j]);
+                    buf.append(" ").append(matrix[i][j]);
                 }
                 buf.append(" }");
                 out.println(buf);
@@ -603,7 +603,7 @@ class Histogram {
     private static
     int[] maybeSort(int[] values) {
         if (!isSorted(values, 0, false)) {
-            values = (int[]) values.clone();
+            values = values.clone();
             Arrays.sort(values);
         }
         return values;

src/share/classes/com/sun/java/util/jar/pack/Instruction.java

 /*
- * Copyright (c) 2001, 2005, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -26,13 +26,15 @@
 package com.sun.java.util.jar.pack;
 
 import java.io.IOException;
+import java.util.Arrays;
+import static com.sun.java.util.jar.pack.Constants.*;
 
 /**
  * A parsed bytecode instruction.
  * Provides accessors to various relevant bits.
  * @author John Rose
  */
-class Instruction implements Constants {
+class Instruction  {
     protected byte[] bytes;  // bytecodes
     protected int pc;        // location of this instruction
     protected int bc;        // opcode of this instruction
@@ -91,8 +93,8 @@ class Instruction implements Constants {
 
     /** A fake instruction at this pc whose next() will be at nextpc. */
     public Instruction forceNextPC(int nextpc) {
-        int length = nextpc - pc;
-        return new Instruction(bytes, pc, -1, -1, length);
+        int llength = nextpc - pc;
+        return new Instruction(bytes, pc, -1, -1, llength);
     }
 
     public static Instruction at(byte[] bytes, int pc) {
@@ -315,12 +317,24 @@ class Instruction implements Constants {
         }
     }
 
-    /** Two insns are equal if they have the same bytes. */
+    /** Two instructions are equal if they have the same bytes. */
     public boolean equals(Object o) {
-        return (o instanceof Instruction) && equals((Instruction)o);
+        return (o != null) && (o.getClass() == Instruction.class)
+                && equals((Instruction) o);
+    }
+
+    public int hashCode() {
+        int hash = 3;
+        hash = 11 * hash + Arrays.hashCode(this.bytes);
+        hash = 11 * hash + this.pc;
+        hash = 11 * hash + this.bc;
+        hash = 11 * hash + this.w;
+        hash = 11 * hash + this.length;
+        return hash;
     }
 
     public boolean equals(Instruction that) {
+        if (this.pc != that.pc)            return false;
         if (this.bc != that.bc)            return false;
         if (this.w  != that.w)             return false;
         if (this.length  != that.length)   return false;

src/share/classes/com/sun/java/util/jar/pack/NativeUnpack.java

@@ -170,8 +170,8 @@ class NativeUnpack {
 
     void run(InputStream inRaw, JarOutputStream jstream,
              ByteBuffer presetInput) throws IOException {
-        BufferedInputStream in = new BufferedInputStream(inRaw);
-        this.in = in;    // for readInputFn to see
+        BufferedInputStream in0 = new BufferedInputStream(inRaw);
+        this.in = in0;    // for readInputFn to see
         _verbose = _props.getInteger(Utils.DEBUG_VERBOSE);
         // Fix for BugId: 4902477, -unpack.modification.time = 1059010598000
         // TODO eliminate and fix in unpack.cpp
@@ -224,7 +224,7 @@ class NativeUnpack {
             if (_verbose > 0)
                 Utils.log.info("bytes consumed = "+consumed);
             if (presetInput == null &&
-                !Utils.isPackMagic(Utils.readMagic(in))) {
+                !Utils.isPackMagic(Utils.readMagic(in0))) {
                 break;
             }
             if (_verbose > 0 ) {

src/share/classes/com/sun/java/util/jar/pack/Package.java

@@ -52,12 +52,13 @@ import java.util.ListIterator;
 import java.util.Map;
 import java.util.Set;
 import java.util.jar.JarFile;
+import static com.sun.java.util.jar.pack.Constants.*;
 
 /**
  * Define the main data structure transmitted by pack/unpack.
  * @author John Rose
  */
-class Package implements Constants {
+class Package {
     int verbose;
     {
         PropMap pmap = Utils.currentPropMap();
@@ -109,9 +110,9 @@ class Package implements Constants {
     public static final Attribute.Layout attrCodeEmpty;
     public static final Attribute.Layout attrInnerClassesEmpty;
     public static final Attribute.Layout attrSourceFileSpecial;
-    public static final Map attrDefs;
+    public static final Map<Attribute.Layout, Attribute> attrDefs;
     static {
-        HashMap<Layout, Attribute> ad = new HashMap<>(3);
+        Map<Layout, Attribute> ad = new HashMap<>(3);
         attrCodeEmpty = Attribute.define(ad, ATTR_CONTEXT_METHOD,
                                          "Code", "").layout();
         attrInnerClassesEmpty = Attribute.define(ad, ATTR_CONTEXT_CLASS,
@@ -130,8 +131,7 @@ class Package implements Constants {
      */
     int getHighestClassVersion() {
         int res = 0;  // initial low value
-        for (Iterator i = classes.iterator(); i.hasNext(); ) {
-            Class cls = (Class) i.next();
+        for (Class cls : classes) {
             int ver = cls.getVersion();
             if (res < ver)  res = ver;
         }
@@ -187,7 +187,7 @@ class Package implements Constants {
         return classes;
     }
 
-    public
+    public final
     class Class extends Attribute.Holder implements Comparable {
         public Package getPackage() { return Package.this; }
 
@@ -232,8 +232,8 @@ class Package implements Constants {
             initFile(newStub(classFile));
         }
 
-        List getFields() { return fields == null ? noFields : fields; }
-        List getMethods() { return methods == null ? noMethods : methods; }
+        List<Field> getFields() { return fields == null ? noFields : fields; }
+        List<Method> getMethods() { return methods == null ? noMethods : methods; }
 
         public String getName() {
             return thisClass.stringValue();
@@ -264,7 +264,7 @@ class Package implements Constants {
             if (olda == null)
                 return;  // no SourceFile attr.
             String obvious = getObviousSourceFile();
-            ArrayList ref = new ArrayList(1);
+            List<Entry> ref = new ArrayList<>(1);
             olda.visitRefs(this, VRM_PACKAGE, ref);
             Utf8Entry sfName = (Utf8Entry) ref.get(0);
             Attribute a = olda;
@@ -341,7 +341,7 @@ class Package implements Constants {
          *  with that of Package.this.allInnerClasses.
          */
         public List<InnerClass> computeGloballyImpliedICs() {
-            HashSet<Entry> cpRefs = new HashSet<>();
+            Set<Entry> cpRefs = new HashSet<>();
             {   // This block temporarily displaces this.innerClasses.
                 ArrayList<InnerClass> innerClassesSaved = innerClasses;
                 innerClasses = null;  // ignore for the moment
@@ -350,7 +350,7 @@ class Package implements Constants {
             }
             ConstantPool.completeReferencesIn(cpRefs, true);
 
-            HashSet<Entry> icRefs = new HashSet<>();
+            Set<Entry> icRefs = new HashSet<>();
             for (Entry e : cpRefs) {
                 // Restrict cpRefs to InnerClasses entries only.
                 if (!(e instanceof ClassEntry))  continue;
@@ -390,7 +390,7 @@ class Package implements Constants {
             List<InnerClass> impliedICs = computeGloballyImpliedICs();
             List<InnerClass> actualICs  = getInnerClasses();
             if (actualICs == null)
-                actualICs = Collections.EMPTY_LIST;
+                actualICs = Collections.emptyList();
 
             // Symmetric difference is calculated from I, A like this:
             //  diff = (I+A) - (I*A)
@@ -409,7 +409,7 @@ class Package implements Constants {
                 // Diff is A since I is empty.
             }
             // (I*A) is non-trivial
-            HashSet<InnerClass> center = new HashSet<>(actualICs);
+            Set<InnerClass> center = new HashSet<>(actualICs);
             center.retainAll(new HashSet<>(impliedICs));
             impliedICs.addAll(actualICs);
             impliedICs.removeAll(center);
@@ -443,7 +443,7 @@ class Package implements Constants {
             } else if (actualICs == null) {
                 // No local IC attribute, even though some are implied.
                 // Signal with trivial attribute.
-                localICs = Collections.EMPTY_LIST;
+                localICs = Collections.emptyList();
             } else {
                 // Transmit a non-empty diff, which will create
                 // a local ICs attribute.
@@ -588,7 +588,7 @@ class Package implements Constants {
             }
 
             public void strip(String attrName) {
-                if (attrName == "Code")
+                if ("Code".equals(attrName))
                     code = null;
                 if (code != null)
                     code.strip(attrName);
@@ -622,7 +622,7 @@ class Package implements Constants {
         }
 
         public void strip(String attrName) {
-            if (attrName == "InnerClass")
+            if ("InnerClass".equals(attrName))
                 innerClasses = null;
             for (int isM = 0; isM <= 1; isM++) {
                 ArrayList members = (isM == 0) ? fields : methods;
@@ -639,9 +639,7 @@ class Package implements Constants {
             if (verbose > 2)  Utils.log.fine("visitRefs "+this);
             refs.add(thisClass);
             refs.add(superClass);
-            for (int i = 0; i < interfaces.length; i++) {
-                refs.add(interfaces[i]);
-            }
+            refs.addAll(Arrays.asList(interfaces));
             for (int isM = 0; isM <= 1; isM++) {
                 ArrayList members = (isM == 0) ? fields : methods;
                 if (members == null)  continue;
@@ -741,7 +739,7 @@ class Package implements Constants {
     }
 
     public List<File> getClassStubs() {
-        ArrayList<File> classStubs = new ArrayList<>(classes.size());
+        List<File> classStubs = new ArrayList<>(classes.size());
         for (Class cls : classes) {
             assert(cls.file.isClassStub());
             classStubs.add(cls.file);
@@ -749,8 +747,7 @@ class Package implements Constants {
         return classStubs;
     }
 
-    public
-    class File implements Comparable {
+    public final class File implements Comparable {
         String nameString;  // true name of this file
         Utf8Entry name;
         int modtime = NO_MODTIME;
@@ -792,8 +789,10 @@ class Package implements Constants {
         // The nameString is the key.  Ignore other things.
         // (Note:  The name might be "", in the case of a trivial class stub.)
         public boolean equals(Object o) {
+            if (o == null || (o.getClass() != File.class))
+                return false;
             File that = (File)o;
-            return that.nameString == this.nameString;
+            return that.nameString.equals(this.nameString);
         }
         public int hashCode() {
             return nameString.hashCode();
@@ -816,9 +815,9 @@ class Package implements Constants {
             return getFileName(null);
         }
         public java.io.File getFileName(java.io.File parent) {
-            String name = this.nameString;
+            String lname = this.nameString;
             //if (name.startsWith("./"))  name = name.substring(2);
-            String fname = name.replace('/', java.io.File.separatorChar);
+            String fname = lname.replace('/', java.io.File.separatorChar);
             return new java.io.File(parent, fname);
         }
 
@@ -834,7 +833,7 @@ class Package implements Constants {
         }
         public long getFileLength() {
             long len = 0;
-            if (prepend == null && append == null)  return 0;
+            if (prepend == null || append == null)  return 0;
             for (Iterator i = prepend.iterator(); i.hasNext(); ) {
                 byte[] block = (byte[]) i.next();
                 len += block.length;
@@ -843,7 +842,7 @@ class Package implements Constants {
             return len;
         }
         public void writeTo(OutputStream out) throws IOException {
-            if (prepend == null && append == null)  return;
+            if (prepend == null || append == null)  return;
             for (Iterator i = prepend.iterator(); i.hasNext(); ) {
                 byte[] block = (byte[]) i.next();
                 out.write(block);
@@ -859,8 +858,8 @@ class Package implements Constants {
         }
         public InputStream getInputStream() {
             InputStream in = new ByteArrayInputStream(append.toByteArray());
-            if (prepend.size() == 0)  return in;
-            ArrayList<InputStream> isa = new ArrayList<>(prepend.size()+1);
+            if (prepend.isEmpty())  return in;
+            List<InputStream> isa = new ArrayList<>(prepend.size()+1);
             for (Iterator i = prepend.iterator(); i.hasNext(); ) {
                 byte[] bytes = (byte[]) i.next();
                 isa.add(new ByteArrayInputStream(bytes));
@@ -897,11 +896,11 @@ class Package implements Constants {
     }
 
     // Is there a globally declared table of inner classes?
-    ArrayList<InnerClass> allInnerClasses = new ArrayList<>();
-    HashMap<ClassEntry, InnerClass>   allInnerClassesByThis;
+    List<InnerClass> allInnerClasses = new ArrayList<>();
+    Map<ClassEntry, InnerClass>   allInnerClassesByThis;
 
     public
-    List getAllInnerClasses() {
+    List<InnerClass> getAllInnerClasses() {
         return allInnerClasses;
     }
 
@@ -955,16 +954,17 @@ class Package implements Constants {
             if (parse == null)  return false;
             String pkgOuter = parse[0];
             //String number = parse[1];
-            String name     = parse[2];
+            String lname     = parse[2];
             String haveName  = (this.name == null)  ? null : this.name.stringValue();
             String haveOuter = (outerClass == null) ? null : outerClass.stringValue();
-            boolean predictable = (name == haveName && pkgOuter == haveOuter);
+            boolean lpredictable = (lname == haveName && pkgOuter == haveOuter);
             //System.out.println("computePredictable => "+predictable);
-            return predictable;
+            return lpredictable;
         }
 
         public boolean equals(Object o) {
-            if (o == null)  return false;
+            if (o == null || o.getClass() != InnerClass.class)
+                return false;
             InnerClass that = (InnerClass)o;
             return eq(this.thisClass, that.thisClass)
                 && eq(this.outerClass, that.outerClass)
@@ -999,7 +999,7 @@ class Package implements Constants {
 
     // Helper for building InnerClasses attributes.
     static private
-    void visitInnerClassRefs(Collection innerClasses, int mode, Collection<Entry> refs) {
+    void visitInnerClassRefs(Collection<InnerClass> innerClasses, int mode, Collection<Entry> refs) {
         if (innerClasses == null) {
             return;  // no attribute; nothing to do
         }
@@ -1008,8 +1008,7 @@ class Package implements Constants {
         }
         if (innerClasses.size() > 0) {
             // Count the entries themselves:
-            for (Iterator i = innerClasses.iterator(); i.hasNext(); ) {
-                InnerClass c = (InnerClass) i.next();
+            for (InnerClass c : innerClasses) {
                 c.visitRefs(mode, refs);
             }
         }
@@ -1117,43 +1116,43 @@ class Package implements Constants {
         // what is one of { Debug, Compile, Constant, Exceptions, InnerClasses }
         if (verbose > 0)
             Utils.log.info("Stripping "+what.toLowerCase()+" data and attributes...");
-        if (what == "Debug") {
+        switch (what) {
+            case "Debug":
                 strip("SourceFile");
                 strip("LineNumberTable");
                 strip("LocalVariableTable");
                 strip("LocalVariableTypeTable");
-        }
-        if (what == "Compile") {
+                break;
+            case "Compile":
                 // Keep the inner classes normally.
                 // Although they have no effect on execution,
                 // the Reflection API exposes them, and JCK checks them.
                 // NO: // strip("InnerClasses");
                 strip("Deprecated");
                 strip("Synthetic");
-        }
-        if (what == "Exceptions") {
+                break;
+            case "Exceptions":
                 // Keep the exceptions normally.
                 // Although they have no effect on execution,
                 // the Reflection API exposes them, and JCK checks them.
                 strip("Exceptions");
-        }
-        if (what == "Constant") {
+                break;
+            case "Constant":
                 stripConstantFields();
+                break;
         }
     }
 
     public void trimToSize() {
         classes.trimToSize();
-        for (Iterator i = classes.iterator(); i.hasNext(); ) {
-            Class c = (Class)i.next();
+        for (Class c : classes) {
             c.trimToSize();
         }
         files.trimToSize();
     }
 
     public void strip(String attrName) {
-        for (Iterator i = classes.iterator(); i.hasNext(); ) {
-            Class c = (Class)i.next();
+        for (Class c : classes) {
             c.strip(attrName);
         }
     }
@@ -1166,10 +1165,9 @@ class Package implements Constants {
     }
 
     public void stripConstantFields() {
-        for (Iterator i = classes.iterator(); i.hasNext(); ) {
-            Class c = (Class) i.next();
-            for (Iterator j = c.fields.iterator(); j.hasNext(); ) {
-                Class.Field f = (Class.Field) j.next();
+        for (Class c : classes) {
+            for (Iterator<Class.Field> j = c.fields.iterator(); j.hasNext(); ) {
+                Class.Field f = j.next();
                 if (Modifier.isFinal(f.flags)
                     // do not strip non-static finals:
                     && Modifier.isStatic(f.flags)
@@ -1189,8 +1187,7 @@ class Package implements Constants {
             c.visitRefs(mode, refs);
         }
         if (mode != VRM_CLASSIC) {
-            for (Iterator i = files.iterator(); i.hasNext(); ) {
-                File f = (File)i.next();
+            for (File f : files) {
                 f.visitRefs(mode, refs);
             }
             visitInnerClassRefs(allInnerClasses, mode, refs);
@@ -1202,6 +1199,7 @@ class Package implements Constants {
     // compress better.  It also moves classes to the end of the
     // file order.  It also removes JAR directory entries, which
     // are useless.
+    @SuppressWarnings("unchecked")
     void reorderFiles(boolean keepClassOrder, boolean stripDirectories) {
         // First reorder the classes, if that is allowed.
         if (!keepClassOrder) {
@@ -1214,9 +1212,9 @@ class Package implements Constants {
         // modtimes and options are not transmitted, and the stub files
         // for class files do not need to be transmitted at all.
         // Also
-        List stubs = getClassStubs();
-        for (Iterator i = files.iterator(); i.hasNext(); ) {
-            File file = (File) i.next();
+        List<File> stubs = getClassStubs();
+        for (Iterator<File> i = files.iterator(); i.hasNext(); ) {
+            File file = i.next();
             if (file.isClassStub() ||
                 (stripDirectories && file.isDirectory())) {
                 i.remove();
@@ -1259,8 +1257,8 @@ class Package implements Constants {
 
     void trimStubs() {
         // Restore enough non-trivial stubs to carry the needed class modtimes.
-        for (ListIterator i = files.listIterator(files.size()); i.hasPrevious(); ) {
-            File file = (File) i.previous();
+        for (ListIterator<File> i = files.listIterator(files.size()); i.hasPrevious(); ) {
+            File file = i.previous();
             if (!file.isTrivialClassStub()) {
                 if (verbose > 1)
                     Utils.log.fine("Keeping last non-trivial "+file);
@@ -1309,7 +1307,7 @@ class Package implements Constants {
 
     // Use this before writing the class files.
     void ensureAllClassFiles() {
-        HashSet<File> fileSet = new HashSet<>(files);
+        Set<File> fileSet = new HashSet<>(files);
         for (Class cls : classes) {
             // Add to the end of ths list:
             if (!fileSet.contains(cls.file))
@@ -1317,8 +1315,8 @@ class Package implements Constants {
         }
     }
 
-    static final List noObjects = Arrays.asList(new Object[0]);
-    static final List noFields = Arrays.asList(new Class.Field[0]);
-    static final List noMethods = Arrays.asList(new Class.Method[0]);
-    static final List noInnerClasses = Arrays.asList(new InnerClass[0]);
+    static final List<Object> noObjects = Arrays.asList(new Object[0]);
+    static final List<Class.Field> noFields = Arrays.asList(new Class.Field[0]);
+    static final List<Class.Method> noMethods = Arrays.asList(new Class.Method[0]);
+    static final List<InnerClass> noInnerClasses = Arrays.asList(new InnerClass[0]);
 }

src/share/classes/com/sun/java/util/jar/pack/PackageReader.java

 /*
- * Copyright (c) 2001, 2005, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -32,11 +32,28 @@ import com.sun.java.util.jar.pack.ConstantPool.Index;
 import com.sun.java.util.jar.pack.ConstantPool.MemberEntry;
 import com.sun.java.util.jar.pack.ConstantPool.SignatureEntry;
 import com.sun.java.util.jar.pack.ConstantPool.Utf8Entry;
-import java.io.*;
-import java.util.*;
 import com.sun.java.util.jar.pack.Package.Class;
 import com.sun.java.util.jar.pack.Package.File;
 import com.sun.java.util.jar.pack.Package.InnerClass;
+import java.io.ByteArrayOutputStream;
+import java.io.EOFException;
+import java.io.PrintStream;
+import java.io.FilterInputStream;
+import java.io.BufferedInputStream;
+import java.io.InputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.Set;
+import static com.sun.java.util.jar.pack.Constants.*;
 
 /**
  * Reader for a package file.
@@ -418,7 +435,7 @@ class PackageReader extends BandStructure {
                 cp_Int.readFrom(in);
                 for (int i = 0; i < cpMap.length; i++) {
                     int x = cp_Int.getInt();  // coding handles signs OK
-                    cpMap[i] = ConstantPool.getLiteralEntry(new Integer(x));
+                    cpMap[i] = ConstantPool.getLiteralEntry(x);
                 }
                 cp_Int.doneDisbursing();
                 break;
@@ -428,7 +445,7 @@ class PackageReader extends BandStructure {
                 for (int i = 0; i < cpMap.length; i++) {
                     int x = cp_Float.getInt();
                     float fx = Float.intBitsToFloat(x);
-                    cpMap[i] = ConstantPool.getLiteralEntry(new Float(fx));
+                    cpMap[i] = ConstantPool.getLiteralEntry(fx);
                 }
                 cp_Float.doneDisbursing();
                 break;
@@ -444,7 +461,7 @@ class PackageReader extends BandStructure {
                     long hi = cp_Long_hi.getInt();
                     long lo = cp_Long_lo.getInt();
                     long x = (hi << 32) + ((lo << 32) >>> 32);
-                    cpMap[i] = ConstantPool.getLiteralEntry(new Long(x));
+                    cpMap[i] = ConstantPool.getLiteralEntry(x);
                 }
                 cp_Long_hi.doneDisbursing();
                 cp_Long_lo.doneDisbursing();
@@ -462,7 +479,7 @@ class PackageReader extends BandStructure {
                     long lo = cp_Double_lo.getInt();
                     long x = (hi << 32) + ((lo << 32) >>> 32);
                     double dx = Double.longBitsToDouble(x);
-                    cpMap[i] = ConstantPool.getLiteralEntry(new Double(dx));
+                    cpMap[i] = ConstantPool.getLiteralEntry(dx);
                 }
                 cp_Double_hi.doneDisbursing();
                 cp_Double_lo.doneDisbursing();
@@ -645,7 +662,7 @@ class PackageReader extends BandStructure {
         cp_Utf8_big_suffix.doneDisbursing();
     }
 
-    HashMap utf8Signatures;  // Utf8Entry->SignatureEntry
+    Map<Utf8Entry, SignatureEntry> utf8Signatures;
 
     void readSignatureBands(Entry[] cpMap) throws IOException {
         //  cp_Signature:
@@ -663,7 +680,7 @@ class PackageReader extends BandStructure {
         cp_Signature_classes.expectLength(getIntTotal(numSigClasses));
         cp_Signature_classes.readFrom(in);
         cp_Signature_classes.setIndex(getCPIndex(CONSTANT_Class));
-        utf8Signatures = new HashMap();
+        utf8Signatures = new HashMap<>();
         for (int i = 0; i < cpMap.length; i++) {
             Utf8Entry formRef = (Utf8Entry) cp_Signature_form.getRef();
             ClassEntry[] classRefs = new ClassEntry[numSigClasses[i]];
@@ -863,7 +880,7 @@ class PackageReader extends BandStructure {
         ic_name.expectLength(longICCount);
         ic_name.readFrom(in);
         ic_flags.resetForSecondPass();
-        ArrayList icList = new ArrayList(numInnerClasses);
+        List<InnerClass> icList = new ArrayList<>(numInnerClasses);
         for (int i = 0; i < numInnerClasses; i++) {
             int flags = ic_flags.getInt();
             boolean longForm = (flags & ACC_IC_LONG_FORM) != 0;
@@ -876,7 +893,7 @@ class PackageReader extends BandStructure {
                 thisName   = (Utf8Entry)  ic_name.getRef();
             } else {
                 String n = thisClass.stringValue();
-                String[] parse = pkg.parseInnerClassName(n);
+                String[] parse = Package.parseInnerClassName(n);
                 assert(parse != null);
                 String pkgOuter = parse[0];
                 //String number = parse[1];
@@ -905,7 +922,7 @@ class PackageReader extends BandStructure {
 
     void readLocalInnerClasses(Class cls) throws IOException {
         int nc = class_InnerClasses_N.getInt();
-        ArrayList localICs = new ArrayList(nc);
+        List<InnerClass> localICs = new ArrayList<>(nc);
         for (int i = 0; i < nc; i++) {
             ClassEntry thisClass = (ClassEntry) class_InnerClasses_RC.getRef();
             int        flags     =              class_InnerClasses_F.getInt();
@@ -994,10 +1011,8 @@ class PackageReader extends BandStructure {
         return -1;
     }
 
-    Comparator entryOutputOrder = new Comparator() {
-        public int compare(Object o0, Object o1) {
-            Entry e0 = (Entry) o0;
-            Entry e1 = (Entry) o1;
+    Comparator<Entry> entryOutputOrder = new Comparator<>() {
+        public int compare(Entry  e0, Entry e1) {
             int k0 = getOutputIndex(e0);
             int k1 = getOutputIndex(e1);
             if (k0 >= 0 && k1 >= 0)
@@ -1034,9 +1049,8 @@ class PackageReader extends BandStructure {
     }
 
     Entry[] reconstructLocalCPMap(Class cls) {
-        HashSet ldcRefs = (HashSet) ldcRefMap.get(cls);
-        HashSet cpRefs = new HashSet();
-        HashSet sigSet = new HashSet();
+        Set<Entry> ldcRefs = ldcRefMap.get(cls);
+        Set<Entry> cpRefs = new HashSet<>();
 
         // look for constant pool entries:
         cls.visitRefs(VRM_CLASSIC, cpRefs);
@@ -1064,8 +1078,7 @@ class PackageReader extends BandStructure {
 
         // construct a local constant pool
         int numDoubles = 0;
-        for (Iterator i = cpRefs.iterator(); i.hasNext(); ) {
-            Entry e = (Entry) i.next();
+        for (Entry e : cpRefs) {
             if (e.isDoubleWord())  numDoubles++;
             assert(e.tag != CONSTANT_Signature) : (e);
         }
@@ -1075,8 +1088,7 @@ class PackageReader extends BandStructure {
         // Add all ldc operands first.
         if (ldcRefs != null) {
             assert(cpRefs.containsAll(ldcRefs));
-            for (Iterator i = ldcRefs.iterator(); i.hasNext(); ) {
-                Entry e = (Entry) i.next();
+            for (Entry e : ldcRefs) {
                 cpMap[fillp++] = e;
             }
             assert(fillp == 1+ldcRefs.size());
@@ -1085,11 +1097,10 @@ class PackageReader extends BandStructure {
         }
 
         // Next add all the two-byte references.
-        HashSet wideRefs = cpRefs;
+        Set<Entry> wideRefs = cpRefs;
         cpRefs = null;  // do not use!
         int narrowLimit = fillp;
-        for (Iterator i = wideRefs.iterator(); i.hasNext(); ) {
-            Entry e = (Entry) i.next();
+        for (Entry e : wideRefs) {
             cpMap[fillp++] = e;
         }
         assert(fillp == narrowLimit+wideRefs.size());
@@ -1144,7 +1155,7 @@ class PackageReader extends BandStructure {
         method_descr.expectLength(totalNM);
         if (verbose > 1)  Utils.log.fine("expecting #fields="+totalNF+" and #methods="+totalNM+" in #classes="+numClasses);
 
-        ArrayList fields = new ArrayList(totalNF);
+        List<Class.Field> fields = new ArrayList<>(totalNF);
         field_descr.readFrom(in);
         for (int i = 0; i < classes.length; i++) {
             Class c = classes[i];
@@ -1160,7 +1171,7 @@ class PackageReader extends BandStructure {
         countAndReadAttrs(ATTR_CONTEXT_FIELD, fields);
         fields = null;  // release to GC
 
-        ArrayList methods = new ArrayList(totalNM);
+        List<Class.Method> methods = new ArrayList<>(totalNM);
         method_descr.readFrom(in);
         for (int i = 0; i < classes.length; i++) {
             Class c = classes[i];
@@ -1182,13 +1193,12 @@ class PackageReader extends BandStructure {
     }
 
     Code[] allCodes;
-    List codesWithFlags;
-    HashMap ldcRefMap = new HashMap();  // HashMap<Class, HashSet<Entry>>
+    List<Code> codesWithFlags;
+    Map<Class, Set<Entry>> ldcRefMap = new HashMap<>();
 
-    Code[] buildCodeAttrs(List methods) {
-        ArrayList codes = new ArrayList(methods.size());
-        for (Iterator i = methods.iterator(); i.hasNext(); ) {
-            Class.Method m = (Class.Method) i.next();
+    Code[] buildCodeAttrs(List<Class.Method> methods) {
+        List<Code> codes = new ArrayList<>(methods.size());
+        for (Class.Method m : methods) {
             if (m.getAttribute(attrCodeEmpty) != null) {
                 m.code = new Code(m);
                 codes.add(m.code);
@@ -1211,7 +1221,7 @@ class PackageReader extends BandStructure {
         boolean attrsOK = testBit(archiveOptions, AO_HAVE_ALL_CODE_FLAGS);
         code_headers.expectLength(allCodes.length);
         code_headers.readFrom(in);
-        ArrayList longCodes = new ArrayList(allCodes.length / 10);
+        List<Code> longCodes = new ArrayList<>(allCodes.length / 10);
         for (int i = 0; i < allCodes.length; i++) {
             Code c = allCodes[i];
             int sc = code_headers.getByte();
@@ -1238,8 +1248,7 @@ class PackageReader extends BandStructure {
         code_max_stack.readFrom(in);
         code_max_na_locals.readFrom(in);
         code_handler_count.readFrom(in);
-        for (Iterator i = longCodes.iterator(); i.hasNext(); ) {
-            Code c = (Code) i.next();
+        for (Code c : longCodes) {
             c.setMaxStack(     code_max_stack.getInt() );
             c.setMaxNALocals(  code_max_na_locals.getInt() );
             c.setHandlerCount( code_handler_count.getInt() );
@@ -1386,8 +1395,9 @@ class PackageReader extends BandStructure {
 
         // Fetch the attribute layout definitions which govern the bands
         // we are about to read.
-        Attribute.Layout[] defs = new Attribute.Layout[attrDefs[ctype].size()];
-        attrDefs[ctype].toArray(defs);
+        List<Attribute.Layout> defList = attrDefs.get(ctype);
+        Attribute.Layout[] defs = new Attribute.Layout[defList.size()];
+        defList.toArray(defs);
         IntBand xxx_flags_hi = getAttrBand(xxx_attr_bands, AB_FLAGS_HI);
         IntBand xxx_flags_lo = getAttrBand(xxx_attr_bands, AB_FLAGS_LO);
         IntBand xxx_attr_count = getAttrBand(xxx_attr_bands, AB_ATTR_COUNT);
@@ -1450,7 +1460,7 @@ class PackageReader extends BandStructure {
                 bits -= (1L<<ai);
                 nfa += 1;
             }
-            ArrayList ha = new ArrayList(nfa + noa);
+            List<Attribute> ha = new ArrayList<>(nfa + noa);
             h.attributes = ha;
             bits = attrBits;  // iterate again
             for (int ai = 0; bits != 0; ai++) {
@@ -1516,7 +1526,7 @@ class PackageReader extends BandStructure {
                 if (predef != isPredefinedAttr(ctype, ai))
                     continue;  // wrong pass
                 int totalCount = totalCounts[ai];
-                Band[] ab = (Band[]) attrBandTable.get(def);
+                Band[] ab = attrBandTable.get(def);
                 if (def == attrInnerClassesEmpty) {
                     // Special case.
                     // Size the bands as if using the following layout:
@@ -1571,15 +1581,16 @@ class PackageReader extends BandStructure {
                                    ATTR_CONTEXT_NAME[ctype]+" attribute");
     }
 
+    @SuppressWarnings("unchecked")
     void readAttrs(int ctype, Collection holders) throws IOException {
         // Decode band values into attributes.
-        HashSet sawDefs = new HashSet();
+        Set<Attribute.Layout> sawDefs = new HashSet<>();
         ByteArrayOutputStream buf = new ByteArrayOutputStream();
         for (Iterator i = holders.iterator(); i.hasNext(); ) {
             final Attribute.Holder h = (Attribute.Holder) i.next();
             if (h.attributes == null)  continue;
-            for (ListIterator j = h.attributes.listIterator(); j.hasNext(); ) {
-                Attribute a = (Attribute) j.next();
+            for (ListIterator<Attribute> j = h.attributes.listIterator(); j.hasNext(); ) {
+                Attribute a = j.next();
                 Attribute.Layout def = a.layout();
                 if (def.bandCount == 0) {
                     if (def == attrInnerClassesEmpty) {
@@ -1595,7 +1606,7 @@ class PackageReader extends BandStructure {
                 if (isCV)  setConstantValueIndex((Class.Field)h);
                 if (verbose > 2)
                     Utils.log.fine("read "+a+" in "+h);
-                final Band[] ab = (Band[]) attrBandTable.get(def);
+                final Band[] ab = attrBandTable.get(def);
                 // Read one attribute of type def from ab into a byte array.
                 buf.reset();
                 Object fixups = a.unparse(new Attribute.ValueStream() {
@@ -1617,10 +1628,9 @@ class PackageReader extends BandStructure {
         }
 
         // Mark the bands we just used as done disbursing.
-        for (Iterator i = sawDefs.iterator(); i.hasNext(); ) {
-            Attribute.Layout def = (Attribute.Layout) i.next();
+        for (Attribute.Layout def : sawDefs) {
             if (def == null)  continue;  // unused index
-            Band[] ab = (Band[]) attrBandTable.get(def);
+            Band[] ab = attrBandTable.get(def);
             for (int j = 0; j < ab.length; j++) {
                 ab[j].doneDisbursing();
             }
@@ -1778,7 +1788,7 @@ class PackageReader extends BandStructure {
         // scratch buffer for collecting code::
         byte[] buf = new byte[1<<12];
         // record of all switch opcodes (these are variable-length)
-        ArrayList allSwitchOps = new ArrayList();
+        List<Integer> allSwitchOps = new ArrayList<>();
         for (int k = 0; k < allCodes.length; k++) {
             Code c = allCodes[k];
         scanOneMethod:
@@ -1798,7 +1808,7 @@ class PackageReader extends BandStructure {
                 case _tableswitch:
                 case _lookupswitch:
                     bc_case_count.expectMoreLength(1);
-                    allSwitchOps.add(new Integer(bc));
+                    allSwitchOps.add(bc);
                     break;
                 case _iinc:
                     bc_local.expectMoreLength(1);
@@ -1866,8 +1876,8 @@ class PackageReader extends BandStructure {
 
         // To size instruction bands correctly, we need info on switches:
         bc_case_count.readFrom(in);
-        for (Iterator i = allSwitchOps.iterator(); i.hasNext(); ) {
-            int bc = ((Integer)i.next()).intValue();
+        for (Integer i : allSwitchOps) {
+            int bc = i.intValue();
             int caseCount = bc_case_count.getInt();
             bc_label.expectMoreLength(1+caseCount); // default label + cases
             bc_case_value.expectMoreLength(bc == _tableswitch ? 1 : caseCount);
@@ -1892,9 +1902,9 @@ class PackageReader extends BandStructure {
 
             Class curClass = code.thisClass();
 
-            HashSet ldcRefSet = (HashSet) ldcRefMap.get(curClass);
+            Set<Entry> ldcRefSet = ldcRefMap.get(curClass);
             if (ldcRefSet == null)
-                ldcRefMap.put(curClass, ldcRefSet = new HashSet());
+                ldcRefMap.put(curClass, ldcRefSet = new HashSet<>());
 
             ClassEntry thisClass  = curClass.thisClass;
             ClassEntry superClass = curClass.superClass;

src/share/classes/com/sun/java/util/jar/pack/PackageWriter.java

 /*
- * Copyright (c) 2001, 2005, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -45,10 +45,10 @@ import java.util.Arrays;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.HashSet;
-import java.util.Iterator;
 import java.util.List;
-import java.util.ListIterator;
 import java.util.Map;
+import java.util.Set;
+import static com.sun.java.util.jar.pack.Constants.*;
 
 /**
  * Writer for a package file.
@@ -111,12 +111,12 @@ class PackageWriter extends BandStructure {
         }
     }
 
-    HashSet     requiredEntries;  // for the CP
-    HashMap     backCountTable;   // for layout callables
+    Set<Entry>                       requiredEntries;  // for the CP
+    Map<Attribute.Layout, int[]>     backCountTable;   // for layout callables
     int[][]     attrCounts;       // count attr. occurences
 
     void setup() {
-        requiredEntries = new HashSet();
+        requiredEntries = new HashSet<>();
         setArchiveOptions();
         trimClassAttributes();
         collectAttributeLayouts();
@@ -139,9 +139,7 @@ class PackageWriter extends BandStructure {
         // Import defaults from package (deflate hint, etc.).
         archiveOptions |= pkg.default_options;
 
-        for (Iterator i = pkg.files.iterator(); i.hasNext(); ) {
-            File file = (File) i.next();
-
+        for (File file : pkg.files) {
             int modtime = file.modtime;
             int options = file.options;
 
@@ -178,16 +176,15 @@ class PackageWriter extends BandStructure {
             }
         }
         // Decide on default version number (majority rule).
-        HashMap verCounts = new HashMap();
+        Map<Integer, int[]> verCounts = new HashMap<>();
         int bestCount = 0;
         int bestVersion = -1;
-        for (Iterator i = pkg.classes.iterator(); i.hasNext(); ) {
-            Class cls = (Class) i.next();
+        for (Class cls : pkg.classes) {
             int version = cls.getVersion();
-            int[] var = (int[]) verCounts.get(new Integer(version));
+            int[] var = verCounts.get(version);
             if (var == null) {
                 var = new int[1];
-                verCounts.put(new Integer(version), var);
+                verCounts.put(version, var);
             }
             int count = (var[0] += 1);
             //System.out.println("version="+version+" count="+count);
@@ -210,9 +207,7 @@ class PackageWriter extends BandStructure {
                            Package.versionStringOf(pkg.getHighestClassVersion()));
 
         // Now add explicit pseudo-attrs. to classes with odd versions.
-        for (Iterator i = pkg.classes.iterator(); i.hasNext(); ) {
-            Class cls = (Class) i.next();
-
+        for (Class cls : pkg.classes) {
             if (cls.getVersion() != bestVersion) {
                 Attribute a = makeClassFileVersionAttr(cls.minver, cls.majver);
                 if (verbose > 1) {
@@ -228,8 +223,7 @@ class PackageWriter extends BandStructure {
         }
 
         // Decide if we are transmitting a huge resource file:
-        for (Iterator i = pkg.files.iterator(); i.hasNext(); ) {
-            File file = (File) i.next();
+        for (File file : pkg.files) {
             long len = file.getFileLength();
             if (len != (int)len) {
                 archiveOptions |= AO_HAVE_FILE_SIZE_HI;
@@ -244,10 +238,8 @@ class PackageWriter extends BandStructure {
         // we must declare unconditional presence of code flags.
         int cost0 = 0;
         int cost1 = 0;
-        for (Iterator i = pkg.classes.iterator(); i.hasNext(); ) {
-            Class cls = (Class) i.next();
-            for (Iterator j = cls.getMethods().iterator(); j.hasNext(); ) {
-                Class.Method m = (Class.Method) j.next();
+        for (Class cls : pkg.classes) {
+            for (Class.Method m : cls.getMethods()) {
                 if (m.code != null) {
                     if (m.code.attributeSize() == 0) {
                         // cost of a useless unconditional flags byte
@@ -352,7 +344,7 @@ class PackageWriter extends BandStructure {
             archive_header_1.putInt(pkg.default_modtime);
             archive_header_1.putInt(pkg.files.size());
         } else {
-            assert(pkg.files.size() == 0);
+            assert(pkg.files.isEmpty());
         }
 
         if (haveSpecial) {
@@ -697,8 +689,7 @@ class PackageWriter extends BandStructure {
         boolean haveModtime = testBit(options, AO_HAVE_FILE_MODTIME);
         boolean haveOptions = testBit(options, AO_HAVE_FILE_OPTIONS);
         if (!haveOptions) {
-            for (Iterator i = pkg.files.iterator(); i.hasNext(); ) {
-                File file = (File) i.next();
+            for (File file : pkg.files) {
                 if (file.isClassStub()) {
                     haveOptions = true;
                     options |= AO_HAVE_FILE_OPTIONS;
@@ -711,9 +702,7 @@ class PackageWriter extends BandStructure {
             options |= AO_HAVE_FILE_HEADERS;
             archiveOptions = options;
         }
-
-        for (Iterator i = pkg.files.iterator(); i.hasNext(); ) {
-            File file = (File) i.next();
+        for (File file : pkg.files) {
             file_name.putRef(file.name);
             long len = file.getFileLength();
             file_size_lo.putInt((int)len);
@@ -731,22 +720,20 @@ class PackageWriter extends BandStructure {
             Utils.log.info("Wrote "+numFiles+" resource files");
     }
 
+    @SuppressWarnings("unchecked")
     void collectAttributeLayouts() {
         maxFlags = new int[ATTR_CONTEXT_LIMIT];
-        allLayouts = new HashMap[ATTR_CONTEXT_LIMIT];
+        allLayouts = new FixedList<>(ATTR_CONTEXT_LIMIT);
         for (int i = 0; i < ATTR_CONTEXT_LIMIT; i++) {
-            allLayouts[i] = new HashMap();
+            allLayouts.set(i, new HashMap<Attribute.Layout, int[]>());
         }
         // Collect maxFlags and allLayouts.
-        for (Iterator i = pkg.classes.iterator(); i.hasNext(); ) {
-            Class cls = (Class) i.next();
+        for (Class cls : pkg.classes) {
             visitAttributeLayoutsIn(ATTR_CONTEXT_CLASS, cls);
-            for (Iterator j = cls.getFields().iterator(); j.hasNext(); ) {
-                Class.Field f = (Class.Field) j.next();
+            for (Class.Field f : cls.getFields()) {
                 visitAttributeLayoutsIn(ATTR_CONTEXT_FIELD, f);
             }
-            for (Iterator j = cls.getMethods().iterator(); j.hasNext(); ) {
-                Class.Method m = (Class.Method) j.next();
+            for (Class.Method m : cls.getMethods()) {
                 visitAttributeLayoutsIn(ATTR_CONTEXT_METHOD, m);
                 if (m.code != null) {
                     visitAttributeLayoutsIn(ATTR_CONTEXT_CODE, m.code);
@@ -755,7 +742,7 @@ class PackageWriter extends BandStructure {
         }
         // If there are many species of attributes, use 63-bit flags.
         for (int i = 0; i < ATTR_CONTEXT_LIMIT; i++) {
-            int nl = allLayouts[i].size();
+            int nl = allLayouts.get(i).size();
             boolean haveLongFlags = haveFlagsHi(i);
             final int TOO_MANY_ATTRS = 32 /*int flag size*/
                 - 12 /*typical flag bits in use*/
@@ -781,7 +768,7 @@ class PackageWriter extends BandStructure {
         }
         // Collect counts for both predefs. and custom defs.
         // Decide on custom, local attribute definitions.
-        backCountTable = new HashMap();
+        backCountTable = new HashMap<>();
         attrCounts = new int[ATTR_CONTEXT_LIMIT][];
         for (int i = 0; i < ATTR_CONTEXT_LIMIT; i++) {
             // Now the remaining defs in allLayouts[i] need attr. indexes.
@@ -793,11 +780,12 @@ class PackageWriter extends BandStructure {
             assert(attrIndexLimit[i] < 64);  // all bits fit into a Java long
             avHiBits &= (1L<<attrIndexLimit[i])-1;
             int nextLoBit = 0;
-            Map.Entry[] layoutsAndCounts = new Map.Entry[allLayouts[i].size()];
-            allLayouts[i].entrySet().toArray(layoutsAndCounts);
+            Map<Attribute.Layout, int[]> defMap = allLayouts.get(i);
+            Map.Entry[] layoutsAndCounts = new Map.Entry[defMap.size()];
+            defMap.entrySet().toArray(layoutsAndCounts);
             // Sort by count, most frequent first.
             // Predefs. participate in this sort, though it does not matter.
-            Arrays.sort(layoutsAndCounts, new Comparator() {
+            Arrays.sort(layoutsAndCounts, new Comparator<>() {
                 public int compare(Object o0, Object o1) {
                     Map.Entry e0 = (Map.Entry) o0;
                     Map.Entry e1 = (Map.Entry) o1;
@@ -814,7 +802,7 @@ class PackageWriter extends BandStructure {
                 Attribute.Layout def = (Attribute.Layout) e.getKey();
                 int count = ((int[])e.getValue())[0];
                 int index;
-                Integer predefIndex = (Integer) attrIndexTable.get(def);
+                Integer predefIndex = attrIndexTable.get(def);
                 if (predefIndex != null) {
                     // The index is already set.
                     index = predefIndex.intValue();
@@ -872,29 +860,32 @@ class PackageWriter extends BandStructure {
 
     // Scratch variables for processing attributes and flags.
     int[] maxFlags;
-    HashMap[] allLayouts;
+    List<Map<Attribute.Layout, int[]>> allLayouts;
 
     void visitAttributeLayoutsIn(int ctype, Attribute.Holder h) {
         // Make note of which flags appear in the class file.
         // Set them in maxFlags.
         maxFlags[ctype] |= h.flags;
-        for (Iterator i = h.getAttributes().iterator(); i.hasNext(); ) {
-            Attribute a = (Attribute) i.next();
+        for (Attribute a : h.getAttributes()) {
             Attribute.Layout def = a.layout();
-            int[] count = (int[]) allLayouts[ctype].get(def);
-            if (count == null)
-                allLayouts[ctype].put(def, count = new int[1]);
-            if (count[0] < Integer.MAX_VALUE)
+            Map<Attribute.Layout, int[]> defMap = allLayouts.get(ctype);
+            int[] count = defMap.get(def);
+            if (count == null) {
+                defMap.put(def, count = new int[1]);
+            }
+            if (count[0] < Integer.MAX_VALUE) {
                 count[0] += 1;
             }
         }
+    }
 
     Attribute.Layout[] attrDefsWritten;
 
+    @SuppressWarnings("unchecked")
     void writeAttrDefs() throws IOException {
-        ArrayList defList = new ArrayList();
+        List<Object[]> defList = new ArrayList<>();
         for (int i = 0; i < ATTR_CONTEXT_LIMIT; i++) {
-            int limit = attrDefs[i].size();
+            int limit = attrDefs.get(i).size();
             for (int j = 0; j < limit; j++) {
                 int header = i;  // ctype
                 if (j < attrIndexLimit[i]) {
@@ -906,9 +897,9 @@ class PackageWriter extends BandStructure {
                         continue;
                     }
                 }
-                Attribute.Layout def = (Attribute.Layout) attrDefs[i].get(j);
-                defList.add(new Object[]{ new Integer(header), def });
-                assert(new Integer(j).equals(attrIndexTable.get(def)));
+                Attribute.Layout def = attrDefs.get(i).get(j);
+                defList.add(new Object[]{ Integer.valueOf(header), def });
+                assert(Integer.valueOf(j).equals(attrIndexTable.get(def)));
             }
         }
         // Sort the new attr defs into some "natural" order.
@@ -934,10 +925,7 @@ class PackageWriter extends BandStructure {
         attrDefsWritten = new Attribute.Layout[numAttrDefs];
         PrintStream dump = !optDumpBands ? null
             : new PrintStream(getDumpStream(attr_definition_headers, ".def"));
-        int[] indexForDebug = new int[ATTR_CONTEXT_LIMIT];
-        for (int i = 0; i < ATTR_CONTEXT_LIMIT; i++) {
-            indexForDebug[i] = attrIndexLimit[i];
-        }
+        int[] indexForDebug = Arrays.copyOf(attrIndexLimit, ATTR_CONTEXT_LIMIT);
         for (int i = 0; i < defs.length; i++) {
             int header = ((Integer)defs[i][0]).intValue();
             Attribute.Layout def = (Attribute.Layout) defs[i][1];
@@ -953,7 +941,7 @@ class PackageWriter extends BandStructure {
             if (debug) {
                 int hdrIndex = (header >> ADH_BIT_SHIFT) - ADH_BIT_IS_LSB;
                 if (hdrIndex < 0)  hdrIndex = indexForDebug[def.ctype()]++;
-                int realIndex = ((Integer) attrIndexTable.get(def)).intValue();
+                int realIndex = (attrIndexTable.get(def)).intValue();
                 assert(hdrIndex == realIndex);
             }
             if (dump != null) {
@@ -969,8 +957,8 @@ class PackageWriter extends BandStructure {
         for (int ctype = 0; ctype < ATTR_CONTEXT_LIMIT; ctype++) {
             MultiBand xxx_attr_bands = attrBands[ctype];
             IntBand xxx_attr_calls = getAttrBand(xxx_attr_bands, AB_ATTR_CALLS);
-            Attribute.Layout[] defs = new Attribute.Layout[attrDefs[ctype].size()];
-            attrDefs[ctype].toArray(defs);
+            Attribute.Layout[] defs = new Attribute.Layout[attrDefs.get(ctype).size()];
+            attrDefs.get(ctype).toArray(defs);
             for (boolean predef = true; ; predef = false) {
                 for (int ai = 0; ai < defs.length; ai++) {
                     Attribute.Layout def = defs[ai];
@@ -980,7 +968,7 @@ class PackageWriter extends BandStructure {
                     int totalCount = attrCounts[ctype][ai];
                     if (totalCount == 0)
                         continue;  // irrelevant
-                    int[] bc = (int[]) backCountTable.get(def);
+                    int[] bc = backCountTable.get(def);
                     for (int j = 0; j < bc.length; j++) {
                         if (bc[j] >= 0) {
                             int backCount = bc[j];
@@ -998,8 +986,7 @@ class PackageWriter extends BandStructure {
     }
 
     void trimClassAttributes() {
-        for (Iterator i = pkg.classes.iterator(); i.hasNext(); ) {
-            Class cls = (Class) i.next();
+        for (Class cls : pkg.classes) {
             // Replace "obvious" SourceFile attrs by null.
             cls.minimizeSourceFile();
         }
@@ -1008,14 +995,12 @@ class PackageWriter extends BandStructure {
     void collectInnerClasses() {
         // Capture inner classes, removing them from individual classes.
         // Irregular inner classes must stay local, though.
-        HashMap allICMap = new HashMap();
+        Map<ClassEntry, InnerClass> allICMap = new HashMap<>();
         // First, collect a consistent global set.
-        for (Iterator i = pkg.classes.iterator(); i.hasNext(); ) {
-            Class cls = (Class) i.next();
+        for (Class cls : pkg.classes) {
             if (!cls.hasInnerClasses())  continue;
-            for (Iterator j = cls.getInnerClasses().iterator(); j.hasNext(); ) {
-                InnerClass ic = (InnerClass) j.next();
-                InnerClass pic = (InnerClass) allICMap.put(ic.thisClass, ic);
+            for (InnerClass ic : cls.getInnerClasses()) {
+                InnerClass pic = allICMap.put(ic.thisClass, ic);
                 if (pic != null && !pic.equals(ic) && pic.predictable) {
                     // Different ICs.  Choose the better to make global.
                     allICMap.put(pic.thisClass, pic);
@@ -1036,15 +1021,13 @@ class PackageWriter extends BandStructure {
         // Next, empty out of every local set the consistent entries.
         // Calculate whether there is any remaining need to have a local
         // set, and whether it needs to be locked.
-        for (Iterator i = pkg.classes.iterator(); i.hasNext(); ) {
-            Class cls = (Class) i.next();
+        for (Class cls : pkg.classes) {
             cls.minimizeLocalICs();
         }
     }
 
     void writeInnerClasses() throws IOException {
-        for (Iterator i = pkg.getAllInnerClasses().iterator(); i.hasNext(); ) {
-            InnerClass ic = (InnerClass) i.next();
+        for (InnerClass ic : pkg.getAllInnerClasses()) {
             int flags = ic.flags;
             assert((flags & ACC_IC_LONG_FORM) == 0);
             if (!ic.predictable) {
@@ -1064,10 +1047,9 @@ class PackageWriter extends BandStructure {
      *  local attribute.  This is expected to be rare.
      */
     void writeLocalInnerClasses(Class cls) throws IOException {
-        List localICs = cls.getInnerClasses();
+        List<InnerClass> localICs = cls.getInnerClasses();
         class_InnerClasses_N.putInt(localICs.size());
-        for (Iterator i = localICs.iterator(); i.hasNext(); ) {
-            InnerClass ic = (InnerClass) i.next();
+        for(InnerClass ic : localICs) {
             class_InnerClasses_RC.putRef(ic.thisClass);
             // Is it redundant with the global version?
             if (ic.equals(pkg.getGlobalInnerClass(ic.thisClass))) {
@@ -1121,18 +1103,16 @@ class PackageWriter extends BandStructure {
     }
 
     void writeMembers(Class cls) throws IOException {
-        List fields = cls.getFields();
+        List<Class.Field> fields = cls.getFields();
         class_field_count.putInt(fields.size());
-        for (Iterator i = fields.iterator(); i.hasNext(); ) {
-            Class.Field f = (Class.Field) i.next();
+        for (Class.Field f : fields) {
             field_descr.putRef(f.getDescriptor());
             writeAttrs(ATTR_CONTEXT_FIELD, f, cls);
         }
 
-        List methods = cls.getMethods();
+        List<Class.Method> methods = cls.getMethods();
         class_method_count.putInt(methods.size());
-        for (Iterator i = methods.iterator(); i.hasNext(); ) {
-            Class.Method m = (Class.Method) i.next();
+        for (Class.Method m : methods) {
             method_descr.putRef(m.getDescriptor());
             writeAttrs(ATTR_CONTEXT_METHOD, m, cls);
             assert((m.code != null) == (m.getAttribute(attrCodeEmpty) != null));
@@ -1206,11 +1186,10 @@ class PackageWriter extends BandStructure {
         long flagMask = attrFlagMask[ctype];  // which flags are attr bits?
         long flagsToAdd = 0;
         int overflowCount = 0;
-        for (ListIterator j = h.attributes.listIterator(); j.hasNext(); ) {
-            Attribute a = (Attribute) j.next();
+        for (Attribute a : h.attributes) {
             Attribute.Layout def = a.layout();
-            int index = ((Integer)attrIndexTable.get(def)).intValue();
-            assert(attrDefs[ctype].get(index) == def);
+            int index = (attrIndexTable.get(def)).intValue();
+            assert(attrDefs.get(ctype).get(index) == def);
             if (verbose > 3)
                 Utils.log.fine("add attr @"+index+" "+a+" in "+h);
             if (index < attrIndexLimit[ctype] && testBit(flagMask, 1L<<index)) {
@@ -1239,10 +1218,10 @@ class PackageWriter extends BandStructure {
                 continue;
             }
             assert(a.fixups == null);
-            final Band[] ab = (Band[]) attrBandTable.get(def);
+            final Band[] ab = attrBandTable.get(def);
             assert(ab != null);
             assert(ab.length == def.bandCount);
-            final int[] bc = (int[]) backCountTable.get(def);
+            final int[] bc = backCountTable.get(def);
             assert(bc != null);
             assert(bc.length == def.getCallables().length);
             // Write one attribute of type def into ab.
@@ -1306,7 +1285,7 @@ class PackageWriter extends BandStructure {
     private int initOpVariant(Instruction i, Entry newClass) {
         if (i.getBC() != _invokespecial)  return -1;
         MemberEntry ref = (MemberEntry) i.getCPRef(curCPMap);
-        if (ref.descRef.nameRef.stringValue() != "<init>")
+        if ("<init>".equals(ref.descRef.nameRef.stringValue()) == false)
             return -1;
         ClassEntry refClass = ref.classRef;
         if (refClass == curClass.thisClass)
@@ -1618,14 +1597,16 @@ class PackageWriter extends BandStructure {
             String count = "" + codeHist[bc];
             count = "         ".substring(count.length()) + count;
             String pct = "" + (codeHist[bc] * 10000 / totalBytes);
-            while (pct.length() < 4)  pct = "0" + pct;
+            while (pct.length() < 4) {
+                pct = "0" + pct;
+            }
             pct = pct.substring(0, pct.length()-2) + "." + pct.substring(pct.length()-2);
             hist[bc] = count + "  " + pct + "%  " + iname;
         }
         Arrays.sort(hist);
         System.out.println("Bytecode histogram ["+totalBytes+"]");
         for (int i = hist.length; --i >= 0; ) {
-            if (hist[i] == "")  continue;
+            if ("".equals(hist[i]))  continue;
             System.out.println(hist[i]);
         }
         for (int tag = 0; tag < ldcHist.length; tag++) {

src/share/classes/com/sun/java/util/jar/pack/PackerImpl.java

@@ -69,7 +69,8 @@ public class PackerImpl  extends TLGlobals implements Pack200.Packer {
      * Get the set of options for the pack and unpack engines.
      * @return A sorted association of option key strings to option values.
      */
-    public SortedMap<String, String> properties() {
+    @SuppressWarnings("unchecked")
+    public SortedMap properties() {
         return props;
     }
 
@@ -155,8 +156,8 @@ public class PackerImpl  extends TLGlobals implements Pack200.Packer {
 
 
     // All the worker bees.....
-
     // The packer worker.
+    @SuppressWarnings("unchecked")
     private class DoPack {
         final int verbose = props.getInteger(Utils.DEBUG_VERBOSE);
 
@@ -179,11 +180,11 @@ public class PackerImpl  extends TLGlobals implements Pack200.Packer {
             unknownAttrCommand = uaMode.intern();
         }
 
-        final HashMap attrDefs;
-        final HashMap attrCommands;
+        final Map<Attribute.Layout, Attribute> attrDefs;
+        final Map<Attribute.Layout, String> attrCommands;
         {
-            HashMap attrDefs     = new HashMap();
-            HashMap attrCommands = new HashMap();
+            Map<Attribute.Layout, Attribute> lattrDefs   = new HashMap<>();
+            Map<Attribute.Layout, String>  lattrCommands = new HashMap<>();
             String[] keys = {
                 Pack200.Packer.CLASS_ATTRIBUTE_PFX,
                 Pack200.Packer.FIELD_ATTRIBUTE_PFX,
@@ -198,8 +199,9 @@ public class PackerImpl  extends TLGlobals implements Pack200.Packer {
             };
             for (int i = 0; i < ctypes.length; i++) {
                 String pfx = keys[i];
-                Map<String, String> map = props.prefixMap(pfx);
-                for (String key : map.keySet()) {
+                Map<Object, Object> map = props.prefixMap(pfx);
+                for (Object k : map.keySet()) {
+                    String key = (String)k;
                     assert(key.startsWith(pfx));
                     String name = key.substring(pfx.length());
                     String layout = props.getProperty(key);
@@ -207,24 +209,18 @@ public class PackerImpl  extends TLGlobals implements Pack200.Packer {
                     if (Pack200.Packer.STRIP.equals(layout) ||
                         Pack200.Packer.PASS.equals(layout) ||
                         Pack200.Packer.ERROR.equals(layout)) {
-                        attrCommands.put(lkey, layout.intern());
+                        lattrCommands.put(lkey, layout.intern());
                     } else {
-                        Attribute.define(attrDefs, ctypes[i], name, layout);
+                        Attribute.define(lattrDefs, ctypes[i], name, layout);
                         if (verbose > 1) {
                             Utils.log.fine("Added layout for "+Constants.ATTR_CONTEXT_NAME[i]+" attribute "+name+" = "+layout);
                         }
-                        assert(attrDefs.containsKey(lkey));
+                        assert(lattrDefs.containsKey(lkey));
                     }
                 }
             }
-            if (attrDefs.size() > 0)
-                this.attrDefs = attrDefs;
-            else
-                this.attrDefs = null;
-            if (attrCommands.size() > 0)
-                this.attrCommands = attrCommands;
-            else
-                this.attrCommands = null;
+            this.attrDefs = (lattrDefs.isEmpty()) ? null : lattrDefs;
+            this.attrCommands = (lattrCommands.isEmpty()) ? null : lattrCommands;
         }
 
         final boolean keepFileOrder
@@ -275,8 +271,8 @@ public class PackerImpl  extends TLGlobals implements Pack200.Packer {
         {
             // Which class files will be passed through?
             passFiles = props.getProperties(Pack200.Packer.PASS_FILE_PFX);
-            for (ListIterator i = passFiles.listIterator(); i.hasNext(); ) {
-                String file = (String) i.next();
+            for (ListIterator<String> i = passFiles.listIterator(); i.hasNext(); ) {
+                String file = i.next();
                 if (file == null) { i.remove(); continue; }
                 file = Utils.getJarEntryName(file);  // normalize '\\' to '/'
                 if (file.endsWith("/"))
@@ -333,7 +329,7 @@ public class PackerImpl  extends TLGlobals implements Pack200.Packer {
             pkg.reset();
         }
 
-        class InFile {
+        final class InFile {
             final String name;
             final JarFile jf;
             final JarEntry je;
@@ -596,8 +592,8 @@ public class PackerImpl  extends TLGlobals implements Pack200.Packer {
                 // Package builder must have created a stub for each class.
                 assert(pkg.files.containsAll(pkg.getClassStubs()));
                 // Order of stubs in file list must agree with classes.
-                List res = pkg.files;
-                assert((res = new ArrayList(pkg.files))
+                List<Package.File> res = pkg.files;
+                assert((res = new ArrayList<>(pkg.files))
                        .retainAll(pkg.getClassStubs()) || true);
                 assert(res.equals(pkg.getClassStubs()));
             }

src/share/classes/com/sun/java/util/jar/pack/PopulationCoding.java

 /*
- * Copyright (c) 2003, 2005, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -31,6 +31,8 @@ import java.io.InputStream;
 import java.io.OutputStream;
 import java.util.Arrays;
 import java.util.HashSet;
+import java.util.Set;
+import static com.sun.java.util.jar.pack.Constants.*;
 
 /**
  * Population-based coding.
@@ -38,7 +40,7 @@ import java.util.HashSet;
  * @author John Rose
  */
 // This tactic alone reduces the final zipped rt.jar by about a percent.
-class PopulationCoding implements Constants, CodingMethod {
+class PopulationCoding implements CodingMethod {
     Histogram vHist;   // histogram of all values
     int[]     fValues; // list of favored values
     int       fVlen;   // inclusive max index
@@ -62,8 +64,8 @@ class PopulationCoding implements Constants, CodingMethod {
         }
     }
     public void setFavoredValues(int[] fValues) {
-        int fVlen = fValues.length-1;
-        setFavoredValues(fValues, fVlen);
+        int lfVlen = fValues.length-1;
+        setFavoredValues(fValues, lfVlen);
     }
     public void setHistogram(Histogram vHist) {
         this.vHist = vHist;
@@ -103,7 +105,7 @@ class PopulationCoding implements Constants, CodingMethod {
         if (tokenCoding instanceof Coding && fValues != null) {
             Coding tc = (Coding) tokenCoding;
             if (tc == fitTokenCoding(fVlen, tc.L()))
-                this.L = tc.L();;
+                this.L = tc.L();
             // Otherwise, it's a non-default coding.
         }
     }
@@ -217,13 +219,13 @@ class PopulationCoding implements Constants, CodingMethod {
     }
 
     private long[] makeSymtab() {
-        long[] symtab = new long[fVlen];
+        long[] lsymtab = new long[fVlen];
         for (int token = 1; token <= fVlen; token++) {
-            symtab[token-1] = ((long)fValues[token] << 32) | token;
+            lsymtab[token-1] = ((long)fValues[token] << 32) | token;
         }
         // Index by value:
-        Arrays.sort(symtab);
-        return symtab;
+        Arrays.sort(lsymtab);
+        return lsymtab;
     }
 
     private Coding getTailCoding(CodingMethod c) {
@@ -302,12 +304,12 @@ class PopulationCoding implements Constants, CodingMethod {
     }
 
     int[] readFavoredValuesFrom(InputStream in, int maxForDebug) throws IOException {
-        int[] fValues = new int[1000];  // realloc as needed
+        int[] lfValues = new int[1000];  // realloc as needed
         // The set uniqueValuesForDebug records all favored values.
         // As each new value is added, we assert that the value
         // was not already in the set.
-        HashSet uniqueValuesForDebug = null;
-        assert((uniqueValuesForDebug = new HashSet()) != null);
+        Set<Integer> uniqueValuesForDebug = null;
+        assert((uniqueValuesForDebug = new HashSet<>()) != null);
         int fillp = 1;
         maxForDebug += fillp;
         int min = Integer.MIN_VALUE;  // farthest from the center
@@ -317,13 +319,14 @@ class PopulationCoding implements Constants, CodingMethod {
         while (fcm instanceof AdaptiveCoding) {
             AdaptiveCoding ac = (AdaptiveCoding) fcm;
             int len = ac.headLength;
-            while (fillp + len > fValues.length)
-                fValues = BandStructure.realloc(fValues);
+            while (fillp + len > lfValues.length) {
+                lfValues = BandStructure.realloc(lfValues);
+            }
             int newFillp = fillp + len;
-            ac.headCoding.readArrayFrom(in, fValues, fillp, newFillp);
+            ac.headCoding.readArrayFrom(in, lfValues, fillp, newFillp);
             while (fillp < newFillp) {
-                int val = fValues[fillp++];
-                assert(uniqueValuesForDebug.add(new Integer(val)));
+                int val = lfValues[fillp++];
+                assert(uniqueValuesForDebug.add(val));
                 assert(fillp <= maxForDebug);
                 last = val;
                 min = moreCentral(min, val);
@@ -344,10 +347,10 @@ class PopulationCoding implements Constants, CodingMethod {
                 state = val;
                 if (fillp > 1 && (val == last || val == min)) //|| val == min2
                     break;
-                if (fillp == fValues.length)
-                    fValues = BandStructure.realloc(fValues);
-                fValues[fillp++] = val;
-                assert(uniqueValuesForDebug.add(new Integer(val)));
+                if (fillp == lfValues.length)
+                    lfValues = BandStructure.realloc(lfValues);
+                lfValues[fillp++] = val;
+                assert(uniqueValuesForDebug.add(val));
                 assert(fillp <= maxForDebug);
                 last = val;
                 min = moreCentral(min, val);
@@ -358,17 +361,17 @@ class PopulationCoding implements Constants, CodingMethod {
                 int val = fc.readFrom(in);
                 if (fillp > 1 && (val == last || val == min)) //|| val == min2
                     break;
-                if (fillp == fValues.length)
-                    fValues = BandStructure.realloc(fValues);
-                fValues[fillp++] = val;
-                assert(uniqueValuesForDebug.add(new Integer(val)));
+                if (fillp == lfValues.length)
+                    lfValues = BandStructure.realloc(lfValues);
+                lfValues[fillp++] = val;
+                assert(uniqueValuesForDebug.add(val));
                 assert(fillp <= maxForDebug);
                 last = val;
                 min = moreCentral(min, val);
                 //min2 = moreCentral2(min2, val, min);
             }
         }
-        return BandStructure.realloc(fValues, fillp);
+        return BandStructure.realloc(lfValues, fillp);
     }
 
     private static int moreCentral(int x, int y) {
@@ -478,7 +481,7 @@ class PopulationCoding implements Constants, CodingMethod {
         boolean verbose
             = (p200 != null &&
                p200.getBoolean(Utils.COM_PREFIX+"verbose.pop"));
-        StringBuffer res = new StringBuffer(100);
+        StringBuilder res = new StringBuilder(100);
         res.append("pop(").append("fVlen=").append(fVlen);
         if (verbose && fValues != null) {
             res.append(" fV=[");

src/share/classes/com/sun/java/util/jar/pack/PropMap.java

 /*
- * Copyright (c) 2003,2010 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -34,8 +34,8 @@ import java.io.PrintStream;
 import java.io.PrintWriter;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Comparator;
 import java.util.HashMap;
-import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Properties;
@@ -46,36 +46,36 @@ import java.util.jar.Pack200;
 /**
  * Control block for publishing Pack200 options to the other classes.
  */
-class PropMap extends TreeMap {
-    ArrayList _listeners = new ArrayList(1);
+
+final class PropMap implements SortedMap<Object, Object>  {
+    private final TreeMap<Object, Object> theMap = new TreeMap<>();;
+    private final List<PropertyChangeListener> listenerList = new ArrayList<>(1);
 
     void addListener(PropertyChangeListener listener) {
-        _listeners.add(listener);
+        listenerList.add(listener);
     }
 
     void removeListener(PropertyChangeListener listener) {
-        _listeners.remove(listener);
+        listenerList.remove(listener);
     }
 
-    void addListeners(ArrayList listeners) {
-        _listeners.addAll(listeners);
+    void addListeners(ArrayList<PropertyChangeListener> listeners) {
+        listenerList.addAll(listeners);
     }
 
-    void removeListeners(ArrayList listeners) {
-        _listeners.removeAll(listeners);
+    void removeListeners(ArrayList<PropertyChangeListener> listeners) {
+        listenerList.removeAll(listeners);
     }
 
     // Override:
     public Object put(Object key, Object value) {
-        Object oldValue = super.put(key, value);
-        if (value != oldValue && _listeners.size() > 0) {
+        Object oldValue = theMap.put(key, value);
+        if (value != oldValue && !listenerList.isEmpty()) {
             // Post the property change event.
             PropertyChangeEvent event =
                 new PropertyChangeEvent(this, (String) key,
                                         oldValue, value);
-            for (Iterator i = _listeners.iterator(); i.hasNext(); ) {
-                PropertyChangeListener listener =
-                    (PropertyChangeListener) i.next();
+            for (PropertyChangeListener listener : listenerList) {
                 listener.propertyChange(event);
             }
         }
@@ -85,7 +85,7 @@ class PropMap extends TreeMap {
     // All this other stuff is private to the current package.
     // Outide clients of Pack200 do not need to use it; they can
     // get by with generic SortedMap functionality.
-    private static Map defaultProps;
+    private static Map<Object, Object> defaultProps;
     static {
         Properties props = new Properties();
 
@@ -122,13 +122,12 @@ class PropMap extends TreeMap {
         // Define certain attribute layouts by default.
         // Do this after the previous props are put in place,
         // to allow override if necessary.
+        InputStream propStr = null;
         try {
             String propFile = "intrinsic.properties";
-            InputStream propStr = PackerImpl.class.getResourceAsStream(propFile);
+            propStr = PackerImpl.class.getResourceAsStream(propFile);
             props.load(new BufferedInputStream(propStr));
-            propStr.close();
-            for (Iterator i = props.entrySet().iterator(); i.hasNext(); ) {
-                Map.Entry e = (Map.Entry) i.next();
+            for (Map.Entry<Object, Object> e : props.entrySet()) {
                 String key = (String) e.getKey();
                 String val = (String) e.getValue();
                 if (key.startsWith("attribute.")) {
@@ -137,19 +136,25 @@ class PropMap extends TreeMap {
             }
         } catch (IOException ee) {
             throw new RuntimeException(ee);
+        } finally {
+            try {
+                if (propStr != null) {
+                    propStr.close();
+                }
+            } catch (IOException ignore) {}
         }
 
-        defaultProps = (new HashMap(props));  // shrink to fit
+        defaultProps = (new HashMap<>(props));  // shrink to fit
     }
 
     PropMap() {
-        putAll(defaultProps);
+        theMap.putAll(defaultProps);
     }
 
     // Return a view of this map which includes only properties
     // that begin with the given prefix.  This is easy because
     // the map is sorted, and has a subMap accessor.
-    SortedMap prefixMap(String prefix) {
+    SortedMap<Object, Object> prefixMap(String prefix) {
         int len = prefix.length();
         if (len == 0)
             return this;
@@ -174,8 +179,8 @@ class PropMap extends TreeMap {
 
     // Get sequence of props for "prefix", and "prefix.*".
     List getProperties(String prefix) {
-        Collection values = prefixMap(prefix).values();
-        ArrayList res = new ArrayList(values.size());
+        Collection<Object> values = prefixMap(prefix).values();
+        List<Object> res = new ArrayList<>(values.size());
         res.addAll(values);
         while (res.remove(null));
         return res;
@@ -240,11 +245,97 @@ class PropMap extends TreeMap {
     void list(PrintWriter out) {
         out.println("#"+Utils.PACK_ZIP_ARCHIVE_MARKER_COMMENT+"[");
         Set defaults = defaultProps.entrySet();
-        for (Iterator i = entrySet().iterator(); i.hasNext(); ) {
-            Map.Entry e = (Map.Entry) i.next();
+        for (Map.Entry e : theMap.entrySet()) {
             if (defaults.contains(e))  continue;
             out.println("  " + e.getKey() + " = " + e.getValue());
         }
         out.println("#]");
     }
+
+    @Override
+    public int size() {
+        return theMap.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return theMap.isEmpty();
+    }
+
+    @Override
+    public boolean containsKey(Object key) {
+        return theMap.containsKey(key);
+    }
+
+    @Override
+    public boolean containsValue(Object value) {
+        return theMap.containsValue(value);
+    }
+
+    @Override
+    public Object get(Object key) {
+        return theMap.get(key);
+    }
+
+    @Override
+    public Object remove(Object key) {
+       return theMap.remove(key);
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public void putAll(Map m) {
+       theMap.putAll(m);
+    }
+
+    @Override
+    public void clear() {
+        theMap.clear();
+    }
+
+    @Override
+    public Set<Object> keySet() {
+       return theMap.keySet();
+    }
+
+    @Override
+    public Collection<Object> values() {
+       return theMap.values();
+    }
+
+    @Override
+    public Set<Map.Entry<Object, Object>> entrySet() {
+        return theMap.entrySet();
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public Comparator<Object> comparator() {
+        return (Comparator<Object>) theMap.comparator();
+    }
+
+    @Override
+    public SortedMap<Object, Object> subMap(Object fromKey, Object toKey) {
+        return theMap.subMap(fromKey, toKey);
+    }
+
+    @Override
+    public SortedMap<Object, Object> headMap(Object toKey) {
+        return theMap.headMap(toKey);
+    }
+
+    @Override
+    public SortedMap<Object, Object> tailMap(Object fromKey) {
+        return theMap.tailMap(fromKey);
+    }
+
+    @Override
+    public Object firstKey() {
+        return theMap.firstKey();
+    }
+
+    @Override
+    public Object lastKey() {
+       return theMap.lastKey();
+    }
 }

src/share/classes/com/sun/java/util/jar/pack/UnpackerImpl.java

@@ -34,7 +34,7 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.util.HashSet;
-import java.util.Iterator;
+import java.util.Set;
 import java.util.SortedMap;
 import java.util.TimeZone;
 import java.util.jar.JarEntry;
@@ -81,7 +81,8 @@ public class UnpackerImpl extends TLGlobals implements Pack200.Unpacker {
      * Get the set of options for the pack and unpack engines.
      * @return A sorted association of option key strings to option values.
      */
-    public SortedMap<String, String> properties() {
+    @SuppressWarnings("unchecked")
+    public SortedMap properties() {
         return props;
     }
 
@@ -225,9 +226,8 @@ public class UnpackerImpl extends TLGlobals implements Pack200.Unpacker {
             props.setProperty(java.util.jar.Pack200.Unpacker.PROGRESS,"50");
             pkg.ensureAllClassFiles();
             // Now write out the files.
-            HashSet<Package.Class> classesToWrite = new HashSet<>(pkg.getClasses());
-            for (Iterator i = pkg.getFiles().iterator(); i.hasNext(); ) {
-                Package.File file = (Package.File) i.next();
+            Set<Package.Class> classesToWrite = new HashSet<>(pkg.getClasses());
+            for (Package.File file : pkg.getFiles()) {
                 String name = file.nameString;
                 JarEntry je = new JarEntry(Utils.getJarEntryName(name));
                 boolean deflate;

src/share/classes/com/sun/java/util/jar/pack/Utils.java

@@ -297,7 +297,7 @@ class Utils {
             (int)( (1.0 - ((double)ze.getCompressedSize()/(double)ze.getSize()))*100 )
             : 0 ;
         // Follow unzip -lv output
-        return (long)ze.getSize() + "\t" + ze.getMethod()
+        return ze.getSize() + "\t" + ze.getMethod()
             + "\t" + ze.getCompressedSize() + "\t"
             + store + "%\t"
             + new Date(ze.getTime()) + "\t"

src/share/classes/java/util/jar/Pack200.java

@@ -732,14 +732,14 @@ public abstract class Pack200 {
     private synchronized static Object newInstance(String prop) {
         String implName = "(unknown)";
         try {
-            Class impl = (prop == PACK_PROVIDER)? packerImpl: unpackerImpl;
+            Class impl = (PACK_PROVIDER.equals(prop))? packerImpl: unpackerImpl;
             if (impl == null) {
                 // The first time, we must decide which class to use.
                 implName = java.security.AccessController.doPrivileged(
                     new sun.security.action.GetPropertyAction(prop,""));
                 if (implName != null && !implName.equals(""))
                     impl = Class.forName(implName);
-                else if (prop == PACK_PROVIDER)
+                else if (PACK_PROVIDER.equals(prop))
                     impl = com.sun.java.util.jar.pack.PackerImpl.class;
                 else
                     impl = com.sun.java.util.jar.pack.UnpackerImpl.class;