Maps

A Map is a data structure that maps keys to values. A map cannot contain duplicate keys and each key can map to at most one value.

Implements Container interface.

type Map interface {
    Put(key interface{}, value interface{})
    Get(key interface{}) (value interface{}, found bool)
    Remove(key interface{})
    Keys() []interface{}
    containers.Container
    // Empty() bool
    // Size() int
    // Clear()
    // Values() []interface{}
}

A BidiMap is an extension to the Map. A bidirectional map (BidiMap), also called a hash bag, is an associative data structure in which the key-value pairs form a one-to-one relation. This relation works in both directions by allow the value to also act as a key to key, e.g. a pair (a,b) thus provides a coupling between ‘a’ and ‘b’ so that ‘b’ can be found when ‘a’ is used as a key and ‘a’ can be found when ‘b’ is used as a key.

type BidiMap interface {
    GetKey(value interface{}) (key interface{}, found bool)
    Map
}

HashMap

A map based on hash tables. Keys are unordered.

Implements Map, JSONSerializer and JSONDeserializer interfaces.

package main
import "github.com/emirpasic/gods/maps/hashmap"
func main() {
    m := hashmap.New() // empty
    m.Put(1, "x")      // 1->x
    m.Put(2, "b")      // 2->b, 1->x (random order)
    m.Put(1, "a")      // 2->b, 1->a (random order)
    _, _ = m.Get(2)    // b, true
    _, _ = m.Get(3)    // nil, false
    _ = m.Values()     // []interface {}{"b", "a"} (random order)
    _ = m.Keys()       // []interface {}{1, 2} (random order)
    m.Remove(1)        // 2->b
    m.Clear()          // empty
    m.Empty()          // true
    m.Size()           // 0
}

TreeMap

A map based on red-black tree. Keys are ordered ordered with respect to the comparator.

Implements Map, IteratorWithKey, EnumerableWithKey, JSONSerializer and JSONDeserializer interfaces.

package main
import "github.com/emirpasic/gods/maps/treemap"
func main() {
    m := treemap.NewWithIntComparator() // empty (keys are of type int)
    m.Put(1, "x")                       // 1->x
    m.Put(2, "b")                       // 1->x, 2->b (in order)
    m.Put(1, "a")                       // 1->a, 2->b (in order)
    _, _ = m.Get(2)                     // b, true
    _, _ = m.Get(3)                     // nil, false
    _ = m.Values()                      // []interface {}{"a", "b"} (in order)
    _ = m.Keys()                        // []interface {}{1, 2} (in order)
    m.Remove(1)                         // 2->b
    m.Clear()                           // empty
    m.Empty()                           // true
    m.Size()                            // 0
    // Other:
    m.Min() // Returns the minimum key and its value from map.
    m.Max() // Returns the maximum key and its value from map.
}

LinkedHashMap

A map that preserves insertion-order. It is backed by a hash table to store values and doubly-linked list to store ordering.

Implements Map, IteratorWithKey, EnumerableWithKey, JSONSerializer and JSONDeserializer interfaces.

package main
import "github.com/emirpasic/gods/maps/linkedhashmap"
func main() {
    m := linkedhashmap.New() // empty (keys are of type int)
    m.Put(2, "b")            // 2->b
    m.Put(1, "x")            // 2->b, 1->x (insertion-order)
    m.Put(1, "a")            // 2->b, 1->a (insertion-order)
    _, _ = m.Get(2)          // b, true
    _, _ = m.Get(3)          // nil, false
    _ = m.Values()           // []interface {}{"b", "a"} (insertion-order)
    _ = m.Keys()             // []interface {}{2, 1} (insertion-order)
    m.Remove(1)              // 2->b
    m.Clear()                // empty
    m.Empty()                // true
    m.Size()                 // 0
}

HashBidiMap

A map based on two hashmaps. Keys are unordered.

Implements BidiMap, JSONSerializer and JSONDeserializer interfaces.

package main
import "github.com/emirpasic/gods/maps/hashbidimap"
func main() {
    m := hashbidimap.New() // empty
    m.Put(1, "x")          // 1->x
    m.Put(3, "b")          // 1->x, 3->b (random order)
    m.Put(1, "a")          // 1->a, 3->b (random order)
    m.Put(2, "b")          // 1->a, 2->b (random order)
    _, _ = m.GetKey("a")   // 1, true
    _, _ = m.Get(2)        // b, true
    _, _ = m.Get(3)        // nil, false
    _ = m.Values()         // []interface {}{"a", "b"} (random order)
    _ = m.Keys()           // []interface {}{1, 2} (random order)
    m.Remove(1)            // 2->b
    m.Clear()              // empty
    m.Empty()              // true
    m.Size()               // 0
}

TreeBidiMap

A map based on red-black tree. This map guarantees that the map will be in both ascending key and value order. Other than key and value ordering, the goal with this structure is to avoid duplication of elements (unlike in HashBidiMap), which can be significant if contained elements are large.

Implements BidiMap, IteratorWithKey, EnumerableWithKey, JSONSerializer and JSONDeserializer interfaces.

package main
import (
    "github.com/emirpasic/gods/maps/treebidimap"
    "github.com/emirpasic/gods/utils"
)
func main() {
    m := treebidimap.NewWith(utils.IntComparator, utils.StringComparator)
    m.Put(1, "x")        // 1->x
    m.Put(3, "b")        // 1->x, 3->b (ordered)
    m.Put(1, "a")        // 1->a, 3->b (ordered)
    m.Put(2, "b")        // 1->a, 2->b (ordered)
    _, _ = m.GetKey("a") // 1, true
    _, _ = m.Get(2)      // b, true
    _, _ = m.Get(3)      // nil, false
    _ = m.Values()       // []interface {}{"a", "b"} (ordered)
    _ = m.Keys()         // []interface {}{1, 2} (ordered)
    m.Remove(1)          // 2->b
    m.Clear()            // empty
    m.Empty()            // true
    m.Size()             // 0
}