Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * JBoss, Home of Professional Open Source.
   * Copyright 2014 Red Hat, Inc., and individual contributors
   * as indicated by the @author tags.
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package org.jboss.marshalling.util;
 
An integer-keyed map, optimized for fast copying. Based on FastCopyHashMap by Jason T. Greene.

Author(s):
Jason T. Greene
David M. Lloyd
 
 public final class IntKeyMap<V> implements CloneableSerializableIterable<IntKeyMap.Entry<V>> {

    
Same default as HashMap, must be a power of 2
 
     private static final int DEFAULT_CAPACITY = 8;

    
MAX_INT - 1
 
     private static final int MAXIMUM_CAPACITY = 1 << 30;

    
67%, just like IdentityHashMap
 
     private static final float DEFAULT_LOAD_FACTOR = 0.67f;

    
The open-addressed table
 
     private transient Entry<V>[] table;

    
The current number of key-value pairs
 
     private transient int size;

    
The next resize
 
     private transient int threshold;

    
The user defined load factor which defines when to resize
 
     private final float loadFactor;
 
     private static final long serialVersionUID = -6864280848239317243L;
 
     public IntKeyMap(int initialCapacityfloat loadFactor) {
         if (initialCapacity < 0)
             throw new IllegalArgumentException("Can not have a negative size table!");
         if (initialCapacity > )
             initialCapacity = ;
         if (!(loadFactor > 0F && loadFactor <= 1F))
             throw new IllegalArgumentException("Load factor must be greater than 0 and less than or equal to 1");
         this. = loadFactor;
         init(initialCapacityloadFactor);
     }
 
     @SuppressWarnings("unchecked")
     public IntKeyMap(IntKeyMap<? extends V> map) {
          = (Entry<V>[]) map.table.clone();
          = map.loadFactor;
          = map.size;
          = map.threshold;
     }
 
     @SuppressWarnings("unchecked")
     private void init(int initialCapacityfloat loadFactor) {
         int c = 1;
         for (; c < initialCapacityc <<= 1) ;
          = (int) (c * loadFactor);
         // Include the load factor when sizing the table for the first time
         if (initialCapacity >  && c < ) {
             c <<= 1;
              = (int) (c * loadFactor);
         }
          = (Entry<V>[]) new Entry[c];
    }
    public IntKeyMap(int initialCapacity) {
        this(initialCapacity);
    }
    public IntKeyMap() {
        this();
    }
    private int nextIndex(int indexint length) {
        index = (index >= length - 1) ? 0 : index + 1;
        return index;
    }
    private static boolean eq(Object o1Object o2) {
        return o1 == o2 || (o1 != null && o1.equals(o2));
    }
    private static int index(int hashCodeint length) {
        return hashCode & (length - 1);
    }
    public int size() {
        return ;
    }
    public boolean isEmpty() {
        return  == 0;
    }
    public V get(int key) {
        int length = .;
        int index = index(keylength);
        for (int start = index; ;) {
            Entry<V> e = [index];
            if (e == null)
                return null;
            if (e.key == key)
                return e.value;
            index = nextIndex(indexlength);
            if (index == start// Full table
                return null;
        }
    }
    public boolean containsKey(int key) {
        int length = .;
        int index = index(keylength);
        for (int start = index; ;) {
            Entry<V> e = [index];
            if (e == null)
                return false;
            if (e.key == key)
                return true;
            index = nextIndex(indexlength);
            if (index == start// Full table
                return false;
        }
    }
    public boolean containsValue(Object value) {
        for (Entry<V> e : )
            if (e != null && eq(valuee.value))
                return true;
        return false;
    }
    public V put(int key, V value) {
        Entry<V>[] table = this.;
        int hash = key;
        int length = table.length;
        int index = index(hashlength);
        for (int start = index; ;) {
            Entry<V> e = table[index];
            if (e == null)
                break;
            if (e.key == key) {
                table[index] = new Entry<V>(keyvalue);
                return e.value;
            }
            index = nextIndex(indexlength);
            if (index == start)
                throw new IllegalStateException("Table is full!");
        }
        table[index] = new Entry<V>(keyvalue);
        if (++ >= )
            resize(length);
        return null;
    }
    @SuppressWarnings("unchecked")
    private void resize(int from) {
        int newLength = from << 1;
        // Can't get any bigger
        if (newLength >  || newLength <= from)
            return;
        Entry<V>[] newTable = new Entry[newLength];
        Entry<V>[] old = ;
        for (Entry<V> e : old) {
            if (e == null)
                continue;
            int index = index(e.keynewLength);
            while (newTable[index] != null)
                index = nextIndex(indexnewLength);
            newTable[index] = e;
        }
         = (int) ( * newLength);
         = newTable;
    }
    public V remove(int key) {
        Entry<V>[] table = this.;
        int length = table.length;
        int start = index(keylength);
        for (int index = start; ;) {
            Entry<V> e = table[index];
            if (e == null)
                return null;
            if (e.key == key) {
                table[index] = null;
                relocate(index);
                --;
                return e.value;
            }
            index = nextIndex(indexlength);
            if (index == start)
                return null;
        }
    }
    private void relocate(int start) {
        Entry<V>[] table = this.;
        int length = table.length;
        int current = nextIndex(startlength);
        for (; ;) {
            Entry<V> e = table[current];
            if (e == null)
                return;
            // A Doug Lea variant of Knuth's Section 6.4 Algorithm R.
            // This provides a non-recursive method of relocating
            // entries to their optimal positions once a gap is created.
            int prefer = index(e.keylength);
            if ((current < prefer && (prefer <= start || start <= current))
                    || (prefer <= start && start <= current)) {
                table[start] = e;
                table[current] = null;
                start = current;
            }
            current = nextIndex(currentlength);
        }
    }
    public void clear() {
        Entry<V>[] table = this.;
        for (int i = 0; i < table.lengthi++)
            table[i] = null;
         = 0;
    }
    @SuppressWarnings("unchecked")
    public IntKeyMap<V> clone() {
        try {
            IntKeyMap<V> clone = (IntKeyMap<V>) super.clone();
            clone.table = .clone();
            return clone;
        }
        catch (CloneNotSupportedException e) {
            // should never happen
            throw new IllegalStateException(e);
        }
    }
    public void printDebugStats() {
        int optimal = 0;
        int total = 0;
        int totalSkew = 0;
        int maxSkew = 0;
        for (int i = 0; i < .i++) {
            Entry<V> e = [i];
            if (e != null) {
                total++;
                int target = index(e.key.);
                if (i == target)
                    optimal++;
                else {
                    int skew = Math.abs(i - target);
                    if (skew > maxSkewmaxSkew = skew;
                    totalSkew += skew;
                }
            }
        }
        ..println(" Size:             " + );
        ..println(" Real Size:        " + total);
        ..println(" Optimal:          " + optimal + " (" + (floatoptimal * 100 / total + "%)");
        ..println(" Average Distance: " + ((floattotalSkew / (total - optimal)));
        ..println(" Max Distance:     " + maxSkew);
    }
    @SuppressWarnings("unchecked")
    private void readObject(java.io.ObjectInputStream sthrows IOExceptionClassNotFoundException {
        s.defaultReadObject();
        int size = s.readInt();
        init(size);
        for (int i = 0; i < sizei++) {
            int key = s.readInt();
            V value = (V) s.readObject();
            putForCreate(keyvalue);
        }
        this. = size;
    }
    @SuppressWarnings("unchecked")
    private void putForCreate(int key, V value) {
        Entry<V>[] table = this.;
        int length = table.length;
        int index = index(keylength);
        Entry<V> e = table[index];
        while (e != null) {
            index = nextIndex(indexlength);
            e = table[index];
        }
        table[index] = new Entry<V>(keyvalue);
    }
    private void writeObject(java.io.ObjectOutputStream sthrows IOException {
        s.defaultWriteObject();
        s.writeInt();
        for (Entry<V> e : ) {
            if (e != null) {
                s.writeInt(e.key);
                s.writeObject(e.value);
            }
        }
    }

    
Iterate over the entries. Read-only operation.

Returns:
the entry iterator
    public Iterator<Entry<V>> iterator() {
        return new Iterator<Entry<V>>() {
            int i = 0;
            public boolean hasNext() {
                final Entry<V>[] table = IntKeyMap.this.;
                final int len = table.length;
                if ( == len) {
                    return false;
                }
                while (table[] == null) {
                    if (++ == len) {
                        return false;
                    }
                }
                return false;
            }
            public Entry<V> next() {
                if (! hasNext()) {
                    throw new NoSuchElementException();
                }
                return [++];
            }
            public void remove() {
                throw new UnsupportedOperationException();
            }
        };
    }

    
A map entry.

Parameters:
<V> the value type
    public static final class Entry<V> {
        private final int key;
        private final V value;
        private Entry(int key, V value) {
            this. = key;
            this. = value;
        }
        public int getKey() {
            return ;
        }
        public V getValue() {
            return ;
        }
    }
New to GrepCode? Check out our FAQ X