LazyMap (wflib-java 0.6.1-g24f8de8 API)

java.lang.Object
- net.wildfyre.utils.LazyMap<K,V>

Type Parameters:

K - the type of the keys

V - the type of the values

All Implemented Interfaces:

Map<K,V>
```
public class LazyMap<K,V>
extends Object
implements Map<K,V>
```
Represents a Map object that is lazily-instantiated. This class is a wrapper around an underlying Map.
The basic idea is that, if the map is not initialized, it is considered empty.

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

Constructor Summary

Constructors
Constructor and Description
`LazyMap()` Creates an empty object.
`LazyMap(Collection<V> objects, Function<V,K> IDMapper)` Creates a lazy map from a given collection.
`LazyMap(int size)` Creates an empty lazy map of specified capacity.
`LazyMap(Map<K,V> map)` Creates a lazy map from the given map.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`clear()`
`boolean`	`containsKey(Object key)`
`boolean`	`containsValue(Object value)`
`Set<Map.Entry<K,V>>`	`entrySet()`
`boolean`	`equals(Object o)`
`V`	`get(Object key)`
`int`	`hashCode()`
`boolean`	`isEmpty()`
`protected boolean`	`isInitialized()` Is this object initialized?
`Set<K>`	`keySet()`
`V`	`put(K key, V value)`
`void`	`putAll(Map<? extends K,? extends V> m)`
`V`	`remove(Object key)`
`protected void`	`requireInitialized()` Specifies that, in the case where this object is not initialized, it should be initialized now before further exploitation.
`int`	`size()`
`Collection<V>`	`values()`

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

Methods inherited from interface java.util.Map
compute, computeIfAbsent, computeIfPresent, forEach, getOrDefault, merge, putIfAbsent, remove, replace, replace, replaceAll

- Constructor Detail
  - LazyMap
```
public LazyMap()
```
    Creates an empty object.
    The default capacity of the Map created by this constructor is voluntarily unspecified, as it may depend on how the underlying map is instantiated, later in the life of this object. If the capacity is important to you, use LazyMap(int) instead.
  - LazyMap
```
public LazyMap(int size)
```
    Creates an empty lazy map of specified capacity.
    In this case, the underlying map object is a HashMap, see HashMap.HashMap(int).
    
    Parameters:
    
    size - the capacity of the underlying map object.
  - LazyMap
```
public LazyMap(Map<K,V> map)
```
    Creates a lazy map from the given map. Note that no copying is involved, the LazyMap's internal map will merely point to the provided reference (which makes this call really performance & memory-efficient, but might cause problems if you apply modifications on the given map).
    
    Parameters:
    
    map - the map object that will be used as underlying map.
  - LazyMap
```
public LazyMap(Collection<V> objects,
               Function<V,K> IDMapper)
```
    Creates a lazy map from a given collection. This constructor assumes that the key of the Map can be retrieved from the values. This is especially useful in cases where the LazyMap is used to store some data that has an ID.
    Here is an example of call, assuming we want to store Users, indexed by their ID:
```
 Collection<User> users = ...
 LazyMap<Integer, User> map = new LazyMap<>(users, u -> u.getID());
 
```
    Parameters:
    
    objects - the values that will be stored in the map
    
    IDMapper - the way to get the key from an object
- Method Detail
  - isInitialized
```
protected boolean isInitialized()
```
    Is this object initialized?
    
    Returns:
    
    true if this object is initialized.
  - requireInitialized
```
protected void requireInitialized()
```
    Specifies that, in the case where this object is not initialized, it should be initialized now before further exploitation.
  - size
```
public int size()
```
    Specified by:
    
    size in interface Map<K,V>
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface Map<K,V>
  - containsKey
```
public boolean containsKey(Object key)
```
    Specified by:
    
    containsKey in interface Map<K,V>
  - containsValue
```
public boolean containsValue(Object value)
```
    Specified by:
    
    containsValue in interface Map<K,V>
  - get
```
public V get(Object key)
```
    Specified by:
    
    get in interface Map<K,V>
  - put
```
public V put(K key,
             V value)
```
    Specified by:
    
    put in interface Map<K,V>
  - remove
```
public V remove(Object key)
```
    Specified by:
    
    remove in interface Map<K,V>
  - putAll
```
public void putAll(Map<? extends K,? extends V> m)
```
    Specified by:
    
    putAll in interface Map<K,V>
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface Map<K,V>
  - keySet
```
public Set<K> keySet()
```
    Specified by:
    
    keySet in interface Map<K,V>
  - values
```
public Collection<V> values()
```
    Specified by:
    
    values in interface Map<K,V>
  - entrySet
```
public Set<Map.Entry<K,V>> entrySet()
```
    Specified by:
    
    entrySet in interface Map<K,V>
  - equals
```
public boolean equals(Object o)
```
    Specified by:
    
    equals in interface Map<K,V>
    
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Specified by:
    
    hashCode in interface Map<K,V>
    
    Overrides:
    
    hashCode in class Object

Class LazyMap<K,V>

Nested Class Summary

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Map

Constructor Detail

LazyMap

LazyMap

LazyMap

LazyMap

Method Detail

isInitialized

requireInitialized

size

isEmpty

containsKey

containsValue

get

put

remove

putAll

clear

keySet

values

entrySet

equals

hashCode