blocks|key|1749402|text|Scala|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1749403|您可以从另一种语言中的方法调用任一语言的方法。|blockquote|1749404|http://www.scala-lang.org/faq/4|offset|length|1749405|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|V|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Q|8|@]|9|@]|A|$]]|$1|E|3|F|5|6|7|R|8|@]|9|@$G|S|H|T|1|U]]|A|$]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|J|$K|$5|L|M|N|A|$O|F]]]]

Scala

<blockquote>
 You can call the methods of either language from methods in the other one
</blockquote>

<a href="http://www.scala-lang.org/faq/4" rel="nofollow noreferrer">http://www.scala-lang.org/faq/4</a>

blocks|key|1403228|text|在我看来，你已经知道你的选择是什么了，你只是对其中任何一个都不满意。以下是我对你提供的三种选择的看法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1403229|Functional+--这个看起来最适合您。它适合您的所有需求，但您不喜欢文档。从我的角度来看，这些文档看起来很基本，但是很有用。他们的代码段应该能让你快速起床和运行。学习曲线似乎几乎不存在，这将有助于缓解缺乏文档。FYI，核心Java的TreeMap也是基于红黑树的.|offset|length|style|BOLD|1403230|Scala+--如果我处在你的位置上，我会做出这样的选择。您似乎不想学习一种新的语言，但是Scala是一个从Java到Scala的非常简单的转换。一开始，您可以编写非常类似java的代码，并慢慢地采用更多的功能习惯用法。Java+<->+Scala互操作在两个方向上都非常出色。|1403231|--尽管我非常喜欢Clojure，但由于java开发人员的语法和陡峭的学习曲线，在这个特殊的情况下很难推荐它。|1403232|entityMap|0|LINK|mutability|MUTABLE|url|http://functionaljava.org/examples/1.5/|1|http://java.sun.com/j2se/1.4.2/docs/api/java/util/TreeMap.html^0|0|0|B|1X|3|0|3C|7|1|0|0|5|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@$D|X|E|Y|F|G]]|9|@$D|Z|E|10|1|11]|$D|12|E|13|1|14]]|A|$]]|$1|H|3|I|5|6|7|15|8|@$D|16|E|17|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|18|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|M|$N|$5|O|P|Q|A|$R|S]]|T|$5|O|P|Q|A|$R|U]]]]

It seems to me you already know what your options are, you just aren't happy with any of them. Here is my take on the three choices you've provided:

Functional Java - This one seems like the best fit for you. It fits all of your requirements except that you don't like the documentation. From my perspective the documentation looks basic, but serviceable. Their <a href="http://functionaljava.org/examples/1.5/" rel="noreferrer">code snippets</a> should get you up and running quickly. The learning curve seems almost non-existent which should help mitigate the lack of documentation. FYI, core Java's <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/util/TreeMap.html" rel="noreferrer">TreeMap</a> is based on a Red-Black tree as well. 

Scala - This is the choice I would make if I was in your shoes. You seem to not want to learn a new language, but Scala is a very easy transition from Java. You can write very java-like code at first, and slowly adopt more functional idioms. The Java &lt;-> Scala interop is excellent in both directions as well.

Clojure - As much as I love Clojure, its tough to recommend in this particular instance due to the radically different syntax and steep learning curve for a java developer.

blocks|key|199319|text|也许谷歌的番石榴库会有一些用处：https://code.google.com/p/guava-libraries/wiki/ImmutableCollectionsExplained|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|199320|entityMap|0|LINK|mutability|MUTABLE|url|https://code.google.com/p/guava-libraries/wiki/ImmutableCollectionsExplained^0|G|24|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]]]]

Perhaps Google's guava-libraries may be of some use:
<a href="https://code.google.com/p/guava-libraries/wiki/ImmutableCollectionsExplained" rel="nofollow">https://code.google.com/p/guava-libraries/wiki/ImmutableCollectionsExplained</a>

blocks|key|1404499|text|我花了一些时间让Clojure持久/不变的数据结构在Java中工作，使用合理的构造函数和泛型作为Pure4J的一部分。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1404500|这还包括@ImmutableValue类，以确保集合不仅不可变，而且您输入的值也是不可变的。|style|CODE|1404501|希望这能有所帮助。|1404502|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/robmoffat/pure4j^0|1C|6|0|0|4|F|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@$A|S|B|T|1|U]]|C|$]]|$1|D|3|E|5|6|7|V|8|@$A|W|B|X|F|G]]|9|@]|C|$]]|$1|H|3|I|5|6|7|Y|8|@]|9|@]|C|$]]|$1|J|3|-4|5|6|7|Z|8|@]|9|@]|C|$]]]|K|$L|$5|M|N|O|C|$P|Q]]]]

I've spent some time making the Clojure persistent/immutable data-structures work in Java, with sensible constructors and generics as part of <a href="https://github.com/robmoffat/pure4j" rel="nofollow">Pure4J</a>.

This also includes <code>@ImmutableValue</code> class for ensuring that not only are the collections immutable, but the values you put in them are immutable too.

Hope this helps.

This is very similar to another question (<a href="https://stackoverflow.com/questions/1683430/functional-data-structures-in-java">Functional Data Structures in Java</a>) but the answers there are not particularly useful.

I need to use immutable versions of the standard Java collections (e.g. HashMap / TreeMap / ArrayList / LinkedList / HashSet / TreeSet). By "immutable" I mean immutable in the functional sense (e.g. <a href="http://en.wikipedia.org/wiki/Purely_functional" rel="nofollow noreferrer">purely functional data structures</a>), where updating operations on the data structure do not change the original data, but instead return a new instance of the same kind of data structure. Also typically new and old instances of the data structure will share immutable data to be efficient in time and space.

From what I can tell my options include:

<ul>
<li><a href="http://functionaljava.org/" rel="nofollow noreferrer">Functional Java</a></li>
<li><a href="http://www.scala-lang.org/" rel="nofollow noreferrer">Scala</a></li>
<li><a href="http://clojure.org/" rel="nofollow noreferrer">Clojure</a></li>
</ul>

but I'm not sure whether any of these are particularly appealing to me. I have a few requirements/desirements:

<ul>
<li>the collections in question should be usable directly in Java (with the appropriate libraries in the classpath). FJ would work for me; I'm not sure if I can use Scala's or Clojure's data structures in Java w/o having to use the compilers/interpreters from those languages and w/o having to write Scala or Clojure code.</li>
<li>Core operations on lists/maps/sets should be possible w/o having to create function objects with confusing syntaxes (FJ looks slightly iffy)</li>
<li>They should be efficient in time and space. I'm looking for a library which ideally has done some performance testing. FJ's <a href="http://functionaljava.googlecode.com/svn/artifacts/2.22/javadoc/index.html" rel="nofollow noreferrer">TreeMap</a> is based on a red-black tree, not sure how that rates.</li>
<li>Documentation / tutorials should be good enough so someone can get started quickly using the data structures. FJ fails on that front.</li>
</ul>

Any suggestions?

java: libraries for immutable functional-style data structures

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

这与另一个问题()非常相似，但答案并不特别有用。我需要使用标准Java集合的不变版本(例如，HashMap / TreeMap / ArrayList / LinkedList / HashSet / TreeSet)。所谓“不可变”，我指的是功能意义上的不可变(例如)，其中对数据结构的更新操作不改变原始数据，而是返回...

问java:用于不可变功能样式数据结构的库
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问java:用于不可变功能样式数据结构的库EN