Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2014-2015 the original author or authors.
   *
   * 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.lastaflute.di.util;
 
 import java.util.Map;
 import java.util.Set;

Parameters:
<KEY> The type of key.
<VALUE> The type of value.
Author(s):
modified by jflute (originated in Seasar)
 
 public class ArrayMap<KEY, VALUE> extends AbstractMap<KEY, VALUE> implements Map<KEY, VALUE>, CloneableExternalizable {
 
     static final long serialVersionUID = 1L;
 
     private static final int INITIAL_CAPACITY = 17;
 
     private static final float LOAD_FACTOR = 0.75f;
 
     private transient int threshold;
     private transient Entry<KEY, VALUE>[] mapTable;
     private transient Entry<KEY, VALUE>[] listTable;
     private transient int size = 0;
     private transient Set<Entry<KEY, VALUE>> entrySet = null;
 
     public ArrayMap() {
         this();
     }
 
     public ArrayMap(int initialCapacity) {
         if (initialCapacity <= 0) {
             initialCapacity = ;
         }
          = new Entry[initialCapacity];
          = new Entry[initialCapacity];
          = (int) (initialCapacity * );
     }
 
     public ArrayMap(Map<KEY, VALUE> map) {
         this((int) (map.size() / ) + 1);
         putAll(map);
     }
 
     public final int size() {
         return ;
     }
 
     public final boolean isEmpty() {
         return  == 0;
     }
 
     public final boolean containsValue(Object value) {
         return indexOf(value) >= 0;
     }
 
     public final int indexOf(Object value) {
         if (value != null) {
             for (int i = 0; i < i++) {
                 if (value.equals([i].)) {
                     return i;
                 }
             }
         } else {
             for (int i = 0; i < i++) {
                 if ([i]. == null) {
                     return i;
                 }
             }
         }
         return -1;
     }
 
     public boolean containsKey(final Object key) {
         Entry<KEY, VALUE>[] tbl = ;
         if (key != null) {
             int hashCode = key.hashCode();
            int index = (hashCode & 0x7FFFFFFF) % tbl.length;
            for (Entry<KEY, VALUE> e = tbl[index]; e != nulle = e.next) {
                if (e.hashCode == hashCode && key.equals(e.key)) {
                    return true;
                }
            }
        } else {
            for (Entry<KEY, VALUE> e = tbl[0]; e != nulle = e.next) {
                if (e.key == null) {
                    return true;
                }
            }
        }
        return false;
    }
    @Override
    public VALUE get(final Object key) {
        Entry<KEY, VALUE>[] tbl = ;
        if (key != null) {
            int hashCode = key.hashCode();
            int index = (hashCode & 0x7FFFFFFF) % tbl.length;
            for (Entry<KEY, VALUE> e = tbl[index]; e != nulle = e.next) {
                if (e.hashCode == hashCode && key.equals(e.key)) {
                    return e.value;
                }
            }
        } else {
            for (Entry<KEY, VALUE> e = tbl[0]; e != nulle = e.next) {
                if (e.key == null) {
                    return e.value;
                }
            }
        }
        return null;
    }
    public final VALUE get(final int index) {
        return getEntry(index).;
    }
    public final Object getKey(final int index) {
        return getEntry(index).;
    }
    public final Entry<KEY, VALUE> getEntry(final int index) {
        if (index >= ) {
            throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + );
        }
        return [index];
    }
    public VALUE put(final KEY keyfinal VALUE value) {
        int hashCode = 0;
        int index = 0;
        if (key != null) {
            hashCode = key.hashCode();
            index = (hashCode & 0x7FFFFFFF) % .;
            for (Entry<KEY, VALUE> e = [index]; e != nulle = e.next) {
                if ((e.hashCode == hashCode) && key.equals(e.key)) {
                    return swapValue(evalue);
                }
            }
        } else {
            for (Entry<KEY, VALUE> e = [0]; e != nulle = e.next) {
                if (e.key == null) {
                    return swapValue(evalue);
                }
            }
        }
        ensureCapacity();
        index = (hashCode & 0x7FFFFFFF) % .;
        Entry<KEY, VALUE> e = new Entry<KEY, VALUE>(hashCodekeyvalue[index]);
        [index] = e;
        [++] = e;
        return null;
    }
    public final void set(final int indexfinal VALUE value) {
        getEntry(index).setValue(value);
    }
    @Override
    public VALUE remove(final Object key) {
        Entry<KEY, VALUE> e = removeMap(key);
        if (e != null) {
            VALUE value = e.value;
            removeList(indexOf(e));
            e.clear();
            return value;
        }
        return null;
    }
    public final VALUE remove(int index) {
        final Entry<KEY, VALUE> entry = removeList(index);
        final VALUE value = entry.value;
        removeMap(entry.key);
        entry.value = null;
        return value;
    }
    @Override
    public void putAll(Map<? extends KEY, ? extends VALUE> map) {
        for (Map.Entry<? extends KEY, ? extends VALUE> entry : map.entrySet()) {
            put(entry.getKey(), entry.getValue());
        }
    }
    @Override
    public final void clear() {
        for (int i = 0; i < .i++) {
            [i] = null;
        }
        for (int i = 0; i < .i++) {
            [i] = null;
        }
         = 0;
    }
    public final Object[] toArray() {
        Object[] array = new Object[];
        for (int i = 0; i < array.lengthi++) {
            array[i] = get(i);
        }
        return array;
    }
    public final Object[] toArray(final Object proto[]) {
        Object[] array = proto;
        if (proto.length < ) {
            array = (Object[]) Array.newInstance(proto.getClass().getComponentType(), );
        }
        for (int i = 0; i < array.lengthi++) {
            array[i] = get(i);
        }
        if (array.length > ) {
            array[] = null;
        }
        return array;
    }
    public final boolean equals(Object o) {
        if (!getClass().isInstance(o)) {
            return false;
        }
        ArrayMap e = (ArrayMapo;
        if ( != e.size) {
            return false;
        }
        for (int i = 0; i < i++) {
            if (![i].equals(e.listTable[i])) {
                return false;
            }
        }
        return true;
    }
    public final Set entrySet() {
        if ( == null) {
             = new AbstractSet() {
                public Iterator iterator() {
                    return new ArrayMapIterator();
                }
                public boolean contains(Object o) {
                    if (!(o instanceof Entry)) {
                        return false;
                    }
                    Entry entry = (Entryo;
                    int index = (entry.hashCode & 0x7FFFFFFF) % .;
                    for (Entry e = [index]; e != nulle = e.next) {
                        if (e.equals(entry)) {
                            return true;
                        }
                    }
                    return false;
                }
                public boolean remove(Object o) {
                    if (!(o instanceof Entry)) {
                        return false;
                    }
                    Entry entry = (Entryo;
                    return ArrayMap.this.remove(entry.key) != null;
                }
                public int size() {
                    return ;
                }
                public void clear() {
                    ArrayMap.this.clear();
                }
            };
        }
        return ;
    }
    public final void writeExternal(final ObjectOutput outthrows IOException {
        out.writeInt(.);
        out.writeInt();
        for (int i = 0; i < i++) {
            out.writeObject([i].);
            out.writeObject([i].);
        }
    }
    public final void readExternal(final ObjectInput inthrows IOExceptionClassNotFoundException {
        int num = in.readInt();
         = new Entry[num];
         = new Entry[num];
         = (int) (num * );
        int size = in.readInt();
        for (int i = 0; i < sizei++) {
            @SuppressWarnings("unchecked")
            KEY key = (KEY) in.readObject();
            @SuppressWarnings("unchecked")
            VALUE value = (VALUE) in.readObject();
            put(keyvalue);
        }
    }
    @Override
    public Object clone() {
        ArrayMap<KEY, VALUE> copy = new ArrayMap<KEY, VALUE>();
        copy.threshold = ;
        copy.mapTable = ;
        copy.listTable = ;
        copy.size = ;
        return copy;
    }
    private final int indexOf(final Entry entry) {
        for (int i = 0; i < i++) {
            if ([i] == entry) {
                return i;
            }
        }
        return -1;
    }
    private final Entry<KEY, VALUE> removeMap(Object key) {
        int hashCode = 0;
        int index = 0;
        if (key != null) {
            hashCode = key.hashCode();
            index = (hashCode & 0x7FFFFFFF) % .;
            for (Entry<KEY, VALUE> e = [index], prev = nulle != nullprev = ee = e.next) {
                if ((e.hashCode == hashCode) && key.equals(e.key)) {
                    if (prev != null) {
                        prev.next = e.next;
                    } else {
                        [index] = e.next;
                    }
                    return e;
                }
            }
        } else {
            for (Entry<KEY, VALUE> e = [index], prev = nulle != nullprev = ee = e.next) {
                if ((e.hashCode == hashCode) && e.key == null) {
                    if (prev != null) {
                        prev.next = e.next;
                    } else {
                        [index] = e.next;
                    }
                    return e;
                }
            }
        }
        return null;
    }
    private final Entry<KEY, VALUE> removeList(int index) {
        Entry<KEY, VALUE> e = [index];
        int numMoved =  - index - 1;
        if (numMoved > 0) {
            System.arraycopy(index + 1, indexnumMoved);
        }
        [--] = null;
        return e;
    }
    private final void ensureCapacity() {
        if ( >= ) {
            Entry[] oldTable = ;
            int newCapacity = oldTable.length * 2 + 1;
            Entry[] newMapTable = new Entry[newCapacity];
            Entry[] newListTable = new Entry[newCapacity];
             = (int) (newCapacity * );
            System.arraycopy(oldTable, 0, newListTable, 0, );
            for (int i = 0; i < i++) {
                Entry<KEY, VALUE> old = oldTable[i];
                int index = (old.hashCode & 0x7FFFFFFF) % newCapacity;
                Entry<KEY, VALUE> e = old;
                old = old.next;
                e.next = newMapTable[index];
                newMapTable[index] = e;
            }
             = newMapTable;
             = newListTable;
        }
    }
    private final VALUE swapValue(final Entry<KEY, VALUE> entryfinal VALUE value) {
        VALUE old = entry.value;
        entry.value = value;
        return old;
    }
    private class ArrayMapIterator implements Iterator {
        private int current = 0;
        private int last = -1;
        public boolean hasNext() {
            return  != ;
        }
        public Object next() {
            try {
                Object n = [];
                 = ++;
                return n;
            } catch (IndexOutOfBoundsException e) {
                throw new NoSuchElementException();
            }
        }
        public void remove() {
            if ( == -1) {
                throw new IllegalStateException();
            }
            ArrayMap.this.remove();
            if ( < ) {
                --;
            }
             = -1;
        }
    }
    private static class Entry<KEY, VALUE> implements Map.Entry<KEY, VALUE>, Externalizable {
        private static final long serialVersionUID = -6625980241350717177L;
        transient int hashCode;
        transient KEY key;
        transient VALUE value;
        transient Entry<KEY, VALUE> next;
        public Entry(final int hashCodefinal KEY keyfinal VALUE valuefinal Entry<KEY, VALUE> next) {
            this. = hashCode;
            this. = key;
            this. = value;
            this. = next;
        }
        public KEY getKey() {
            return ;
        }
        public VALUE getValue() {
            return ;
        }
        public VALUE setValue(final VALUE value) {
            VALUE oldValue = value;
            this. = value;
            return oldValue;
        }
        public void clear() {
             = null;
             = null;
             = null;
        }
        @Override
        public boolean equals(final Object o) {
            if (this == o) {
                return true;
            }
            @SuppressWarnings("unchecked")
            final Entry<KEY, VALUE> e = (Entry<KEY, VALUE>) o;
            return ( != null ? .equals(e.key) : e.key == null) && ( != null ? .equals(e.value) : e.value == null);
        }
        public int hashCode() {
            return ;
        }
        public String toString() {
            return  + "=" + ;
        }
        public void writeExternal(final ObjectOutput sthrows IOException {
            s.writeInt();
            s.writeObject();
            s.writeObject();
            s.writeObject();
        }
        @SuppressWarnings({ "rawtypes""unchecked" })
        public void readExternal(final ObjectInput sthrows IOExceptionClassNotFoundException {
             = s.readInt();
             = (KEY) s.readObject();
             = (VALUE) s.readObject();
             = (Entry<KEY, VALUE>) s.readObject();
        }
    }
New to GrepCode? Check out our FAQ X