Java 如何在scala中进行增量重构？

我有这样一个代码：

var index = 0
var array: Array[String] = //initialized

functionOne(array(index))
index = index + 1
functionTwo(array(index))
index = index + 1

---

这个想法很清楚——每次从数组中获取元素时，我都需要增加索引。使用java，只需编写

index++

interead即可复制

index=index+1

。是否有一种模式/api可以用scala重构上面的代码？

您的想法是强制性的，而不是功能性的。如果您想将函数应用于Scala中数组中的每个元素，那么惯用的方法是使用map函数，这样您就可以：

val elements = Array(1,2,3,4,5)
val results = elements map { x => x+4}

如果需要使用函数调用中每个元素的索引，则使用zip和索引将数组转换为成对的数组（或序列），如下所示：

scala> elements.zipWithIndex
res0: Array[(Int, Int)] = Array((1,0), (2,1), (3,2), (4,3), (5,4), (6,5))

然后，您可以再次应用映射，这一次应用一个函数，该函数采用一对而不是单个元素：

scala> elements.zipWithIndex map { case (x,y) => (x, y*5) }
res2: Array[(Int, Int)] = Array((1,0), (2,5), (3,10), (4,15), (5,20), (6,25))

或

如果要为每个索引应用不同的函数，则只需在映射闭包中提供不同的定义：

scala> elements.zipWithIndex map { 
   case (0, y) => y + 45
 | case (1, y) => y + 5
 | case (_, y) => y
 | }

---

你的思维是强制性的，而不是功能性的。如果您想将函数应用于Scala中数组中的每个元素，那么惯用的方法是使用map函数，这样您就可以：

val elements = Array(1,2,3,4,5)
val results = elements map { x => x+4}

如果需要使用函数调用中每个元素的索引，则使用zip和索引将数组转换为成对的数组（或序列），如下所示：

scala> elements.zipWithIndex
res0: Array[(Int, Int)] = Array((1,0), (2,1), (3,2), (4,3), (5,4), (6,5))

然后，您可以再次应用映射，这一次应用一个函数，该函数采用一对而不是单个元素：

scala> elements.zipWithIndex map { case (x,y) => (x, y*5) }
res2: Array[(Int, Int)] = Array((1,0), (2,5), (3,10), (4,15), (5,20), (6,25))

或

如果要为每个索引应用不同的函数，则只需在映射闭包中提供不同的定义：

scala> elements.zipWithIndex map { 
   case (0, y) => y + 45
 | case (1, y) => y + 5
 | case (_, y) => y
 | }

---

你的思维是强制性的，而不是功能性的。如果您想将函数应用于Scala中数组中的每个元素，那么惯用的方法是使用map函数，这样您就可以：

val elements = Array(1,2,3,4,5)
val results = elements map { x => x+4}

如果需要使用函数调用中每个元素的索引，则使用zip和索引将数组转换为成对的数组（或序列），如下所示：

scala> elements.zipWithIndex
res0: Array[(Int, Int)] = Array((1,0), (2,1), (3,2), (4,3), (5,4), (6,5))

然后，您可以再次应用映射，这一次应用一个函数，该函数采用一对而不是单个元素：

scala> elements.zipWithIndex map { case (x,y) => (x, y*5) }
res2: Array[(Int, Int)] = Array((1,0), (2,5), (3,10), (4,15), (5,20), (6,25))

或

如果要为每个索引应用不同的函数，则只需在映射闭包中提供不同的定义：

scala> elements.zipWithIndex map { 
   case (0, y) => y + 45
 | case (1, y) => y + 5
 | case (_, y) => y
 | }

---

你的思维是强制性的，而不是功能性的。如果您想将函数应用于Scala中数组中的每个元素，那么惯用的方法是使用map函数，这样您就可以：

val elements = Array(1,2,3,4,5)
val results = elements map { x => x+4}

如果需要使用函数调用中每个元素的索引，则使用zip和索引将数组转换为成对的数组（或序列），如下所示：

scala> elements.zipWithIndex
res0: Array[(Int, Int)] = Array((1,0), (2,1), (3,2), (4,3), (5,4), (6,5))

然后，您可以再次应用映射，这一次应用一个函数，该函数采用一对而不是单个元素：

scala> elements.zipWithIndex map { case (x,y) => (x, y*5) }
res2: Array[(Int, Int)] = Array((1,0), (2,5), (3,10), (4,15), (5,20), (6,25))

或

如果要为每个索引应用不同的函数，则只需在映射闭包中提供不同的定义：

scala> elements.zipWithIndex map { 
   case (0, y) => y + 45
 | case (1, y) => y + 5
 | case (_, y) => y
 | }

---

Scala没有增量运算符。您可以就地使用

索引+=1

。请参阅

Scala没有增量运算符。您可以就地使用

索引+=1

。请参阅

Scala没有增量运算符。您可以就地使用

索引+=1

。请参阅

Scala没有增量运算符。您可以就地使用

索引+=1

。请参考

如果用例是为数组的每个元素调用不同的函数，则需要更简洁的解决方案

var array: Array[String] = ??? // intialized
// as many functions as needed
val functions = Array(functionOne, functionTwo, functionThree);  

(array zip functions) foreach { case (el, f) => f(el) }

---

这是一个更一般的想法的例子，如果您不使用索引值做任何事情，只使用它访问集合，那么可能有一种方法根本不需要索引。

如果用例是为数组的每个元素调用不同的函数，则需要一个更简洁的解决方案

var array: Array[String] = ??? // intialized
// as many functions as needed
val functions = Array(functionOne, functionTwo, functionThree);  

(array zip functions) foreach { case (el, f) => f(el) }

---

这是一个更一般的想法的例子，如果您不使用索引值做任何事情，只使用它访问集合，那么可能有一种方法根本不需要索引。

如果用例是为数组的每个元素调用不同的函数，则需要一个更简洁的解决方案

var array: Array[String] = ??? // intialized
// as many functions as needed
val functions = Array(functionOne, functionTwo, functionThree);  

(array zip functions) foreach { case (el, f) => f(el) }

---

这是一个更一般的想法的例子，如果您不使用索引值做任何事情，只使用它访问集合，那么可能有一种方法根本不需要索引。

如果用例是为数组的每个元素调用不同的函数，则需要一个更简洁的解决方案

var array: Array[String] = ??? // intialized
// as many functions as needed
val functions = Array(functionOne, functionTwo, functionThree);  

(array zip functions) foreach { case (el, f) => f(el) }

---

---

这是一个更一般的想法的示例，如果您不使用索引值，只使用它访问集合，然后可能有一种方法根本不需要索引。

你可以使用

index+=1

。你可以使用

index+=1

。你可以使用

index+=1

。你可以使用

index+=1

。关于应用数组元素不同函数的问题。例如，

functionOne

和

functionTwo

是不同的函数调用。在这种情况下，您只需在映射闭包中使用不同的函数定义…一个根据传入索引而变化的函数定义…映射中的情况非常糟糕。如果OP希望首先调用一个函数，然后在第二个函数上调用另一个函数，依此类推，那么更好的方法是

（array.toList zip List（functionOne，functionTwo，[etc.]）。foreach（case（el，f）=>f（el））

？是-好的观点。这真的更干净更可读。关于应用数组元素的不同函数的问题。例如，

functionOne

和

functionTwo

是不同的函数调用。在这种情况下，您只需在映射闭包中使用不同的函数定义…一个根据传入索引而变化的函数定义…映射中的情况非常糟糕。如果OP希望首先调用一个函数，然后在第二个函数上调用另一个函数，依此类推，那么更好的方法是类似于

（array.toList zip List（functio