Java 在减速器上循环两次

我正在实现两阶段矩阵乘法。以下是第一阶段的减速器。键是左文件的行索引和右文件的列索引。 我希望map和reducer的输出计数相同。但看起来内部循环增加的迭代器和外部循环增加的迭代器相同，所以减速机输出的数量等于键的数量

代码块：

@Override
        public void reduce(Text key, Iterable<Text> values, Context context)
        throws IOException, InterruptedException
        {
            for (Text outer : values) {
                String [] outerLine = outer.toString().split("\t");
                //int outerIndex = 0;
                //outerIndex = outerLine[0].equalsIgnoreCase(leftFilePattern) ? outerIndex : 1;
                if(outerLine[0].equalsIgnoreCase(rightFilePattern))
                    continue;
                double outerValue = Double.parseDouble(outerLine[2]);
                for (Text inner : values) {
                    String [] innerLine = inner.toString().split("\t");
                    if(innerLine[0].equalsIgnoreCase(leftFilePattern))
                        continue;
                    context.write(new Text(key.toString() + "-" + innerLine[1]), 
                                new DoubleWritable(outerValue * Double.parseDouble(innerLine[2])));
                }
            }

@覆盖
公共void reduce（文本键、Iterable值、上下文）
抛出IOException、InterruptedException
{
用于（文本外部：值）{
字符串[]outerLine=outer.toString（）.split（“\t”）；
//int outerIndex=0；
//outerIndex=outerLine[0]。相等信号案例（leftFilePattern）？outerIndex:1；
if（外部线[0].equalsIgnoreCase（rightFilePattern））
继续；
double-outerValue=double.parseDouble（outerLine[2]）；
用于（文本内部：值）{
字符串[]innerLine=inner.toString（）.split（“\t”）；
if（内部行[0].equalsIgnoreCase（leftFilePattern））
继续；
context.write（新文本（key.toString（）+“-”+innerLine[1]），
新的DoubleWritable（outerValue*Double.parseDouble（innerLine[2]））；
}
}

但当我有如下简单的java应用程序时：

List<Integer> l = Arrays.asList(10, 15);
        Iterable<Integer> it = l;
        for (Integer in : it) {
            for (Integer out : it) {
                System.out.println(in + " " + out);
            }
        }

List l=Arrays.asList（10,15）；
Iterable it=l；
for（整数：it）{
for（整数输出：it）{
System.out.println（in+“”+out）；
}
}

这里的输出数是4。若内环的工作原理和减速机相同，则输出计数应为1，即（10 15）

有人能解释这种行为吗

---

Vishal

有一种可能的方法来实现Iterable，这可能会导致这种效果

其目的似乎是每个

iterator（）

调用都应该返回自己的

iterator

实例。

java.util

中的

Iterable

类，包括

数组.asList（）使用的私有
列表
类

，都是这样做的。相同的

Iterable

上的嵌套foreach需要这种行为，

Iterable

的声明目的是foreach支持

我在

Iterable

API文档中找不到任何直接需要该行为的内容

显然，如果两次

iterator（）

调用都使用了相同的对象，那么相同

Iterable

上的嵌套foreach语句将以您描述的方式失败

=========================================================

---

如果出现这种情况，我最好的建议是对

值进行初始传递

将每个文本引用复制到行为良好的

列表

，例如

数组列表

。您可以安全地在其元素上执行嵌套循环。

是的，不同的实现可以自由地以不同的方式实现，但它们应该使用不同的名称。对不同的行为使用相同的名称会使使用…@VishalKumar变得困难迭代器接口API文档确实应该指定每个迭代器（）调用都返回一个不同的对象。