在scala中处理状态的不可变方法
在Scala中处理状态的不可变方法是通过使用不可变数据结构和函数式编程的方式来实现的。不可变数据结构是指一旦创建就不能被修改的数据结构，任何对数据结构的修改都会返回一个新的数据结构，而不是在原数据结构上进行修改。
在Scala中，可以使用case class来定义不可变的数据结构。case class是一种特殊的类，它自动生成了一些常用的方法，比如equals、hashCode和toString等。同时，case class的构造函数参数默认是val类型，这意味着它们是不可变的。
除了使用不可变数据结构，函数式编程也是处理状态的不可变方法的关键。函数式编程强调将计算过程看作是一系列函数的组合，而不是一系列状态的修改。在函数式编程中，函数是一等公民，可以作为参数传递给其他函数，也可以作为返回值返回。
在处理状态的不可变方法中，可以使用函数的纯粹性来确保状态不被修改。纯函数是指没有副作用的函数，即函数的返回值仅依赖于输入参数，而不依赖于外部状态。通过使用纯函数，可以避免对状态的修改，从而实现状态的不可变性。
在Scala中，可以使用不可变集合类来处理状态。不可变集合类是指一旦创建就不能被修改的集合类，任何对集合的修改都会返回一个新的集合，而不是在原集合上进行修改。Scala提供了一系列不可变集合类，如List、Set和Map等。
不可变方法的优势包括：
- 线程安全：由于不可变方法不修改状态，所以可以避免多线程并发访问时的竞态条件和死锁等问题。
- 可维护性：不可变方法更易于理解和维护，因为它们没有副作用，不会引入隐藏的状态变化。
- 可测试性：不可变方法更易于测试，因为它们的行为仅依赖于输入参数，不依赖于外部状态。
- 函数式编程支持：不可变方法与函数式编程的理念相契合，可以更好地利用函数式编程的特性，如高阶函数和不可变数据结构。
在Scala中处理状态的不可变方法可以应用于各种场景，包括但不限于：
- 并发编程：不可变方法可以避免多线程并发访问时的竞态条件和死锁等问题，提高并发编程的可靠性和性能。
- 分布式系统：不可变方法可以简化分布式系统的设计和实现，减少状态同步和一致性问题。
- 数据处理：不可变方法可以用于处理大规模数据集，保证数据的一致性和可靠性。
- Web开发：不可变方法可以用于构建可扩展和可维护的Web应用程序，提高开发效率和用户体验。
推荐的腾讯云相关产品和产品介绍链接地址：
- 云服务器（CVM）：提供可扩展的虚拟服务器，支持多种操作系统和应用场景。详情请参考：https://cloud.tencent.com/product/cvm
- 云数据库MySQL版（CDB）：提供高可用、可扩展的关系型数据库服务，支持自动备份和容灾。详情请参考：https://cloud.tencent.com/product/cdb_mysql
- 云原生容器服务（TKE）：提供高度可扩展的容器集群管理服务，支持容器化应用的部署和运行。详情请参考：https://cloud.tencent.com/product/tke
- 人工智能平台（AI Lab）：提供丰富的人工智能算法和工具，支持机器学习和深度学习任务。详情请参考：https://cloud.tencent.com/product/ailab
请注意，以上推荐的腾讯云产品仅供参考，具体选择应根据实际需求和项目要求进行评估。
相关·内容
在Scala中，纯函数的精确定义是什么？纯函数在wiki 上有一个定义。我认为这个定义是用于纯函数式编程语言的。
然而，在类方法和闭包的上下文中，我认为它变得复杂了。
class Ave(val a: Int, val b: Int) {
def ave = (a+b)/2
}
ave是一种纯功能吗？我认为是这样，因为它没有副作用，它只取决于类的不变状态。但这实际上违反了wiki上的纯函数定义，即纯函数一般不应该访问非局部变量。
关于关闭的类似问题：
def fcn(a:Int, b: Int): Unit = {
def ave = (a+b) / 2
}
对我来说，这两个av
浏览 1提问于2016-03-30得票数 2
回答已采纳
目前正在开发一个使用JavaFX 2作为框架的图形用户界面应用程序。在Java中使用，并且了解数据绑定的原理。
由于scala中的函数式编程提倡使用不可改变的值，因此存在差距。
除了为gui提供基于可变fx属性的表示模型，以及为具有转换层的应用程序逻辑提供不可变的模型之外，还有其他解决方案吗？
你好，安德烈亚斯
浏览 1提问于2013-04-02得票数 0
我是scala和演员世界的新手。
这是我到目前为止所学到的：
scala是函数式编程(不是纯粹的)，人们建议不要在Scala中使用可变状态。
但另一方面，也有实现角色模型的akka框架。在玩akka的过程中，我意识到消息是不可变的，但参与者的状态是可变的。因此，我需要在actors内部指定"var“变量和可变集合。而且，对我来说，拥有一个可变的状态对于scala来说是不自然的。
那么，我的理解正确吗？为什么人们在不可变的scala语言中采用可变角色模型？
浏览 5提问于2017-04-09得票数 6
我有一个很大的可变Map对象，它占用了太多的内存，父对象的所有子对象都需要访问或修改相同Map的值。
我正在考虑只是在创建子对象时将可变映射作为构造函数参数传递给所有子对象，以便它们可以相应地访问或修改映射。
我只是想确认SCALA确实传递了对象引用，所以可变Map不会被重新复制，而是所有子对象都将修改相同的Map实例？
浏览 1提问于2015-02-20得票数 3
为了测试Chisel代码，我在我的项目的目录中启动了一个控制台sbt，然后是scala，这里是文件build.sbt。我可以导入chisel3库：
$ cd myproject
$ sbt
sbt:myproject> console
scala> import chisel3._
import chisel3._
然后，我可以测试一些数据类型的凿子代码，例如：
scala> val plop = "b01010101".U(20.W)
plop: chisel3.UInt = UInt<20>(85)
但是我可以测试Reg()或其他Module(
浏览 2提问于2019-11-08得票数 1
回答已采纳
在scala中使用@BeanProperty或创建Set & Get方法，这是正确的方式
浏览 0提问于2013-07-11得票数 0
回答已采纳
我想知道不可变的scala集合(例如immutable.HashMap)是否线程安全。内容显然不会改变，但内部优化的可变状态对我来说是不清楚的。
键和值被假定为不可变。
谢谢你的帮忙
浏览 2提问于2017-01-30得票数 2
回答已采纳
val和var在scala中，我认为这个概念是可以理解的。
我想做这样的事情(比如java)：
trait PersonInfo {
var name: Option[String] = None
var address: Option[String] = None
// plus another 30 var, for example
}
case class Person() extends PersonInfo
object TestObject {
def main(args: Array[String]): Unit = {
val p = ne
浏览 0提问于2012-12-13得票数 2
2回答
医生说：
包scala.collection.immutable中的集合对于每个人来说都是不可变的。这样的集合在创建之后永远不会改变。
但我不明白我期望的行为：
scala> var test3 = scala.collection.immutable.Set[String]("one", "two")
test3: scala.collection.immutable.Set[String] = Set(one, two)
scala> test3 += "three"
scala> println(test3)
浏览 1提问于2016-06-02得票数 2
回答已采纳
在我发表这个问题之前，我已经阅读了上面的文章。显然，如果您在val中存储某物，则不能修改它，但是如果您存储一个可变集合(如ArrayBuffer )，则可以修改它！
scala> val b = ArrayBuffer[Int](1,2,3)
b: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3)
scala> b += 1
res50: b.type = ArrayBuffer(1, 2, 3, 1)
scala> b
res51: scala.collection.mutable.Arr
浏览 1提问于2013-11-16得票数 3
回答已采纳
3回答
我只是在学习用scala编程。我有一些函数式编程的经验，就像我在面向对象编程方面的经验一样。我的问题很简单，但也很棘手：
在Scala中应该使用哪些结构？我们应该只使用不可变的，例如。通过迭代来修改列表并将一个新列表粘合在一起，还是使用可变的？你对此有什么看法，性能方面，内存相关方面，...
我可能会以函数式风格编程，但它通常会扩展到疯狂的工作量，以完成那些通过使用可变变量很容易完成的事情。它依赖于环境吗，使用什么？
浏览 0提问于2013-01-10得票数 5
回答已采纳
2回答
我对Akka框架和并发概念相当陌生。从Akka文档中，我了解到Actor邮箱中一次只能处理一条消息。因此，单个线程将同时处理Actor的状态。我的疑问是，因此，将Actor状态/数据变量声明为可变的-‘Var’(仅当'Val‘不适合时)，不会导致并发情况下的Actor状态不一致。我正在使用Scala进行开发。在下面的Master actor中，worker的详细信息存储在一个可变变量“worker”中。这会是并发的问题吗？
class Master extends PersistentActor with ActorLogging {
...
private var
浏览 1提问于2015-10-03得票数 4
4回答
我有一个Actor，它的本质是维护一个对象列表。它有三个基本操作，添加、更新和删除(有时从add方法调用remove，但除此之外)，并使用单个集合。显然，该支持列表是并发访问的，添加和删除调用不断地相互交错。
我的第一个版本使用了一个ListBuffer，但我在某个地方读到了它不是用于并发访问的。我没有得到并发访问异常，但我确实注意到，在其中查找和删除对象并不总是有效的，可能是由于并发。
我正在重新编写它以使用var列表，但从Scala的默认不可变列表中删除项有点痛苦-而且我怀疑它是否适合并发访问。
因此，基本问题是:在并发访问情况下，我应该使用什么集合类型，以及如何使用它？
(也许是次要的:
浏览 0提问于2011-11-24得票数 11
我在Scala中使用了以下示例来说明我的困惑：
import java.util.HashMap
val jhm = new HashMap[String, Int]
jhm.put("myId", 1)
jhm.put("yourId", 2)
它允许添加到"jhm“中
现在，如果我在Scala中这样做：
val nmap = Map()
nmap += ("myId" -> 1)
它不允许这是预期的。我的问题是:为什么它允许在第一种情况下更改不可变的"val“？
浏览 0提问于2017-05-24得票数 0
在Odersky等人的Scala书中，他们说使用列表。我还没有读过这本书的封面，但所有的例子似乎都使用了val List。据我所知，我们也鼓励人们在vars上使用vars。但是，在大多数应用程序中，在使用var列表还是使用val MutableList之间不存在权衡吗？显然，我们可以使用val列表。，但使用大量var列表(或var Vectors等)是很好的实践吗？
我对来自C#的Scala非常陌生。在那里我有很多：
public List<T> myList {get; private set;}
如果C#内置了不变性，则可以很容易地将集合声明为vals，因为集合本身在构造后从未
浏览 1提问于2012-06-12得票数 14
回答已采纳
情况是这样的。我正在Scala中创建一个简单的会话处理程序，我需要一个可以存储列表的类。该类需要与其关联的其他函数才能正常工作。
我将通过会话ID访问会话，我很少遍历我将不断添加和从列表中删除的列表
我的问题：
在这种情况下，适当的Scala对象是什么？
从所说的Scala对象中添加或删除实体的最佳方法是什么？
我对Scala相当陌生，所以请原谅我可能提出的基本问题。如能提供任何协助，将不胜感激。
编辑:要在其中添加all...Thread安全性是一个因素。所使用的对象必须是线程安全的，或者在按会话ID添加和删除项时必须容易允许线程安全。
浏览 5提问于2013-03-19得票数 1
回答已采纳
2回答
我正在通过Coursera课程学习Scala。
我们正在学习从函数上思考，并在可能的情况下使用尾递归来实现函数/方法。
作为一个列表函数上的foreach的例子，我们教会了如何实现它，如下所示：
def foreach[T](list: List[T], f: [T] => Unit) {
if (!list.isEmpty) foreach(list.tail) else f(list.head)
}
然后，当我在一些Scala apis中发现以下实现时，我感到很惊讶：
override /*IterableLike*/
def foreach[B](f: A =>
浏览 0提问于2015-07-12得票数 7
1回答
我正试图了解在星火中突变的状态。不过，我最初认为我应该在下一个操作中使用返回值；相反，这似乎是对同一个实例的引用，并且状态实际上是在同一个Dataset中变异的。
这是否意味着火花实际上正在改变数据集的状态？也就是说，它是否意味着数据集并不是纯功能性的，因为它持有可变状态？或者，这和会议有某种联系吗？如果是这样的话，请再说一次；从功能上讲，这意味着数据集仍然包含可变状态，即使它是通过代理进行的。
scala> var x = sc.parallelize(List(1, 2, 3)).toDS
x: org.apache.spark.sql.Dataset[Int] = [value:
浏览 0提问于2018-11-08得票数 0
回答已采纳
我在scala中看到了3种映射类型：
scala.collection.Map
scala.collection.immutable.Map
scala.collection.mutable.Map
不可变性与可变性的对比非常合理，似乎predef有一个直接指向immutable.Map的映射别名。不过，我不明白为什么会有scala.collections.Map。
此外，看起来JavaConversions.mapAsJavaMap只接受scala.collections.Map，而不接受不可变的？
浏览 2提问于2015-05-18得票数 0
我们写了很多关于不可变状态的优点的文章，但是在Scala中有一些常见的情况，在这种情况下，选择可变类是有意义的吗？(这是一个Scala新手问题，来自具有“经典”OOP设计背景的人，使用可变类。)
对于一些琐碎的东西，比如三维点类，我得到了不可变的优点。但是，类似马达类的东西呢，它暴露了各种控制变量和/或传感器读数？经验丰富的Scala开发人员通常会编写这样的类吗？在这种情况下，'setSpeed‘方法会在内部被表示为'val’而不是'var'，而‘’方法会返回类的一个新实例吗？类似地，每一次从传感器中读取描述电机内部状态的新读数都会导致一个新的马达实例被实例化吗
浏览 1提问于2013-09-30得票数 11
我正在使用Array Buffers创建可变长度的数组。
import scala.collection.mutable.ArrayBuffer
val b = ArrayBuffer[Int]() // empty array!
b += (1, 2, 3, 5) // append and output: ArrayBuffer(1, 2, 3, 5)
现在我想把变量b赋给a
var a = Array[Int]() // a(0) = 10 // error because a is empty array
a = b.toArray // Array(1, 1, 2)
相反，如果我想
浏览 0提问于2016-04-13得票数 0
1回答
你认为Scala如何帮助我们编写像Redis这样的分布式内存服务(但多线程)？
Scala编程鼓励我们使用不可变数据，以避免共享数据和竞争条件，然而在这种数据存储中，不可变数据对我们没有帮助(我认为)。
阻塞线程将是解决方案吗？
浏览 0提问于2013-12-06得票数 0
我想要创建可变地图，其中包含字符串作为键，MutableList作为值。
val myMap = scala.collection.mutable.Map[String, MutableList]()
就像这样：
mymap = Map("a" -> MutableList(1, 2, 3), "b" -> MutableList(5, 6, 7))
但是，当我试图创建它时，会引发错误：
scala> var myval = scala.collection.mutable.Map[String, scala.collection.mutabl
浏览 1提问于2015-08-06得票数 2
回答已采纳
依赖于来自Scala的reply，我认为Actor似乎非常容易出错。这真的是角色之间进行对话的惯用的Scala方式吗？是否有其他选择，或更安全的使用reply，我错过了？
(关于我:我熟悉Java中的同步，但我以前从未设计过基于参与者的系统，也还没有完全理解这种模式。)
示例错误
对于一个简单的演示，让我们来看看这个愚蠢的整数解析行为者：
import actors._, Actor._
val a = actor {
loop {
react {
case s: String => reply(s.toInt)
}
}
}
我们可以用这个作为
sc
浏览 4提问于2013-01-03得票数 0
回答已采纳
2回答
我使用的是Akka库。
当多个参与者在一个对象上调用一个函数时会发生什么？这会阻止其他参与者访问该对象吗？
我问这个的原因是因为我想在akka演员中使用JBCrypt。因为我们可以同时加密多个字符串，所以我让每个参与者调用JBcrypt.hash(...)。我不确定它是如何工作的，因为我认为，在scala中，对象存在于一个地方，并且我觉得使用同一对象(库)的多个参与者可能会阻止并发的实际发生。
浏览 0提问于2017-12-05得票数 1
在对的评论中，Josh Sureth指出了非方法本地var是Scala代码中问题的原因。
这个页面是谷歌对短语non-method-local vars的唯一点击，那么它是什么意思，问题是什么？
浏览 1提问于2012-05-05得票数 5
回答已采纳
def sort(s:String)={
val a= s.toCharArray ()
scala.util.Sorting.quickSort(array)
new String(a)
}
在保持对QuickSort的调用的同时，是否有一种更简单的方式来编写上面的内容？
为什么快速排序会改变数组，而不是返回一个新数组(这不是函数语言应该做的吗?)
浏览 5提问于2013-07-04得票数 0
回答已采纳
我有一份的工作，我需要计算有多少书面项目满足一些业务规则。(PS:由于遗留原因，我使用Spring批处理3.0.x)
我必须记住，如果发生回滚，则必须忽略相同事务(即相同块)中先前已计数的项。因此，我不能直接从Writer中更新JobExecutionContext，而是在ChunkContext中更新一个属性，并且在块成功后才使用CustomChunkListener来更新JobExecutionContext (如下面的代码所示)。
在进行多线程步骤之前，我得到了如下实现，如预期的那样工作(我尽可能地简化了代码以关注这个问题)：
CustomItemWriter
public class
浏览 4提问于2020-04-20得票数 2
1回答
我正在学习Scala，我不得不说我真的很喜欢它。我正在移植到Scala，这是我以前的一个Java项目，尝试在我可以/知道如何使用时利用该语言(主要是模式匹配和尝试使用vals，而不是递归或函数)。
在java项目中，我有一个HashMap，它一开始是空的，然后使用一些方法填充。然后，当然，我会使用hmap.get(key)来检索对象。这一次我想使用一个不可变的HashMap，但是我有点纠结它！下面是我的代码：
val recipes = new HashMap[String,Any]()
private def addCrucibleRecipe(tag: String, tagAddon:
浏览 4提问于2015-11-03得票数 0
我知道Scala完全接受了不变性。
现在我在想一个场景，我必须在一个类或类似的类中保存一些状态(通过变量)。我需要稍后更新这些变量；然后我可以稍后重新访问类以访问更新后的变量。
我将用一个非常简单的例子来让它变得简单：
class A {
var x: Int
def compute: Int = {calling some other processes or such using x as input}
}
.
def invoker() {
val a: A = new A
a.x = 1
......
val res1 = a.compute
a.x = 5
浏览 0提问于2013-05-31得票数 3
scala> def judge(func: ()=> Boolean) {
| val result = func()
| println(result)
| }
judge: (func: () => Boolean)Unit
scala> def compare = { 6 > 4 }
compare: Boolean
scala> judge(compare)
<console>:10: error: type mismatch;
found : Boolean
required: ()
浏览 0提问于2014-01-13得票数 0
1回答
我正在阅读scala的实际操作(人员配置版)，其中有一个关于这个模式的章节，其中有一个代码示例：
class PureSquare(val side: Int) {
def newSide(s: Int): PureSquare = new PureSquare(s)
def area = side * side
}
这本书应该有一个链接来解释这个模式。不幸的是，链接断了，我找不到它。
有人能解释这个模式以及这段代码应该如何工作吗？
因为我不知道在调用area函数时如何调用newSide。
谢谢
浏览 5提问于2013-09-25得票数 1
回答已采纳
1回答
我正在阅读第二版Scala的编程(这本书很棒，比scala的网站更好地以一种非科学的方式解释事情)，我在浏览不变和可变的集合时注意到了this...oddity。
它将以下声明声明为不可变集
var jetSet=Set("Boeing", "Airbus")
jetSet+="Lear"
println(jetSet.contains("Cessna"))
然后声明只有可变集才定义+=方法。好吧，这很有道理。问题是这段代码工作正常。在REPL中测试时创建的集合的类型实际上是不可变的集合，但是它定义了+=方法，它的功能非常好。看
浏览 1提问于2014-10-20得票数 6
回答已采纳
我在Scala中有一个类，它有一个方法，可以在构造函数中提供的列表上使用foreach顺序执行一组计算。该类有一个字段val progress: Array[Boolean] = list.map(_ => false).toArray。其中一些计算可能需要很长时间，因此在每次计算结束时，我都会在progress中将适当的索引设置为true。然后，我可以让progress从类外确定我在计算中的位置。
这似乎并不是Scala中最好的方法(因为我使用的是可变的数据结构)，因此，任何改进它的建议都会受到欢迎。
浏览 7提问于2016-01-15得票数 1
回答已采纳
我想知道如果Scala不(必须)遵循Java的java.io.Serializable/java.lang.Cloneable (主要是为了与Java及其周围的工具/生态系统保持兼容)，这些功能性会有多大的不同(以及实现会有多大的不同)。
因为Scala在语言设计上更简单，但支持更强大的实现和抽象可能性，所以可以想象，与Java相比，Scala可能会走一条不同的道路，如果它不需要承担Java兼容性负担的话。
我可以想象，惯用的实现将使用类型类或带有(可能)私有字段/方法的特征(在Java接口中是不可能的？)，可能带有一些标准实现？
或者，标记接口仍然是Scala的正确选择吗？
浏览 1提问于2011-06-12得票数 11
回答已采纳
2回答
我是scala的新手，我正试图通过编写一个简单的程序来学习scala，以检查是否给出一个字符串，每个打开的偏执狂都有自己的闭括号。例如，对于字符串“{ssss{{}”，答案应为false。我使用的代码如下：
package recfun
import common._
import scala.collection.mutable.Stack
object Main{
def main(args: Array[String]) {
println(balance("{{ssss{{}}}}}".toList))
}
def balance(chars: List[Char
浏览 3提问于2016-05-13得票数 1
回答已采纳
2回答
继承设计模式的不可变性
、、、
我正在Scala中实现一些代码，下面是Java教程。
本教程有一段代码，可以最小化为以下代码：
public abstract class A {
private int id;
public A(String name) {
id = Helper.getId(name);
fetchAllAttributes();
}
protected abstract void fetchAllAttributes();
protected int fetchAttribute(String attribute) {
浏览 0提问于2018-05-15得票数 1
回答已采纳
2回答
在命令式Scala代码中，我有一个算法：
def myProcessor(val items: List) {
var numProcessed = 0
while(numProcessed < items.size) {
val processedSoFar = items.size - numProcessed
numProcessed += processNextBlockOfItems(items, processedSoFar)
}
}
我希望保留“块处理”功能，而不仅仅是在条目列表上执行"takeWhile“。我怎样才能用函数式重写它呢？
浏览 1提问于2014-03-05得票数 4
回答已采纳
2回答
scala.collection.mutable.Map说。
为了提高效率，重写方法foreach和size也是个好主意。
重写size (可能)是O(n)到O(1)的改进。
但是重写foreach的价值是什么？
浏览 8提问于2013-12-21得票数 2
回答已采纳
4回答
我有Scala的代码
class MyClass {
private val myData: Map[String, MyClass2] = new HashMap[String, MyClass2]()
def someMethod = {
synchronized(myData) {
val id = getSomeId
if (myData.containsKey(id)) myData = myData.remove(id)
else Log.d("123", "Not found!"
浏览 2提问于2013-06-15得票数 4
回答已采纳
在Scala中是否有一个类似map的函数来呈现：M[A] -> M[B]，但也允许您指定一些类似于scanLeft的上下文信息？例如，类似这样的内容： def mapWithContext(context: C, f: (C, A) => (C, B)): M[B] 将向f传递1)类型C的上下文信息2)类型A的列表中的当前元素，然后它将返回1)更新的上下文信息C 2)类型B的转换的列表元素。然而，与scanLeft不同的是，它将丢弃它正在构建的集合中的上下文信息，而只返回B的
浏览 22提问于2019-12-05得票数 1
回答已采纳
我知道在Haskell中，State monad很有用，因为没有可变变量(除非我们在IO monad中)。
然而，Scala是怎么回事呢？在有可变变量的语言中，State Monad有用吗？
从某种意义上说，State Monad所允许的就是。例如：
newtype Labeled anytype = Labeled (S -> (S, anytype))
instance Monad Labeled where
return contents = Labeled (\st -> (st, contents))
Labeled fst0 >>= f
浏览 2提问于2017-04-05得票数 3
我只是在玩scala，并且做了一些非常基本的Val分配，参见下面，如果我重新分配val，它看起来就像一个var。
scala> val number = 17
number: Int = 17
scala> println(number)
17
scala> val number = 20
number: Int = 20
scala> number
res1: Int = 20
scala> val string = "ABC1234"
string: String = ABC1234
scala> println(string)
浏览 2提问于2013-09-09得票数 0
回答已采纳
2回答
我知道Scala有var (表示可变状态)，但纯函数式编程不鼓励使用任何可变状态，而是专注于将val用于所有事情。
来自一个势在必行的世界，很难放弃可变状态。
我的问题是，什么时候可以在Scala代码中使用var？仅仅使用val就可以完成所有的代码吗？如果是，那么为什么Scala有var？
浏览 0提问于2012-10-27得票数 17
回答已采纳
2回答
可变集合中的Scala协变量类型
、、、、
我是Scala世界的新手，现在我正在阅读"Scala in Action“一书(由Nilanjan Raychaudhuri撰写)，即第97页中称为”可变对象需要不变“的部分，我不理解直接摘自上述书的以下部分。
假设ListBuffer是协变的，下面的代码片段可以工作，没有任何编译问题：
scala> val mxs: ListBuffer[String] = ListBuffer("pants")
mxs: scala.collection.mutable.ListBuffer[String] =
ListBuffer(pants)
scala> val
浏览 3提问于2018-03-21得票数 2
3回答
这里有一个有状态类，但是据说scala中的类应该是无状态的，在多线程环境中有状态对象可能会出错。所以有人能帮我把它转换成一个无状态类吗？
trait SwitchStrategy {
def shouldSwitch: Boolean
}
object Strategies {
def countdown(counts: Int): SwitchStrategy = {
return new SwitchStrategy {
private[this] var count = 0
override def shouldSwitch: Boolean
浏览 4提问于2016-03-31得票数 1
回答已采纳
3回答
有人告诉我(Scala) Actor实际上从来不会同时执行两个操作，这意味着行为(或react？或接收？)方法本身就是同步的。我知道act方法中的长操作可能会导致阻塞问题，我假设对消息队列的访问必须以某种方式同步……但是..。
建议的是，actor接收到通知它递增内部计数器的消息时，将以threadsafe的方式递增计数器。不会同时处理两个更新消息，因此不会有两个消息尝试同时更新计数器。
参与者中的计数器属性听起来像“共享状态”。
这样的操作真的是完全threadsafe的吗？如果是这样的话，参与者如何以某种有效的方式使用多个核心机器？演员是如何实现多线程的呢？
如果没有，那么在不需要一些同步
浏览 3提问于2012-09-13得票数 6
回答已采纳
6回答
在Java语言中，我使用LinkedHashMap来实现这一目的。Java的LinkedHashMap文档非常清楚，它具有“可预测的迭代顺序”，我也需要在Scala中使用同样的顺序。
Scala有ListMap和LinkedHashMap，但是关于它们具体做什么的文档很少。
问:Scala的LinkedHashMap或ListMap是用于此目的的实现吗？如果没有，除了直接使用Java的LinkedHashMap之外，还有什么其他的选择呢？
浏览 4提问于2010-10-01得票数 45
回答已采纳
我在找人帮忙做我的业余项目。我试图找到一个更好的方法，在我的拉模式下的Manager如何处理任务列表更新(需要完成的工作列表)
我已经实现了一个拉模式，其中有一个工作工厂，经理和工人。Manager在akka调度程序的帮助下从作业工厂获得新的作业。每当有新的工作，工人得到通知，并开始咀嚼。
在我的实现中，可能有些奇怪的是，工作人员会产生新的任务，这些任务也必须完成。目前，我已经用从工作人员到自己的递归消息来解决这个问题。
以下是非常简单的观点：
class Worker extends Actor {
def receive = {
case Work0 ⇒ self ! Work
浏览 0提问于2018-05-09得票数 0
回答已采纳
1回答
我从了解到，没有一种标准的Scala方法可以动态更改数据结构。在我的例子中，我将构建一个树，其中的值存储在节点上。随着处理的进行，将发生两个变化。树将生长(新叶子萌发)，并且节点上的值将发生变化。对于这种结构，有没有更好的Scala方法？
浏览 0提问于2014-05-01得票数 0
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
即时通信 IM活动推荐
腾讯云开发者
