How to populate a hashmap through iteration or recursion in clojure?

As Alan Thompson says, reduce is the general purpose tool for iterating over a sequence and accumulating a result. But if you need to make many "independent" changes, as here you associate keys in a map with values that don't depend on anything but the key, there are better tools. map is the general purpose tool for producing a new sequence based on an old one, and into is for turning sequences into maps. So, you can write

(into {}
      (map (fn [n] [n (abundance n)])
           (range 1 301)))

Note that (fn [n] [n (abundance n)]) could also be written (juxt identity abundance), though it's up to you which you find clearer.

Personally I don't like writing (map (fn [n] ...)) - usually if you need a (one-argument) lambda, for is a better tool than map. The into/for pairing is very common for tasks like this:

(into {}
      (for [n (range 1 301)]
        [n (abundance n)]))

I would not at all recommend using an atom just for a "more imperative feel". There are good times to use an atom, but beginners don't run into them super quickly, and this isn't one of them.

Just wanted to add a reduce code example to @amalloy's answer:

  (let [keys [:a :b :c :d :e :f :g]
        vals [1  2  3  4  5  6  7]]
      (map vector keys vals))

  => ([:a 1] [:b 2] [:c 3] [:d 4] [:e 5] [:f 6] [:g 7])

  
  (let [keys [:a :b :c :d :e :f :g]
        vals [1  2  3  4  5  6  7]]
    (reduce
      (fn [a [k v]] (assoc a k v))
      {}
      (map vector keys vals)))
  => {:a 1, :b 2, :c 3, :d 4, :e 5, :f 6, :g 7}

This uses reduce with an "accumulator function". For each iteration, the function is called with the old value of the map and a new key-value pair. It assoc's in the new value and returns a new map with an extra key-value pair. The initial value is provided as the second argument to reduce (the {} empty map).

Reduce is a good option here, starting from my favorite template project:

(ns tst.demo.core
  (:use demo.core tupelo.core tupelo.test))

(verify
  (let [result (reduce  (fn [accum item]
                          (assoc accum item (str "item " item)))
                 {} ; initial empty map
                 (range 5)) ; list of items to add
                 ]
    (is= result
      {0 "item 0"
       1 "item 1"
       2 "item 2"
       3 "item 3"
       4 "item 4"})))

If you want a more imperative-style solution, you can always accumulate the result into an atom:

(verify
  (let [accum (atom {})]
    (doseq [idx (range 5)]
      (swap! accum
        #(assoc % idx (str "item " idx))))
    (is= @accum
      {0 "item 0"
       1 "item 1"
       2 "item 2"
       3 "item 3"
       4 "item 4"})))