blocks|key|1370575|text|如果你需要随机访问大向量排序的结果，那么调用vec所花费的时间应该远远超过这样做所节省的时间。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1370576|如果你分析发现它太慢了，你可能不得不使用java数组。|1370577|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

If you need to random access on the result of sort with huge vectors, then the time took by the call to vec should be far outweighed by time savings of doing so.

If you profile and find that it is too slow, you'll probably have to use java arrays.

blocks|key|1155554|text|根据我自己的测试(没有什么科学依据)，在进行大量排序的情况下，直接处理数组可能会更好。但是如果你很少排序，并且有很多随机访问要做，那么使用向量可能是一个更好的选择，因为随机访问时间平均要快40%25以上，但排序性能很糟糕，因为要将向量转换为数组，然后再转换回向量。这是我的发现：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1155555|(def+foo+(int-array+(range+1000)))

(time
++(dotimes+[_+10000]
++++(java.util.Arrays/sort+foo)))

;+Elapsed+time:+652.185436+msecs

(time
++(dotimes+[_+10000]
++++(nth+foo+(rand-int+1000))))

;+Elapsed+time:+7.900073+msecs

(def+bar+(vec+(range+1000)))

(time
++(dotimes+[_+10000]
++++(vec+(sort+bar))))

;+Elapsed+time:+2810.877103+msecs

(time
++(dotimes+[_+10000]
++++(nth+bar+(rand-int+1000))))

;+Elapsed+time:+5.500802+msecs|code-block|syntax|javascript|1155556|附注:请注意，向量版本实际上不会将排序后的向量存储在任何地方，但这不会显著改变结果，因为您将在循环中使用简单的绑定来提高速度。|1155557|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

From my own tests (nothing scientific) you may be better with working directly on arrays in cases where you do lots of sorting. But if you sort rarely and have a lots of random access to do though, going with a vector may be a better choice as random access time is more than 40% faster on average, but the sorting performance is horrible due to converting the vector to an array and then back to a vector. Here's my findings:

<pre><code>(def foo (int-array (range 1000)))

(time
 (dotimes [_ 10000]
 (java.util.Arrays/sort foo)))

; Elapsed time: 652.185436 msecs

(time
 (dotimes [_ 10000]
 (nth foo (rand-int 1000))))

; Elapsed time: 7.900073 msecs

(def bar (vec (range 1000)))

(time
 (dotimes [_ 10000]
 (vec (sort bar))))

; Elapsed time: 2810.877103 msecs

(time
 (dotimes [_ 10000]
 (nth bar (rand-int 1000))))

; Elapsed time: 5.500802 msecs
</code></pre>

P.S.: Note that the vector version doesn't actually store the sorted vector anywhere, but that shouldn't change the result considerably as you would use simple bindings in a loop for speed.

blocks|key|1155602|text|Meikel+Brandmeyer刚刚在Clojure小组上发布了一个解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1155603|(defn+sorted-vec
++[coll]
++(let+[arr+(into-array+coll)]
++++(java.util.Arrays/sort+arr)
++++(vec+arr)))|code-block|syntax|javascript|1155604|Clojure的sort跨排序数组返回一个seq；这种方法的作用与此大致相同，但返回的是一个向量，而不是一个seq。|offset|length|style|CODE|1155605|如果愿意，您甚至可以跳过转换回Clojure持久数据结构的过程：|1155606|(defn+sorted-arr
++"Returns+a+*mutable*+array!"
++[coll]
++(doto+(into-array+coll)]
++++(java.util.Arrays/sort))|1155607|但是得到的Java数组(在大多数情况下，您可以将其视为Clojure集合)将是可变的。如果您没有将它交给其他代码，这是很好的，但要小心。|1155608|entityMap^0|0|0|8|4|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@$I|X|J|Y|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|10|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

Meikel Brandmeyer just posted a solution to this on the Clojure group.

<pre><code>(defn sorted-vec
 [coll]
 (let [arr (into-array coll)]
 (java.util.Arrays/sort arr)
 (vec arr)))
</code></pre>

Clojure's <code>sort</code> returns a seq across a sorted array; this approach does much the same thing, but returns a vector, not a seq.

If you wish, you can even skip the conversion back into a Clojure persistent data structure:

<pre><code>(defn sorted-arr
 "Returns a *mutable* array!"
 [coll]
 (doto (into-array coll)]
 (java.util.Arrays/sort))
</code></pre>

but the resulting Java array (which you can treat as a Clojure collection in most cases) will be mutable. That's fine if you're not handing it off to other code, but be careful.

blocks|key|1370753|text|作为一个新的Clojure开发人员，很容易混淆集合和序列。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1370754|这个排序后的向量函数：|1370755|(排序1+2+3+4+5+6)+=>+(1+2+3+4+5+6)；返回一个序列|1370756|但我需要下一个操作的向量，因为这不起作用...|1370757|(take-while+(partial+>+3)+(1+2+3+4+5+6))|1370758|无法将=>ClassCastException+java.lang.Long强制转换为clojure.lang.IFn用户/+cast+2251+(NO_SOURCE_FILE:2136)|1370759|让我们尝试将序列转换为向量：|1370760|(vec+(1+2+3+4+5+6))|1370761|无法将=>ClassCastException+java.lang.Long强制转换为clojure.lang.IFn用户/valu2253+(NO_SOURCE_FILE:2139)|1370762|不是的！但如果你把它们放在一起，它就会工作得很好。|1370763|(take-while+(部分>+3)+(排序1+2+3+4+5+6))|1370764|=>(1+2)|1370765|教训:你不能直接使用序列！它们是这个过程中的中间步骤。当REPL尝试计算(1+2+3+4+5+6)时，它会看到一个函数并抛出异常：|1370766|(%251%252%253%254%255%25+6)无法将=>ClassCastException+java.lang.Long强制转换为clojure.lang.IFn用户/user+2263+(NO_SOURCE_FILE:2146)|1370767|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|13|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|14|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|15|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|16|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|17|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|18|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|19|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|1A|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1B|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|1C|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|1D|8|@]|9|@]|A|$]]|$1|V|3|W|5|6|7|1E|8|@]|9|@]|A|$]]|$1|X|3|Y|5|6|7|1F|8|@]|9|@]|A|$]]|$1|Z|3|10|5|6|7|1G|8|@]|9|@]|A|$]]|$1|11|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|12|$]]

As a new Clojure developer, it is easy to confuse collections and sequences.

This sorted vector function:

(sort [1 2 3 4 5 6])
=> (1 2 3 4 5 6) ; returns a sequence

But I need a vector for the next operation because this does not work...

(take-while (partial > 3) (1 2 3 4 5 6))

=>ClassCastException java.lang.Long cannot be cast to clojure.lang.IFn user/eval2251 (NO_SOURCE_FILE:2136)

Let us try to convert the sequence to a vector:

(vec (1 2 3 4 5 6))

=>ClassCastException java.lang.Long cannot be cast to clojure.lang.IFn user/eval2253 (NO_SOURCE_FILE:2139)

Nope! But if you put it all together, it works just fine.

(take-while (partial > 3) (sort [1 2 3 4 5 6]))

=>(1 2)

The lesson: You cannot work with sequences directly! They are an intermediate step in the process.
When the REPL tries to evaluate (1 2 3 4 5 6), it sees a a function and throws an exception:

(1 2 3 4 5 6)
=>ClassCastException java.lang.Long cannot be cast to clojure.lang.IFn user/eval2263 (NO_SOURCE_FILE:2146)

How can I cast a sequence back to vector after a sequence producing operation (like sort)? Does using (vec..) on a sequence that was a vector is costly? 

One (bad?) possibility is creating a new vector out of sequence:

<pre><code>(vec (sort [1 2 3 4 5 6]))
</code></pre>

I am asking because I need random access (nth ..) to huge sorted vectors - which are now huge sequences after the sort, with horrible O(n) random access time

Clojure: sequence back to vector

数据结构

Java

在序列生成操作(如排序)之后，如何将序列转换回向量？使用(vec..)作为载体的序列是昂贵的吗？一个(不好？)可能性是无序地创建一个新的向量：(vec (sort [1 2 3 4 5 6]))我问是因为我需要随机访问(nth ..)大的排序向量-现在是排序后的大序列，具有可怕的O(n)随机访问时间

问Clojure:返回到向量的序列
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Clojure:返回到向量的序列EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Clojure:返回到向量的序列
EN