RubyHash

java.lang.Object
- net.sf.rubycollect4j.RubyEnumerable<java.util.Map.Entry<K,V>>
- - net.sf.rubycollect4j.RubyHash<K,V>

Type Parameters:
K - the type of the key elements
V - the type of the value elements

All Implemented Interfaces:

java.io.Serializable, java.lang.Iterable<java.util.Map.Entry<K,V>>, java.util.Map<K,V>, Ruby.Enumerable<java.util.Map.Entry<K,V>>, RubyContract.Enumerable<java.util.Map.Entry<K,V>,Ruby.Enumerator<?>,RubyArray<?>>
```
public final class RubyHash<K,V>
extends RubyEnumerable<java.util.Map.Entry<K,V>>
implements java.util.Map<K,V>, java.io.Serializable
```
RubyHash implements all methods refer to the Hash class of Ruby language.
RubyHash is also a Java Map and a Ruby.Enumerable.

See Also:
Serialized Form

Nested Class Summary
- Nested classes/interfaces inherited from interface java.util.Map
  java.util.Map.Entry<K,V>

Constructor Summary

Constructors
Constructor and Description
`RubyHash()` Creates a `RubyHash`.
`RubyHash(java.util.LinkedHashMap<K,V> map)` Creates a `RubyHash` by given LinkedHashMap.
`RubyHash(java.util.Map<K,V> map)` Creates a `RubyHash` by given Map.

Method Summary

Methods
Modifier and Type	Method and Description
`boolean`	`allʔ(EntryBooleanBlock<? super K,? super V> block)` An adapter method.
`boolean`	`anyʔ(EntryBooleanBlock<? super K,? super V> block)` An adapter method.
`java.util.Map.Entry<K,V>`	`assoc(K key)` Finds an Entry by given key.
`<S> RubyEnumerator<java.util.Map.Entry<S,RubyArray<java.util.Map.Entry<K,V>>>>`	`chunk(EntryTransformBlock<? super K,? super V,? extends S> block)` An adapter method.
`void`	`clear()`
`<S> RubyArray<S>`	`collect(EntryTransformBlock<? super K,? super V,? extends S> block)` An adapter method.
`<S> RubyArray<S>`	`collectConcat(EntryTransformBlock<? super K,? super V,? extends java.util.List<S>> block)` An adapter method.
`RubyHash<K,V>`	`compareByIdentity()` Turns this `RubyHash` to compare each elements by their identities instead of their equalities.
`boolean`	`comparedByIdentityʔ()` Returns whether this `RubyHash` is compared by identity.
`boolean`	`containsKey(java.lang.Object key)`
`boolean`	`containsValue(java.lang.Object value)`
`static <K,V> RubyHash<K,V>`	`copyOf(java.util.Map<K,V> map)` Returns a `RubyHash` which copies the elements of given Map.
`int`	`count(EntryBooleanBlock<? super K,? super V> block)` An adapter method.
`void`	`cycle(EntryBlock<? super K,? super V> block)` An adapter method.
`void`	`cycle(int n, EntryBlock<? super K,? super V> block)` An adapter method.
`V`	`delete(K key)` Deletes an Entry by given key and returns the deleted value.Returns null if key is not found and default value is not set.
`RubyEnumerator<java.util.Map.Entry<K,V>>`	`deleteIf()` Returns a `RubyEnumerator` of entries this `RubyHash`.
`RubyHash<K,V>`	`deleteIf(EntryBooleanBlock<? super K,? super V> block)` Deletes entries which the result are true returned by the block.
`java.util.Map.Entry<K,V>`	`detect(EntryBooleanBlock<? super K,? super V> block)` An adapter method.
`RubyArray<java.util.Map.Entry<K,V>>`	`dropWhile(EntryBooleanBlock<? super K,? super V> block)` An adapter method.
`RubyHash<K,V>`	`each(EntryBlock<? super K,? super V> block)`
`RubyEnumerable<java.util.Map.Entry<K,V>>`	`eachEntry(EntryBlock<? super K,? super V> block)` An adapter method.
`RubyEnumerator<K>`	`eachKey()` Returns a `RubyEnumerator` of keys of this `RubyHash`.
`RubyHash<K,V>`	`eachKey(Block<? super K> block)` Yields each key to given block.
`RubyEnumerator<java.util.Map.Entry<K,V>>`	`eachPair()` Returns a `RubyEnumerator` of entries this `RubyHash`.
`RubyHash<K,V>`	`eachPair(EntryBlock<? super K,? super V> block)` Equivalent to `each(EntryBlock)`.
`RubyEnumerator<V>`	`eachValue()` Returns a `RubyEnumerator` of values of this `RubyHash`.
`RubyHash<K,V>`	`eachValue(Block<? super V> block)` Yields each value to given block.
`boolean`	`emptyʔ()` Checks if this `RubyHash` is empty.
`java.util.Set<java.util.Map.Entry<K,V>>`	`entrySet()`
`boolean`	`eqlʔ(java.lang.Object other)` Equivalent to `equals(Object)`.
`boolean`	`equals(java.lang.Object o)`
`V`	`fetch(K key)` Fetchs the value of the key.
`V`	`fetch(K key, V defaultValue)` Fetches the value of the key.
`java.util.Map.Entry<K,V>`	`find(EntryBooleanBlock<? super K,? super V> block)` An adapter method.
`RubyArray<java.util.Map.Entry<K,V>>`	`findAll(EntryBooleanBlock<? super K,? super V> block)` An adapter method.
`java.lang.Integer`	`findIndex(EntryBooleanBlock<? super K,? super V> block)` An adapter method.
`<S> RubyArray<S>`	`flatMap(EntryTransformBlock<? super K,? super V,? extends java.util.List<S>> block)` An adapter method.
`RubyArray<java.util.Map.Entry<K,V>>`	`flatten()` Returns a `RubyEnumerator` of entries of this `RubyHash`.
`RubyHash<K,V>`	`freeze()` Freezes this `RubyHash`.
`boolean`	`frozenʔ()` Checks if this `RubyHash` is frozen.
`V`	`get(java.lang.Object key)`
`V`	`getDefault()` Returns the default value of this `RubyHash`.
`protected java.lang.Iterable<java.util.Map.Entry<K,V>>`	`getIterable()` Returns an Iterable of elements.
`<S> RubyArray<S>`	`grep(java.lang.String regex, EntryTransformBlock<? super K,? super V,? extends S> block)` An adapter method.
`<S> RubyHash<S,RubyArray<java.util.Map.Entry<K,V>>>`	`groupBy(EntryTransformBlock<? super K,? super V,? extends S> block)` An adapter method.
`int`	`hash()` Equivalent to `hashCode()`.
`int`	`hashCode()`
`java.lang.String`	`inspect()` Equivalent to `toString()`.
`RubyHash<V,K>`	`invert()` Creates an inverted `RubyHash` which gets the reversed value-key entries based on this `RubyHash`.
`boolean`	`isEmpty()`
`RubyEnumerator<java.util.Map.Entry<K,V>>`	`keepIf()` Returns a `RubyEnumerator` of entries of this `RubyHash`.
`RubyHash<K,V>`	`keepIf(EntryBooleanBlock<? super K,? super V> block)` Keeps elements which the result are true returned by the block.
`K`	`key(V value)` Finds the key related to given value.
`RubyArray<K>`	`keys()` Returns a `RubyArray` of keys of this `RubyHash`.
`java.util.Set<K>`	`keySet()`
`boolean`	`keyʔ(K key)` Equivalent to `containsKey(Object)`.
`int`	`length()` Equivalent to `size()`.
`<S> RubyArray<S>`	`map(EntryTransformBlock<? super K,? super V,? extends S> block)` An adapter method.
`<S> java.util.Map.Entry<K,V>`	`maxBy(java.util.Comparator<? super S> comp, EntryTransformBlock<? super K,? super V,? extends S> block)` An adapter method.
`<S> java.util.Map.Entry<K,V>`	`maxBy(EntryTransformBlock<? super K,? super V,? extends S> block)` An adapter method.
`RubyHash<K,V>`	`merge(java.util.Map<? extends K,? extends V> otherHash)` Merges any Map with self and puts into a new `RubyHash`.
`RubyHash<K,V>`	`merge(java.util.Map<K,V> otherHash, EntryMergeBlock<? super K,V> block)` Merges any Map with self and puts into a new `RubyHash`.
`RubyHash<K,V>`	`mergeǃ(java.util.Map<? extends K,? extends V> otherHash)` Merges any Map into self.
`RubyHash<K,V>`	`mergeǃ(java.util.Map<? extends K,? extends V> otherHash, EntryMergeBlock<? super K,V> block)` Merges any Map into self.
`<S> java.util.Map.Entry<K,V>`	`minBy(java.util.Comparator<? super S> comp, EntryTransformBlock<? super K,? super V,? extends S> block)` An adapter method.
`<S> java.util.Map.Entry<K,V>`	`minBy(EntryTransformBlock<? super K,? super V,? extends S> block)` An adapter method.
`<S> RubyArray<java.util.Map.Entry<K,V>>`	`minmaxBy(java.util.Comparator<? super S> comp, EntryTransformBlock<? super K,? super V,? extends S> block)` An adapter method.
`<S> RubyArray<java.util.Map.Entry<K,V>>`	`minmaxBy(EntryTransformBlock<? super K,? super V,? extends S> block)` An adapter method.
`boolean`	`noneʔ(EntryBooleanBlock<? super K,? super V> block)` An adapter method.
`static <K,V> RubyHash<K,V>`	`of(java.util.LinkedHashMap<K,V> map)` Returns a `RubyHash` which wraps the given Map.
`boolean`	`oneʔ(EntryBooleanBlock<? super K,? super V> block)` An adapter method.
`RubyArray<RubyArray<java.util.Map.Entry<K,V>>>`	`partition(EntryBooleanBlock<? super K,? super V> block)` An adapter method.
`V`	`put(K key, V value)`
`RubyHash<K,V>`	`put(java.util.Map.Entry<? extends K,? extends V>... entries)` Puts entries into this `RubyHash` directly.
`RubyHash<K,V>`	`put(java.util.Map.Entry<? extends K,? extends V> entry)` Puts an Entry into this `RubyHash` directly.
`void`	`putAll(java.util.Map<? extends K,? extends V> m)`
`java.util.Map.Entry<K,V>`	`rassoc(V value)` Finds an Entry by given value.
`RubyArray<java.util.Map.Entry<K,V>>`	`reject(EntryBooleanBlock<? super K,? super V> block)` An adapter method.
`RubyEnumerator<java.util.Map.Entry<K,V>>`	`rejectǃ()` Returns a `RubyEnumerator` of entries of this `RubyHash`.
`RubyHash<K,V>`	`rejectǃ(EntryBooleanBlock<? super K,? super V> block)` Deletes entries which are true returned by the block.
`V`	`remove(java.lang.Object key)`
`RubyHash<K,V>`	`replace(java.util.Map<? extends K,? extends V> otherHash)` Replaces all entries with the entries of given Map.
`RubyEnumerable<java.util.Map.Entry<K,V>>`	`reverseEach(EntryBlock<? super K,? super V> block)` An adapter method.
`RubyArray<java.util.Map.Entry<K,V>>`	`select(EntryBooleanBlock<? super K,? super V> block)` An adapter method.
`V`	`setDefault(V defaultValue)` Sets the default value of this `RubyHash`.
`java.util.Map.Entry<K,V>`	`shift()` Removes the first Entry and returns it.
`int`	`size()`
`RubyEnumerator<RubyArray<java.util.Map.Entry<K,V>>>`	`sliceBefore(EntryBooleanBlock<? super K,? super V> block)` An adapter method.
`<S> RubyArray<java.util.Map.Entry<K,V>>`	`sortBy(java.util.Comparator<? super S> comp, EntryTransformBlock<? super K,? super V,? extends S> block)` An adapter method.
`<S> RubyArray<java.util.Map.Entry<K,V>>`	`sortBy(EntryTransformBlock<? super K,? super V,? extends S> block)` An adapter method.
`V`	`store(K key, V value)` Puts a key-value pair and returns the value.
`RubyArray<java.util.Map.Entry<K,V>>`	`takeWhile(EntryBooleanBlock<? super K,? super V> block)` An adapter method.
`RubyHash<K,V>`	`toH()` Returns this `RubyHash`.
`RubyHash<K,V>`	`toHash()` Returns this `RubyHash`.
`java.lang.String`	`toS()` Equivalent to `toString()`.
`java.lang.String`	`toString()`
`RubyHash<K,V>`	`update(java.util.Map<? extends K,? extends V> otherHash)` Equivalent to `mergeǃ(Map)`.
`RubyHash<K,V>`	`update(java.util.Map<? extends K,? extends V> otherHash, EntryMergeBlock<? super K,V> block)` Equivalent to `mergeǃ(Map, EntryMergeBlock)`.
`RubyArray<V>`	`values()` Returns a `RubyArray` of values of this `RubyHash`.
`RubyArray<V>`	`valuesAt(java.lang.Iterable<?> keys)` Finds all the values by given keys.
`RubyArray<V>`	`valuesAt(java.lang.Object... keys)` Finds all the values by given keys.
`boolean`	`valueʔ(java.lang.Object value)` Checks if the value included.

Methods inherited from class net.sf.rubycollect4j.RubyEnumerable
allʔ, allʔ, anyʔ, anyʔ, chunk, chunk, collect, collect, collect, collectConcat, collectConcat, count, count, cycle, cycle, cycle, cycle, detect, detect, drop, dropWhile, dropWhile, each, each, eachCons, eachCons, eachEntry, eachEntry, eachSlice, eachSlice, eachWithIndex, eachWithIndex, eachWithObject, eachWithObject, entries, find, find, findAll, findAll, findIndex, findIndex, findIndex, first, first, flatMap, flatMap, grep, grep, grep, groupBy, groupBy, groupBy, includeʔ, inject, inject, inject, inject, iterator, lazy, map, map, map, max, max, maxBy, maxBy, maxBy, maxBy, memberʔ, min, min, minBy, minBy, minBy, minBy, minmax, minmax, minmaxBy, minmaxBy, minmaxBy, minmaxBy, noneʔ, noneʔ, oneʔ, oneʔ, partition, partition, reduce, reduce, reduce, reduce, reject, reject, reverseEach, reverseEach, select, select, sliceBefore, sliceBefore, sort, sortBy, sortBy, sortBy, sortBy, sortBy, take, takeWhile, takeWhile, toA, zip, zip, zip

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - RubyHash
```
public RubyHash()
```
    Creates a RubyHash.
  - RubyHash
```
public RubyHash(java.util.LinkedHashMap<K,V> map)
```
    Creates a RubyHash by given LinkedHashMap. It's a wrapper implementation. No defensive copy has been made.
    
    Parameters:
    map - a LinkedHashMap
    
    Throws:
    
    java.lang.NullPointerException - if map is null
  - RubyHash
```
public RubyHash(java.util.Map<K,V> map)
```
    Creates a RubyHash by given Map.
    
    Parameters:
    map - any Map
    
    Throws:
    
    java.lang.NullPointerException - if map is null
- Method Detail
  - of
```
public static <K,V> RubyHash<K,V> of(java.util.LinkedHashMap<K,V> map)
```
    Returns a RubyHash which wraps the given Map.
    
    Parameters:
    map - any Map
    
    Returns:
    RubyHash
    
    Throws:
    
    java.lang.NullPointerException - if map is null
  - copyOf
```
public static <K,V> RubyHash<K,V> copyOf(java.util.Map<K,V> map)
```
    Returns a RubyHash which copies the elements of given Map.
    
    Parameters:
    map - any Map
    
    Returns:
    RubyHash
    
    Throws:
    
    java.lang.NullPointerException - if map is null
  - getIterable
```
protected java.lang.Iterable<java.util.Map.Entry<K,V>> getIterable()
```
    Description copied from class: RubyEnumerable
    
    Returns an Iterable of elements.
    
    Specified by:
    
    getIterable in class RubyEnumerable<java.util.Map.Entry<K,V>>
    
    Returns:
    Iterable
  - assoc
```
public java.util.Map.Entry<K,V> assoc(K key)
```
    Finds an Entry by given key.
    
    Parameters:
    key - to be found
    
    Returns:
    Entry or null
  - compareByIdentity
```
public RubyHash<K,V> compareByIdentity()
```
    Turns this RubyHash to compare each elements by their identities instead of their equalities.
    
    Returns:
    this RubyHash
  - comparedByIdentityʔ
```
public boolean comparedByIdentityʔ()
```
    Returns whether this RubyHash is compared by identity.
    
    Returns:
    true if this RubyHash is compared by identity, false otherwise
  - delete
```
public V delete(K key)
```
    Deletes an Entry by given key and returns the deleted value.Returns null if key is not found and default value is not set. Returns default value otherwise.
    
    Parameters:
    key - to be deleted
    
    Returns:
    deleted value or null
  - deleteIf
```
public RubyEnumerator<java.util.Map.Entry<K,V>> deleteIf()
```
    Returns a RubyEnumerator of entries this RubyHash.
    
    Returns:
    RubyEnumerator
  - deleteIf
```
public RubyHash<K,V> deleteIf(EntryBooleanBlock<? super K,? super V> block)
```
    Deletes entries which the result are true returned by the block.
    
    Parameters:
    block - to filter elements
    
    Returns:
    this RubyHash
  - setDefault
```
public V setDefault(V defaultValue)
```
    Sets the default value of this RubyHash.
    
    Parameters:
    defaultValue - default value if key is not found
    
    Returns:
    default value
  - getDefault
```
public V getDefault()
```
    Returns the default value of this RubyHash.
    
    Returns:
    default value
  - each
```
public RubyHash<K,V> each(EntryBlock<? super K,? super V> block)
```
    Returns:
    this RubyHash
    See Also:
    RubyEnumerable.each(Block)
  - eachKey
```
public RubyEnumerator<K> eachKey()
```
    Returns a RubyEnumerator of keys of this RubyHash.
    
    Returns:
    RubyEnumerator
  - eachKey
```
public RubyHash<K,V> eachKey(Block<? super K> block)
```
    Yields each key to given block.
    
    Parameters:
    block - to yield each key
    
    Returns:
    this RubyHash
  - eachPair
```
public RubyEnumerator<java.util.Map.Entry<K,V>> eachPair()
```
    Returns a RubyEnumerator of entries this RubyHash.
    
    Returns:
    RubyEnumerator
  - eachPair
```
public RubyHash<K,V> eachPair(EntryBlock<? super K,? super V> block)
```
    Equivalent to each(EntryBlock).
    
    Parameters:
    block - to yield each entry
    
    Returns:
    this RubyHash
  - eachValue
```
public RubyEnumerator<V> eachValue()
```
    Returns a RubyEnumerator of values of this RubyHash.
    
    Returns:
    RubyEnumerator
  - eachValue
```
public RubyHash<K,V> eachValue(Block<? super V> block)
```
    Yields each value to given block.
    
    Parameters:
    block - to yield each value
    
    Returns:
    this RubyHash
  - emptyʔ
```
public boolean emptyʔ()
```
    Checks if this RubyHash is empty.
    
    Returns:
    true if this RubyHash is empty, false otherwise
  - eqlʔ
```
public boolean eqlʔ(java.lang.Object other)
```
    Equivalent to equals(Object).
    
    Parameters:
    other - any Object
    
    Returns:
    true if 2 objects are equal, false otherwise
  - fetch
```
public V fetch(K key)
```
    Fetchs the value of the key.
    
    Parameters:
    key - to be found
    
    Returns:
    value of the key
    
    Throws:
    
    java.util.NoSuchElementException - if key is not found
  - fetch
```
public V fetch(K key,
      V defaultValue)
```
    Fetches the value of the key.
    
    Parameters:
    key - to be found
    defaultValue - when key is not found
    
    Returns:
    value of the key or defaultValue
  - flatten
```
public RubyArray<java.util.Map.Entry<K,V>> flatten()
```
    Returns a RubyEnumerator of entries of this RubyHash.
    
    Returns:
    RubyEnumerator
  - freeze
```
public RubyHash<K,V> freeze()
```
    Freezes this RubyHash.
    
    Returns:
    this RubyHash
  - frozenʔ
```
public boolean frozenʔ()
```
    Checks if this RubyHash is frozen.
    
    Returns:
    true if this RubyHash is frozen, false otherwise
  - hash
```
public int hash()
```
    Equivalent to hashCode().
    
    Returns:
    the hash code
  - inspect
```
public java.lang.String inspect()
```
    Equivalent to toString().
    
    Returns:
    String
  - invert
```
public RubyHash<V,K> invert()
```
    Creates an inverted RubyHash which gets the reversed value-key entries based on this RubyHash.
    
    Returns:
    new RubyHash
  - keepIf
```
public RubyEnumerator<java.util.Map.Entry<K,V>> keepIf()
```
    Returns a RubyEnumerator of entries of this RubyHash.
    
    Returns:
    RubyEnumerator
  - keepIf
```
public RubyHash<K,V> keepIf(EntryBooleanBlock<? super K,? super V> block)
```
    Keeps elements which the result are true returned by the block.
    
    Parameters:
    block - to filter elements
    
    Returns:
    this RubyHash
  - key
```
public K key(V value)
```
    Finds the key related to given value.
    
    Parameters:
    value - to be found
    
    Returns:
    key of the given value or null
  - keys
```
public RubyArray<K> keys()
```
    Returns a RubyArray of keys of this RubyHash.
    
    Returns:
    RubyArray
  - keyʔ
```
public boolean keyʔ(K key)
```
    Equivalent to containsKey(Object).
    
    Parameters:
    key - to be found
    
    Returns:
    true if key is found, false otherwise
  - length
```
public int length()
```
    Equivalent to size().
    
    Returns:
    size of this RubyHash
  - merge
```
public RubyHash<K,V> merge(java.util.Map<? extends K,? extends V> otherHash)
```
    Merges any Map with self and puts into a new RubyHash.
    
    Parameters:
    otherHash - any Map
    
    Returns:
    new RubyHash
  - merge
```
public RubyHash<K,V> merge(java.util.Map<K,V> otherHash,
                  EntryMergeBlock<? super K,V> block)
```
    Merges any Map with self and puts into a new RubyHash. Resolves the final value of the key which is conflicted by given block.
    
    Parameters:
    otherHash - any Map
    block - to determine which value is used when key is conflict
    
    Returns:
    new RubyHash
  - mergeǃ
```
public RubyHash<K,V> mergeǃ(java.util.Map<? extends K,? extends V> otherHash)
```
    Merges any Map into self.
    
    Parameters:
    otherHash - any Map
    
    Returns:
    this RubyHash
  - mergeǃ
```
public RubyHash<K,V> mergeǃ(java.util.Map<? extends K,? extends V> otherHash,
                   EntryMergeBlock<? super K,V> block)
```
    Merges any Map into self. Resolves the final value of the key which is conflicted by given block.
    
    Parameters:
    otherHash - any Map
    block - to determine which value is used when key is conflict
    
    Returns:
    new RubyHash
  - put
```
public RubyHash<K,V> put(java.util.Map.Entry<? extends K,? extends V> entry)
```
    Puts an Entry into this RubyHash directly.
    
    Parameters:
    entry - an Entry
    
    Returns:
    this RubyHash
  - put
```
public RubyHash<K,V> put(java.util.Map.Entry<? extends K,? extends V>... entries)
```
    Puts entries into this RubyHash directly.
    
    Parameters:
    entries - an array of entries
    
    Returns:
    this RubyHash
  - rassoc
```
public java.util.Map.Entry<K,V> rassoc(V value)
```
    Finds an Entry by given value.
    
    Parameters:
    value - to be found
    
    Returns:
    Entry or null
  - rejectǃ
```
public RubyEnumerator<java.util.Map.Entry<K,V>> rejectǃ()
```
    Returns a RubyEnumerator of entries of this RubyHash.
    
    Returns:
    RubyEnumerator
  - rejectǃ
```
public RubyHash<K,V> rejectǃ(EntryBooleanBlock<? super K,? super V> block)
```
    Deletes entries which are true returned by the block. Returns null if nothing is deleted.
    
    Parameters:
    block - to filter elements
    
    Returns:
    this RubyHash or null
  - replace
```
public RubyHash<K,V> replace(java.util.Map<? extends K,? extends V> otherHash)
```
    Replaces all entries with the entries of given Map.
    
    Parameters:
    otherHash - any Map
    
    Returns:
    this RubyHash
  - shift
```
public java.util.Map.Entry<K,V> shift()
```
    Removes the first Entry and returns it.
    
    Returns:
    Entry
  - store
```
public V store(K key,
      V value)
```
    Puts a key-value pair and returns the value.
    
    Parameters:
    key - of Entry
    value - of Entry
    
    Returns:
    value
  - toH
```
public RubyHash<K,V> toH()
```
    Returns this RubyHash.
    
    Returns:
    this RubyHash
  - toHash
```
public RubyHash<K,V> toHash()
```
    Returns this RubyHash.
    
    Returns:
    this RubyHash
  - toS
```
public java.lang.String toS()
```
    Equivalent to toString().
    
    Returns:
    String
  - update
```
public RubyHash<K,V> update(java.util.Map<? extends K,? extends V> otherHash)
```
    Equivalent to mergeǃ(Map).
    
    Parameters:
    otherHash - any Map
    
    Returns:
    this RubyHash
  - update
```
public RubyHash<K,V> update(java.util.Map<? extends K,? extends V> otherHash,
                   EntryMergeBlock<? super K,V> block)
```
    Equivalent to mergeǃ(Map, EntryMergeBlock).
    
    Parameters:
    otherHash - any Map
    block - to determine which value is used when key is conflict
    
    Returns:
    new RubyHash
  - allʔ
```
public boolean allʔ(EntryBooleanBlock<? super K,? super V> block)
```
    An adapter method.
    
    See Also:
    RubyEnumerable.allʔ(BooleanBlock)
  - anyʔ
```
public boolean anyʔ(EntryBooleanBlock<? super K,? super V> block)
```
    An adapter method.
    
    See Also:
    RubyEnumerable.anyʔ(BooleanBlock)
  - chunk
```
public <S> RubyEnumerator<java.util.Map.Entry<S,RubyArray<java.util.Map.Entry<K,V>>>> chunk(EntryTransformBlock<? super K,? super V,? extends S> block)
```
    An adapter method.
    
    See Also:
    RubyEnumerable.chunk(TransformBlock)
  - collect
```
public <S> RubyArray<S> collect(EntryTransformBlock<? super K,? super V,? extends S> block)
```
    An adapter method.
    
    See Also:
    RubyEnumerable.collect(TransformBlock)
  - collectConcat
```
public <S> RubyArray<S> collectConcat(EntryTransformBlock<? super K,? super V,? extends java.util.List<S>> block)
```
    An adapter method.
    
    See Also:
    RubyEnumerable.collectConcat(TransformBlock)
  - count
```
public int count(EntryBooleanBlock<? super K,? super V> block)
```
    An adapter method.
    
    See Also:
    RubyEnumerable.count(BooleanBlock)
  - cycle
```
public void cycle(EntryBlock<? super K,? super V> block)
```
    An adapter method.
    
    See Also:
    RubyEnumerable.cycle(Block)
  - cycle
```
public void cycle(int n,
         EntryBlock<? super K,? super V> block)
```
    An adapter method.
    
    See Also:
    RubyEnumerable.cycle(int, Block)
  - detect
```
public java.util.Map.Entry<K,V> detect(EntryBooleanBlock<? super K,? super V> block)
```
    An adapter method.
    
    See Also:
    RubyEnumerable.detect(BooleanBlock)
  - dropWhile
```
public RubyArray<java.util.Map.Entry<K,V>> dropWhile(EntryBooleanBlock<? super K,? super V> block)
```
    An adapter method.
    
    See Also:
    RubyEnumerable.dropWhile(BooleanBlock)
  - eachEntry
```
public RubyEnumerable<java.util.Map.Entry<K,V>> eachEntry(EntryBlock<? super K,? super V> block)
```
    An adapter method.
    
    See Also:
    RubyEnumerable.eachEntry(Block)
  - find
```
public java.util.Map.Entry<K,V> find(EntryBooleanBlock<? super K,? super V> block)
```
    An adapter method.
    
    See Also:
    RubyEnumerable.find(BooleanBlock)
  - findAll
```
public RubyArray<java.util.Map.Entry<K,V>> findAll(EntryBooleanBlock<? super K,? super V> block)
```
    An adapter method.
    
    See Also:
    RubyEnumerable.findAll(BooleanBlock)
  - findIndex
```
public java.lang.Integer findIndex(EntryBooleanBlock<? super K,? super V> block)
```
    An adapter method.
    
    See Also:
    RubyEnumerable.findIndex(BooleanBlock)
  - flatMap
```
public <S> RubyArray<S> flatMap(EntryTransformBlock<? super K,? super V,? extends java.util.List<S>> block)
```
    An adapter method.
    
    See Also:
    RubyEnumerable.flatMap(TransformBlock)
  - grep
```
public <S> RubyArray<S> grep(java.lang.String regex,
                    EntryTransformBlock<? super K,? super V,? extends S> block)
```
    An adapter method.
    
    See Also:
    RubyEnumerable.grep(String, TransformBlock)
  - groupBy
```
public <S> RubyHash<S,RubyArray<java.util.Map.Entry<K,V>>> groupBy(EntryTransformBlock<? super K,? super V,? extends S> block)
```
    An adapter method.
    
    See Also:
    RubyEnumerable.groupBy(TransformBlock)
  - map
```
public <S> RubyArray<S> map(EntryTransformBlock<? super K,? super V,? extends S> block)
```
    An adapter method.
    
    See Also:
    RubyEnumerable.map(TransformBlock)
  - maxBy
```
public <S> java.util.Map.Entry<K,V> maxBy(java.util.Comparator<? super S> comp,
                                 EntryTransformBlock<? super K,? super V,? extends S> block)
```
    An adapter method.
    
    See Also:
    RubyEnumerable.maxBy(Comparator, TransformBlock)
  - maxBy
```
public <S> java.util.Map.Entry<K,V> maxBy(EntryTransformBlock<? super K,? super V,? extends S> block)
```
    An adapter method.
    
    See Also:
    RubyEnumerable.maxBy(TransformBlock)
  - minBy
```
public <S> java.util.Map.Entry<K,V> minBy(java.util.Comparator<? super S> comp,
                                 EntryTransformBlock<? super K,? super V,? extends S> block)
```
    An adapter method.
    
    See Also:
    RubyEnumerable.minBy(Comparator, TransformBlock)
  - minBy
```
public <S> java.util.Map.Entry<K,V> minBy(EntryTransformBlock<? super K,? super V,? extends S> block)
```
    An adapter method.
    
    See Also:
    RubyEnumerable.minBy(TransformBlock)
  - minmaxBy
```
public <S> RubyArray<java.util.Map.Entry<K,V>> minmaxBy(java.util.Comparator<? super S> comp,
                                               EntryTransformBlock<? super K,? super V,? extends S> block)
```
    An adapter method.
    
    See Also:
    RubyEnumerable.minmaxBy(Comparator, TransformBlock)
  - minmaxBy
```
public <S> RubyArray<java.util.Map.Entry<K,V>> minmaxBy(EntryTransformBlock<? super K,? super V,? extends S> block)
```
    An adapter method.
    
    See Also:
    RubyEnumerable.minmaxBy(TransformBlock)
  - noneʔ
```
public boolean noneʔ(EntryBooleanBlock<? super K,? super V> block)
```
    An adapter method.
    
    See Also:
    RubyEnumerable.noneʔ(BooleanBlock)
  - oneʔ
```
public boolean oneʔ(EntryBooleanBlock<? super K,? super V> block)
```
    An adapter method.
    
    See Also:
    RubyEnumerable.oneʔ(BooleanBlock)
  - partition
```
public RubyArray<RubyArray<java.util.Map.Entry<K,V>>> partition(EntryBooleanBlock<? super K,? super V> block)
```
    An adapter method.
    
    See Also:
    RubyEnumerable.partition(BooleanBlock)
  - reject
```
public RubyArray<java.util.Map.Entry<K,V>> reject(EntryBooleanBlock<? super K,? super V> block)
```
    An adapter method.
    
    See Also:
    RubyEnumerable.reject(BooleanBlock)
  - reverseEach
```
public RubyEnumerable<java.util.Map.Entry<K,V>> reverseEach(EntryBlock<? super K,? super V> block)
```
    An adapter method.
    
    See Also:
    RubyEnumerable.reverseEach(Block)
  - select
```
public RubyArray<java.util.Map.Entry<K,V>> select(EntryBooleanBlock<? super K,? super V> block)
```
    An adapter method.
    
    See Also:
    RubyEnumerable.select(BooleanBlock)
  - sliceBefore
```
public RubyEnumerator<RubyArray<java.util.Map.Entry<K,V>>> sliceBefore(EntryBooleanBlock<? super K,? super V> block)
```
    An adapter method.
    
    See Also:
    RubyEnumerable.sliceBefore(BooleanBlock)
  - sortBy
```
public <S> RubyArray<java.util.Map.Entry<K,V>> sortBy(java.util.Comparator<? super S> comp,
                                             EntryTransformBlock<? super K,? super V,? extends S> block)
```
    An adapter method.
    
    See Also:
    RubyEnumerable.sortBy(Comparator, TransformBlock)
  - sortBy
```
public <S> RubyArray<java.util.Map.Entry<K,V>> sortBy(EntryTransformBlock<? super K,? super V,? extends S> block)
```
    An adapter method.
    
    See Also:
    RubyEnumerable.sortBy(TransformBlock)
  - takeWhile
```
public RubyArray<java.util.Map.Entry<K,V>> takeWhile(EntryBooleanBlock<? super K,? super V> block)
```
    An adapter method.
    
    See Also:
    RubyEnumerable.takeWhile(BooleanBlock)
  - values
```
public RubyArray<V> values()
```
    Returns a RubyArray of values of this RubyHash.
    
    Specified by:
    
    values in interface java.util.Map<K,V>
    
    Returns:
    RubyArray
  - valuesAt
```
public RubyArray<V> valuesAt(java.lang.Object... keys)
```
    Finds all the values by given keys.
    
    Parameters:
    keys - to retrieve values
    
    Returns:
    RubyArray
  - valuesAt
```
public RubyArray<V> valuesAt(java.lang.Iterable<?> keys)
```
    Finds all the values by given keys.
    
    Parameters:
    keys - to retrieve values
    
    Returns:
    RubyArray
  - valueʔ
```
public boolean valueʔ(java.lang.Object value)
```
    Checks if the value included.
    
    Parameters:
    value - to be checked
    
    Returns:
    true if value included, false otherwise
  - size
```
public int size()
```
    Specified by:
    
    size in interface java.util.Map<K,V>
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface java.util.Map<K,V>
  - containsKey
```
public boolean containsKey(java.lang.Object key)
```
    Specified by:
    
    containsKey in interface java.util.Map<K,V>
  - containsValue
```
public boolean containsValue(java.lang.Object value)
```
    Specified by:
    
    containsValue in interface java.util.Map<K,V>
  - get
```
public V get(java.lang.Object key)
```
    Specified by:
    
    get in interface java.util.Map<K,V>
  - put
```
public V put(K key,
    V value)
```
    Specified by:
    
    put in interface java.util.Map<K,V>
  - remove
```
public V remove(java.lang.Object key)
```
    Specified by:
    
    remove in interface java.util.Map<K,V>
  - putAll
```
public void putAll(java.util.Map<? extends K,? extends V> m)
```
    Specified by:
    
    putAll in interface java.util.Map<K,V>
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface java.util.Map<K,V>
  - keySet
```
public java.util.Set<K> keySet()
```
    Specified by:
    
    keySet in interface java.util.Map<K,V>
  - entrySet
```
public java.util.Set<java.util.Map.Entry<K,V>> entrySet()
```
    Specified by:
    
    entrySet in interface java.util.Map<K,V>
  - equals
```
public boolean equals(java.lang.Object o)
```
    Specified by:
    
    equals in interface java.util.Map<K,V>
    
    Overrides:
    
    equals in class java.lang.Object
  - hashCode
```
public int hashCode()
```
    Specified by:
    
    hashCode in interface java.util.Map<K,V>
    
    Overrides:
    
    hashCode in class java.lang.Object
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class RubyEnumerable<java.util.Map.Entry<K,V>>

Class RubyHash<K,V>

Nested Class Summary

Nested classes/interfaces inherited from interface java.util.Map

Constructor Summary

Method Summary

Methods inherited from class net.sf.rubycollect4j.RubyEnumerable

Methods inherited from class java.lang.Object

Constructor Detail

RubyHash

RubyHash

RubyHash

Method Detail

of

copyOf

getIterable

assoc

compareByIdentity

comparedByIdentityʔ

delete

deleteIf

deleteIf

setDefault

getDefault

each

eachKey

eachKey

eachPair

eachPair

eachValue

eachValue

emptyʔ

eqlʔ

fetch

fetch

flatten

freeze

frozenʔ

hash

inspect

invert

keepIf

keepIf

key

keys

keyʔ

length

merge

merge

mergeǃ

mergeǃ

put

put

rassoc

rejectǃ

rejectǃ

replace

shift

store

toH

toHash

toS

update

update

allʔ

anyʔ

chunk

collect

collectConcat

count

cycle

cycle

detect

dropWhile

eachEntry

find

findAll

findIndex

flatMap

grep

groupBy