在 Clojure 中，是否有一种简单的方法可以在列表类型之间进行转换？

vec, set and generally into are your friends to easily "convert" to another collection type.

How do you want to transform a vector of maps into a map of maps? You need a key, can you provide use with sample input/expected output?

For vectors there is the vec function

user=> (vec '(1 2 3))
[1 2 3]

For lazy sequences there is the lazy-seq function

user=> (lazy-seq [1 2 3])
(1 2 3)

For converting into sets, there is the set function

user=> (set [{:a :b, :c :d} {:a :b} {:a :b}])
#\{\{:a :b} {:a :b, :c :d}}

Let's not forget that trusty old into lets you take anything seqable (list, vector, map, set, sorted-map) and an empty container you want filled, and puts it into it.

(into [] '(1 2 3 4)) ==> [1 2 3 4]         "have a lazy list and want a vector"
(into #{} [1 2 3 4]) ==> #{1 2 3 4}        "have a vector and want a set"
(into {} #{[1 2] [3 4]}) ==> {3 4, 1 2}    "have a set of vectors want a map"
(into #{} [{1 2} {3 4}]) ==> #\{\{1 2} {3 4}} "have a vector of maps want a set of maps"

into is a wrapper around conj, which is the base abstraction for inserting new entries appropriately into a collection based on the type of the collection. The principle that makes this flow so nicely is that Clojure is build on composable abstractions, in this case into on top of conj on top of collection and seq.

The above examples would still compose well if the recipient was being passed in at run time: because the underlying abstractions (seq and conj) are implemented for all the collections (and many of Java's collections also), so the higher abstractions don't need to worry about lots of special data-related corner cases.

To convert a vector to a list you can also use for, like this:

=> (for [i [1 2 3 4]] i)
(1 2 3 4)

When you don't want to manipulate the data, just use seq on the vector:

=> (seq [1 2 3])
(1 2 3)

There is no need to convert a vector to a list. Clojure will treat a vector as it would treat a list - as a sequence - when a sequence is required. For example,

user=> (cons 0 [1 2 3])
(0 1 2 3)

If you need to make sure that the vector is being treated as a sequence, wrap it in seq:

user=> (conj [1 2 3] 0) ; treated as a vector
[1 2 3 0]


user=> (conj (seq [1 2 3]) 0) ; treated as a sequence
(0 1 2 3)

If you have a vector of maps, and you want a set of maps, it doesn't matter that the vector holds maps. You just convert the vector to a set as usual:

user=> (set [{:a 1, :b 2} {"three" 3, "four" 4}])
#\{\{:a 1, :b 2} {"four" 4, "three" 3}}

One more answer for converting from a list to a map (for the sake of completeness) - from here:

(apply hash-map '(1 2 3 4))
;=>{1 2, 3 4}