blocks|key|19249|text|据我所知没有，但你可以使用hash+tables来做类似的事情。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|19250|entityMap|0|LINK|mutability|MUTABLE|url|http://www.lispworks.com/documentation/HyperSpec/Body/18_.htm^0|D|B|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Not that I'm aware of, but you can use <a href="http://www.lispworks.com/documentation/HyperSpec/Body/18_.htm" rel="nofollow noreferrer">hash tables</a> for something quite similar.

blocks|key|3800232|text|Lisp哈希表是基于CLOS的。规格here。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3800233|entityMap|0|LINK|mutability|MUTABLE|url|http://clhs.lisp.se/Body/t_hash_t.htm^0|I|4|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Lisp hashtables are CLOS based. Specs <a href="http://clhs.lisp.se/Body/t_hash_t.htm" rel="nofollow noreferrer">here</a>.

blocks|key|2514668|text|要获得快速解决方案，只需使用哈希表，如前所述。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2514669|然而，如果你喜欢更有原则的方法，你可以看看FSet，它是一个“函数式集合论集合库”。其中，它包含集合和包的类和操作。|offset|length|2514670|(EDIT:)最干净的方法可能是将面向集合的操作定义为泛型函数。毕竟，一组泛型函数基本上等同于一个Java接口。您可以简单地在标准散列表类上实现方法作为第一个原型，并允许其他实现。|2514671|entityMap|0|LINK|mutability|MUTABLE|url|http://common-lisp.net/project/fset/^0|0|L|4|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@$D|R|E|S|1|T]]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

For a quick solution, just use hash tables, as has been mentioned before.

However, if you prefer a more principled approach, you can take a look at <a href="http://common-lisp.net/project/fset/" rel="noreferrer">FSet</a>, which is “a functional set-theoretic collections library”. Among others, it contains classes and operations for sets and bags.

(EDIT:) The cleanest way would probably be to define your set-oriented operations as generic functions. A set of generic functions is basically equivalent to a Java interface, after all. You can simply implement methods on the standard HASH-TABLE class as a first prototype and allow other implementations as well.

blocks|key|19429|text|您可以使用列表，尽管它们在表示大型集合时可能被证明效率低下。这可以使用ADJOIN或PUSHNEW将新元素添加到列表中，使用DELETE+or+REMOVE执行相反的操作。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|19430|(let+((set+(list)))
++(pushnew+11+set)
++(pushnew+42+set)
++(pushnew+11+set)+
++(print+set)+;+set={42,11}
++(setq+set+(delete+42+set))
++(print+set))+;+set={11}|code-block|syntax|javascript|19431|需要注意的一件事是，默认情况下，这些操作符使用EQL来测试集合中的潜在重复项(就像Java使用equals方法一样)。对于包含数字或字符的集合，这是可以的，但对于其他对象的集合，应该将诸如EQUAL之类的“更深”相等测试指定为:TEST关键字参数，例如，对于一组字符串:-|19432|(let+((set+(list)))
++(pushnew+"foo"+set+:test+#'equal)
++(pushnew+"bar"+set+:test+#'equal)
++(pushnew+"foo"+set+:test+#'equal)+;+EQUAL+decides+that+"foo"="foo"
++(print+set))+;+set={"bar","foo"}|19433|Lisp相当于Java的一些Set操作，它们是：|19434|SUBSETP|19435|removeAll+SET-DIFFERENCE+or+NSET-DIFFERENCE|unordered-list-item|19436|
|19437|retainAll+INTERSECTION+or+NINTERSECTION|19438|
+INTERSECTION+or+NINTERSECTION的|19439|addAll+->|19440|19441|entityMap|0|LINK|mutability|MUTABLE|url|http://www.lispworks.com/documentation/HyperSpec/Body/m_pshnew.htm|1|http://www.lispworks.com/documentation/HyperSpec/Body/f_rm_rm.htm|2|http://www.lispworks.com/documentation/HyperSpec/Body/f_eql.htm|3|http://www.lispworks.com/documentation/HyperSpec/Body/f_equal.htm|4|http://www.lispworks.com/documentation/HyperSpec/Body/f_subset.htm#subsetp|5|http://www.lispworks.com/documentation/HyperSpec/Body/f_set_di.htm|6|http://www.lispworks.com/documentation/HyperSpec/Body/f_isec_.htm#intersection|7^0|16|7|0|1Q|G|1|0|0|N|3|2|2M|5|3|0|0|0|0|7|4|0|A|X|5|0|0|A|T|6|0|2|T|7|0|0|0^^$0|@$1|2|3|4|5|6|7|1N|8|@]|9|@$A|1O|B|1P|1|1Q]|$A|1R|B|1S|1|1T]]|C|$]]|$1|D|3|E|5|F|7|1U|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|1V|8|@]|9|@$A|1W|B|1X|1|1Y]|$A|1Z|B|20|1|21]]|C|$]]|$1|K|3|L|5|F|7|22|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|23|8|@]|9|@]|C|$]]|$1|O|3|P|5|6|7|24|8|@]|9|@$A|25|B|26|1|27]]|C|$]]|$1|Q|3|R|5|S|7|28|8|@]|9|@$A|29|B|2A|1|2B]]|C|$]]|$1|T|3|U|5|6|7|2C|8|@]|9|@]|C|$]]|$1|V|3|W|5|S|7|2D|8|@]|9|@$A|2E|B|2F|1|2G]]|C|$]]|$1|X|3|Y|5|6|7|2H|8|@]|9|@$A|2I|B|2J|1|2K]]|C|$]]|$1|Z|3|10|5|S|7|2L|8|@]|9|@]|C|$]]|$1|11|3|-4|5|6|7|2M|8|@]|9|@]|C|$]]|$1|12|3|-4|5|6|7|2N|8|@]|9|@]|C|$]]]|13|$14|$5|15|16|17|C|$18|19]]|1A|$5|15|16|17|C|$18|1B]]|1C|$5|15|16|17|C|$18|1D]]|1E|$5|15|16|17|C|$18|1F]]|1G|$5|15|16|17|C|$18|1H]]|1I|$5|15|16|17|C|$18|1J]]|1K|$5|15|16|17|C|$18|1L]]|1M|$5|15|16|17|C|$18|1L]]]]

You could use lists, though they can prove to be inefficient for representing large sets. This is done using ADJOIN or <a href="http://www.lispworks.com/documentation/HyperSpec/Body/m_pshnew.htm" rel="noreferrer">PUSHNEW</a> to add a new element to a list, and <a href="http://www.lispworks.com/documentation/HyperSpec/Body/f_rm_rm.htm" rel="noreferrer">DELETE or REMOVE</a> to do the opposite. 

<pre><code>(let ((set (list)))
 (pushnew 11 set)
 (pushnew 42 set)
 (pushnew 11 set) 
 (print set) ; set={42,11}
 (setq set (delete 42 set))
 (print set)) ; set={11}
</code></pre>

One thing to watch out for is all that these operators use <a href="http://www.lispworks.com/documentation/HyperSpec/Body/f_eql.htm" rel="noreferrer">EQL</a> by default to test for potential duplicates in the set (much as Java uses the equals method). That's OK for sets holding numbers or characters, but for sets of other objects, a `deeper' equality test such as <a href="http://www.lispworks.com/documentation/HyperSpec/Body/f_equal.htm" rel="noreferrer">EQUAL</a> should be specified as a :TEST keyword parameter, e.g. for a set of strings :-

<pre><code>(let ((set (list)))
 (pushnew "foo" set :test #'equal)
 (pushnew "bar" set :test #'equal)
 (pushnew "foo" set :test #'equal) ; EQUAL decides that "foo"="foo"
 (print set)) ; set={"bar","foo"}
</code></pre>

Lisp's counterparts to some of Java's Set operations are:

<ul>
<li>addAll -> <a href="http://www.lispworks.com/documentation/HyperSpec/Body/f_unionc.htm" rel="noreferrer">UNION or NUNION</a></li>
<li>containsAll -> <a href="http://www.lispworks.com/documentation/HyperSpec/Body/f_subset.htm#subsetp" rel="noreferrer">SUBSETP</a></li>
<li>removeAll -> <a href="http://www.lispworks.com/documentation/HyperSpec/Body/f_set_di.htm" rel="noreferrer">SET-DIFFERENCE or NSET-DIFFERENCE</a></li>
<li>retainAll -> <a href="http://www.lispworks.com/documentation/HyperSpec/Body/f_isec_.htm#intersection" rel="noreferrer">INTERSECTION or NINTERSECTION</a></li>
</ul>

blocks|key|3800340|text|看看cl-containers吧。这里有一个set-container类。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3800341|entityMap|0|LINK|mutability|MUTABLE|url|http://common-lisp.net/project/cl-containers/^0|2|D|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Look at <a href="http://common-lisp.net/project/cl-containers/" rel="noreferrer">cl-containers</a>. There is a set-container class.

blocks|key|19488|text|是的，它有套装。请参阅实用的Common+Lisp中的this+section+on+"Sets"。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|19489|基本上，您可以使用pushnew和adjoin创建一个集合，使用member、member-if和member-if-not查询它，并使用intersection、union、set-difference、set-exclusive-or和subsetp等函数将其与其他集合组合。|style|CODE|19490|entityMap|0|LINK|mutability|MUTABLE|url|http://gigamonkeys.com/book/beyond-lists-other-uses-for-cons-cells.html^0|R|M|0|0|9|7|H|6|W|6|13|9|1D|D|1X|C|2A|5|2G|E|2V|G|3C|7|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@$A|U|B|V|F|G]|$A|W|B|X|F|G]|$A|Y|B|Z|F|G]|$A|10|B|11|F|G]|$A|12|B|13|F|G]|$A|14|B|15|F|G]|$A|16|B|17|F|G]|$A|18|B|19|F|G]|$A|1A|B|1B|F|G]|$A|1C|B|1D|F|G]]|9|@]|C|$]]|$1|H|3|-4|5|6|7|1E|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]]]

Yes, it has sets. See <a href="http://gigamonkeys.com/book/beyond-lists-other-uses-for-cons-cells.html" rel="noreferrer">this section on "Sets"</a> from Practical Common Lisp.

Basically, you can create a set with <code>pushnew</code> and <code>adjoin</code>, query it with <code>member</code>, <code>member-if</code> and <code>member-if-not</code>, and combine it with other sets with functions like <code>intersection</code>, <code>union</code>, <code>set-difference</code>, <code>set-exclusive-or</code> and <code>subsetp</code>.

blocks|key|603002|text|使用哈希表可以很容易地解决。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|603003|(let+((h+(make-hash-table+:test+'equalp)))+;+if+you're+storing+symbols
++(loop+for+i+from+0+upto+20
++++++++do+(setf+(gethash+i+h)+(format+nil+"Value+~A"+i)))
++(loop+for+i+from+10+upto+30
++++++++do+(setf+(gethash+i+h)+(format+nil+"~A+eulaV"+i)))
++(loop+for+k+being+the+hash-keys+of+h+using+(hash-value+v)
++++++++do+(format+t+"~A+=>+~A~%25"+k+v)))|code-block|syntax|javascript|603004|输出|603005|0+=>+Value+0
1+=>+Value+1
...
9+=>+Value+9
10+=>+10+eulaV
11+=>+11+eulaV
...
29+=>+29+eulaV
30+=>+30+eulaV|603006|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Easily solvable using a hash table.

<pre><code>(let ((h (make-hash-table :test 'equalp))) ; if you're storing symbols
 (loop for i from 0 upto 20
 do (setf (gethash i h) (format nil "Value ~A" i)))
 (loop for i from 10 upto 30
 do (setf (gethash i h) (format nil "~A eulaV" i)))
 (loop for k being the hash-keys of h using (hash-value v)
 do (format t "~A =&gt; ~A~%" k v)))
</code></pre>

outputs

<pre><code>0 =&gt; Value 0
1 =&gt; Value 1
...
9 =&gt; Value 9
10 =&gt; 10 eulaV
11 =&gt; 11 eulaV
...
29 =&gt; 29 eulaV
30 =&gt; 30 eulaV
</code></pre>

blocks|key|3800420|text|就我个人而言，我只会实现一个函数，它接受一个列表并返回一个唯一的集合。我已经共同起草了一些对我有效的东西：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3800421|(defun+make-set+(list-in+&optional+(list-out+'()))
++(if+(endp+list-in)
++++++(nreverse+list-out)
++++++(make-set
++++++++(cdr+list-in)
++++++++(adjoin+(car+list-in)+list-out+:test+'equal))))|code-block|syntax|javascript|3800422|基本上，当且仅当列表中不存在某一项时，adjoin函数才会以非破坏性方式将该项添加到列表中，并接受一个可选的测试函数(+Common+Lisp+"equal“函数之一)。您也可以使用pushnew来破坏性地执行此操作，但我发现尾递归实现要优雅得多。所以，Lisp确实导出了几个允许您将列表作为集合使用的基本函数；不需要内置的数据类型，因为您可以使用不同的函数将内容预先添加到列表中。|offset|length|style|CODE|3800423|我的所有数据源(不是函数，而是信息)都是Common+Lisp+HyperSpec和Common+Lisp+the+Language+(2nd+Edition)的组合。|3800424|entityMap|0|LINK|mutability|MUTABLE|url|http://www.lispworks.com/documentation/common-lisp.html|1|http://www.cs.cmu.edu/Groups/AI/html/cltl/cltl2.html^0|0|0|J|6|2J|7|0|K|L|0|16|12|1|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@$I|11|J|12|K|L]|$I|13|J|14|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|15|8|@]|9|@$I|16|J|17|1|18]|$I|19|J|1A|1|1B]]|A|$]]|$1|O|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]|W|$5|R|S|T|A|$U|X]]]]

Personally, I would just implement a function which takes a list and return a unique set. I've drafted something together which works for me:

<pre><code>(defun make-set (list-in &amp;optional (list-out '()))
 (if (endp list-in)
 (nreverse list-out)
 (make-set
 (cdr list-in)
 (adjoin (car list-in) list-out :test 'equal))))
</code></pre>

Basically, the <code>adjoin</code> function prepends an item to a list non-destructively if and only if the item is not already present in the list, accepting an optional test function (one of the Common Lisp "equal" functions). You can also use <code>pushnew</code> to do so destructively, but I find the tail-recursive implementation to be far more elegant. So, Lisp does export several basic functions that allow you to use a list as a set; no built-in datatype is needed because you can just use different functions for prepending things to a list.

My data source for all of this (not the function, but the info) has been a combination of the <a href="http://www.lispworks.com/documentation/common-lisp.html" rel="nofollow noreferrer">Common Lisp HyperSpec</a> and <a href="http://www.cs.cmu.edu/Groups/AI/html/cltl/cltl2.html" rel="nofollow noreferrer">Common Lisp the Language (2nd Edition)</a>.

I need something like <a href="http://java.sun.com/j2se/1.5.0/docs/api/java/util/Set.html" rel="noreferrer">this</a>, a collection of elements which contains no duplicates of any element. Does Common Lisp, specifically SBCL, have any thing like this?

Does Common Lisp have a something like java's Set Interface/implementing classes?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我需要像这样的东西，一个不包含任何元素副本的元素集合。Common Lisp，特别是SBCL，有这样的东西吗？

问Common Lisp是否有类似java的Set Interface/implementing类？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Common Lisp是否有类似java的Set Interface/implementing类？EN