Java 如何循环二维数组中的元素以在“中”中构造字符串；Ruby函数式风格"；

Ruby大量使用“functional concept”中的函数，例如map，每个。它们实际上依赖于一个自包含函数，在Ruby中称之为块

在二维数组中循环，生成元素的字符串是非常常见的

在java中，它可能看起来像

   public String toString(){
        String output = "[";
        for (int i =0; i<array.length; i++) {
            output+= "Row "+(i+1)+" : ";
            for (int j=0; j<array[0].length;j++ ) {
                output += array[i][j]+", ";
            }
            output += "\n";
        }

        return output += "]";
    }

公共字符串toString（）{
字符串输出=“[”；
对于（int i=0；i相同的东西，但更短，块更少

  def to_s
        output = "[\n"
        @data.each_with_index do |row,i|
            output << "Row #{i+1} : #{row.join(',')}\n"
        end

        output+"]"
    end

def to_s
output=“[\n”
@data.each_与_索引do |行，i|
输出相同，但更短，块数更少

  def to_s
        output = "[\n"
        @data.each_with_index do |row,i|
            output << "Row #{i+1} : #{row.join(',')}\n"
        end

        output+"]"
    end

def to_s
output=“[\n”
@data.each_与_索引do |行，i|
输出这里有一个没有可变变量的方法：

def to_s
  (
    [ "[" ] +
    @data.map.with_index { |row,i| "Row #{i+1} : #{row * ','}" } +
    [ "]" ]
  ).join("\n")
end

下面是一个没有可变变量的方法：

def to_s
  (
    [ "[" ] +
    @data.map.with_index { |row,i| "Row #{i+1} : #{row * ','}" } +
    [ "]" ]
  ).join("\n")
end

每当您看到模式时：

初始化累加器（在您的情况下，
输出
）
在某个集合的每次迭代中修改累加器（在您的例子中，附加到累加器）
返回蓄能器
这是一个
折叠
，或者用Ruby术语来说是一个
注入

实际上，这有点重复。折叠是一种通用的迭代方法：可以通过对集合元素进行迭代来表示的所有内容也可以表示为对集合进行折叠。换句话说，
可枚举的所有方法（包括
每个
！）也可以定义为
inject
作为原始方法，而不是
每个

这样想：集合可以是空的，也可以是当前元素。没有第三个选项，如果您涵盖了这两种情况，那么您已经涵盖了所有内容。
fold
包含两个参数：一个参数告诉它在集合为空时该做什么，另一个参数告诉它如何处理当前元素或者，换一种方式：您可以将集合视为一系列指令，
fold
是这些指令的解释器。只有两种指令：
END
指令和
值（el）
指令。您可以将这两条指令的解释器代码提供给
文件夹

在Ruby中，第二个参数不是参数列表的一部分，而是块

那么，作为一个
折叠

def to_s
  @data.each_with_index.inject("[\n") do |acc, (row, i)|
    acc + "Row #{i+1} : #{row.join(',')}\n"
  end + ']'
end

如果您想知道
每个带有_索引的_
是否会用一些非功能性杂质感染您的代码，请放心，您可以通过将索引包含在累加器中同样轻松地消除它：

def to_s
  @data.inject(["[\n", 1]) do |(s, i), row|
    [s + "Row #{i} : #{row.join(',')}\n", i+1]
  end.first + ']'
end

还要注意的是，在第一种情况下，使用
每个带有索引的\u
，我们实际上并没有做任何“有趣”的事情对于累加器，与第二种情况不同，在第二种情况下，我们使用累加器对索引进行计数。事实上，第一种情况实际上是一种限制形式的
折叠
，它并没有使用所有的功能。它实际上只是一个
映射
：

def to_s
  "[\n" + @data.map.with_index(1) do |row, i|
    "Row #{i} : #{row.join(',')}\n"
  end.join + ']'
end

在我个人看来，在这里使用（可变）字符串追加而不是字符串串联实际上是完全可以的：

def to_s
  "[\n" << @data.map.with_index(1) do |row, i|
    "Row #{i} : #{row.join(',')}\n"
  end.join << ']'
end

不幸的是，这不仅破坏了IRb的语法突出显示，而且也破坏了我的大脑；-）
每当你看到模式时：

初始化累加器（在您的情况下，
输出
）
在某个集合的每次迭代中修改累加器（在您的例子中，附加到累加器）
返回蓄能器
这是一个
折叠
，或者用Ruby术语来说是一个
注入

实际上，这有点重复。折叠是一种通用的迭代方法：可以通过对集合元素进行迭代来表示的所有内容也可以表示为对集合进行折叠。换句话说，
可枚举的所有方法（包括
每个
！）也可以定义为
inject
作为原始方法，而不是
每个

这样想：集合可以是空的，也可以是当前元素。没有第三个选项，如果您涵盖了这两种情况，那么您已经涵盖了所有内容。
fold
包含两个参数：一个参数告诉它在集合为空时该做什么，另一个参数告诉它如何处理当前元素或者，换一种方式：您可以将集合视为一系列指令，
fold
是这些指令的解释器。只有两种指令：
END
指令和
值（el）
指令。您可以将这两条指令的解释器代码提供给
文件夹

在Ruby中，第二个参数不是参数列表的一部分，而是块

那么，作为一个
折叠

def to_s
  @data.each_with_index.inject("[\n") do |acc, (row, i)|
    acc + "Row #{i+1} : #{row.join(',')}\n"
  end + ']'
end

如果您想知道
每个带有_索引的_
是否会用一些非功能性杂质感染您的代码，请放心，您可以通过将索引包含在累加器中同样轻松地消除它：

def to_s
  @data.inject(["[\n", 1]) do |(s, i), row|
    [s + "Row #{i} : #{row.join(',')}\n", i+1]
  end.first + ']'
end

还要注意的是，在第一种情况下，使用
每个带有索引的\u
，我们实际上并没有做任何“有趣”的事情对于累加器，与第二种情况不同，在第二种情况下，我们使用累加器对索引进行计数。事实上，第一种情况实际上是一种限制形式的
折叠
，它并没有使用所有的功能。它实际上只是一个
映射
：

def to_s
  "[\n" + @data.map.with_index(1) do |row, i|
    "Row #{i} : #{row.join(',')}\n"
  end.join + ']'
end

在我个人看来，在这里使用（可变）字符串追加而不是字符串串联实际上是完全可以的：

def to_s
  "[\n" << @data.map.with_index(1) do |row, i|
    "Row #{i} : #{row.join(',')}\n"
  end.join << ']'
end

不幸的是，这不仅破坏了IRb的语法突出显示，也破坏了我大脑的；-）
引用：“相同的东西但更短”我试图用“Ruby函数式”重写这样的东西，但我认为仍然有一些改进。例如，我想删除可变变量输出“我不知道我