`clojure.core/array-map`¶

Type: function Added: Clojure 1.0 Examples: 5 Runnable: 3

([] [& keyvals])

Constructs an array-map. If any keys are equal, they are handled as if by repeated uses of assoc.

Examples¶

by Jacolyte on 2010-07-27

by kumarshantanu on 2010-09-05

by steveminer on 2011-04-23 . May have evaluation errors.

by TradeIdeasPhilip on 2016-05-16

;; Sometimes Clojure will automatically choose between a hash map and
;; an array map.  What's the rule?  Let's try a few experiments.

;; Start with a quick way to make a map with N items.
(defn make-map [count] (zipmap (range count) (range count)))
;; => #'user/make-map
(make-map 3)
;; => {0 0, 1 1, 2 2}

;; Try a few maps.  The cutoff seems to be 9.5.  If you have fewer than
;; 9.5 items you get an array map.  If you have more than 9.5 items you
;; get a hash map.
(type (make-map 8))
;; => clojure.lang.PersistentArrayMap
(type (make-map 9))
;; => clojure.lang.PersistentArrayMap
(type (make-map 10))
;; => clojure.lang.PersistentHashMap
(type (make-map 11))
;; => clojure.lang.PersistentHashMap

;; Using assoc we get similar results.  9 or fewer items yields an array
;; map.  10 or more yields a hash map.
(type (assoc (make-map 9) :x 1))  ; 10 items -> hash map.
;; => clojure.lang.PersistentHashMap
(type (assoc (make-map 8) :x 1))  ; 9 items -> array map.
;; => clojure.lang.PersistentArrayMap
(type (assoc (make-map 8) :x 1 :y 2))  ; 10 items -> hash map.
;; => clojure.lang.PersistentHashMap
(type (assoc (assoc (make-map 8) :x 1) :y 2))  ; 10 items -> hash map.
;; => clojure.lang.PersistentHashMap

;; But when we use { and } to create a map, the cutoff seems to move to 8.5.
;; A map with 9 items created with assoc or zipmap would be an array map,
;; but a map with 9 items created by { } is a hash map.
(type {0 0, 1 1, 2 2, 3 3, 4 4, 5 5, 6 6, 7 7})  ; 8 items -> array map.
;; => clojure.lang.PersistentArrayMap
(type {0 0, 1 1, 2 2, 3 3, 4 4, 5 5, 6 6, 7 7, 8 8})  ; 9 items -> hash
;; => clojure.lang.PersistentHashMap

;; Calling dissoc on an array map always yields an array map, regardless of
;; the size of the map.
;; Let's start by making a large array map then remove a few items.  This will
;; give us array maps larger than you could create with assoc.
(def array20 (apply array-map (range 40)))
;; => #'user/array20
(type array20)
;; => clojure.lang.PersistentArrayMap
(type (dissoc array20 6))
;; => clojure.lang.PersistentArrayMap
(count (dissoc array20 6))
;; => 19
(type (dissoc array20 6 2))
;; => clojure.lang.PersistentArrayMap
(count (dissoc array20 6 2))
;; => 18

;; Calling dissoc on a hash map always yields another hash map, regardless
;; of the size of the map.
;; Let's start by making a large hash map then remove a lot of items.  This
;; will give us hash maps smaller than you could create with assoc.
(type (make-map 40))
;; => clojure.lang.PersistentHashMap
(type (apply dissoc (make-map 40) (range 1 80)))
;; => clojure.lang.PersistentHashMap
(count (apply dissoc (make-map 40) (range 1 80)))
;; => 1
(apply dissoc (make-map 40) (range 1 80))
;; => {0 0}
(type (apply dissoc (make-map 40) (range 0 80)))
;; => clojure.lang.PersistentHashMap
(count (apply dissoc (make-map 40) (range 0 80)))
;; => 0
(apply dissoc (make-map 40) (range 0 80))
;; => {}

by tomdl89 on 2022-07-28 . May have evaluation errors.

Note by Jacolyte¶

The definition is kind of short, IMO. More descriptively, array-map creates a mapping with arrays being the keys and the values. It doesn't seem like array-map cares whether or not the keys/values are arrays, although it doesn't seem to like sequences.

Note by steveminer¶

An array-map maintains the insertion order of the keys. Look up is linear, which is not a problem for small maps (say less than 10 keys). If your map is large, you should use hash-map instead.

When you assoc onto an existing array-map, the result is a new array-map with the new key as the first key. The rest of the keys are in the same order as the original. Functions such as seq and keys will respect the key order.

Note that assoc will decide to return a hash-map if the result is too big to be efficient.

clojure.core/array-map¶

Examples¶

Note by Jacolyte¶

Note by steveminer¶

See also¶

`clojure.core/array-map`¶