是java吗 Iterator 接口强制我们在调用 next() 此接口上的方法？我浏览了文档，没有义务每次调用都返回一个新对象，但这会导致许多歧义。看起来，hadoopmapreduce框架打破了一些未记录的规则，这在我的简单程序（包括使用java8流）中造成了许多问题。当我调用 next() 上的方法 Iterator （虽然这与我的想象相悖，但似乎并没有违反法律的规定 Iterator ，至少它似乎并没有打破有文件记载的规则 Iterator 接口）。我想知道为什么会这样？是mapreduce故障吗？还是java没有记录的错误 Iterator 接口在每次调用时返回新示例 next() 方法：
为了简单起见，并展示hadoopmapreduce中正在发生的事情，我编写了自己的mapreduce Iterator 这与mapreduce所做的类似，因此您可以理解我的意思（因此它不是一个完美的程序，可能有很多问题，但请关注我试图展示的概念）。假设我有以下 Hospital 实体：

@Getter
@Setter
@AllArgsConstructor
@ToString
public class Hospital {
    private AREA area;
    private int patients;
    public Hospital(AREA area, int patients) {
        this.area = area;
        this.patients = patients;
    }
    public Hospital() {
    }
}

为此我写了以下文章 MyCustomHospitalIterable :

public class MyCustomHospitalIterable implements Iterable<Hospital> {
    private List<Hospital> internalList;
    private CustomHospitalIteration customIteration = new CustomHospitalIteration();
    public MyCustomHospitalIterable(List<Hospital> internalList) {
        this.internalList = internalList;
    }
    @Override
    public Iterator<Hospital> iterator() {
        return customIteration;
    }
    public class CustomHospitalIteration implements Iterator<Hospital> {
        private int currentIndex = 0;
        private Hospital currentHospital = new Hospital();
        @Override
        public boolean hasNext() {
            if (MyCustomHospitalIterable.this.internalList.size() - 1 > currentIndex) {
                currentIndex++;
                return true;
            }
            return false;
        }
        @Override
        public Hospital next() {
            Hospital hospital =
                    MyCustomHospitalIterable.this.internalList.get(currentIndex);
            currentHospital.setArea(hospital.getArea());
            currentHospital.setPatients(hospital.getPatients());
            return currentHospital;
        }
    }
}

在这里，我不是在next（）方法调用时返回新对象，而是返回具有不同内容的相同对象。你可能会问这样做的好处是什么？它在mapreduce中有自己的优势，因为在大数据中，他们不想为了性能考虑而创建新对象。这是否违反了任何记录在案的规则 Iterator 接口？
现在让我们看看实施 Iterable 这样：考虑以下简单程序：

public static void main(String[] args) {
        List<Hospital> hospitalArray = Arrays.asList(
                new Hospital(AREA.AREA1, 10),
                new Hospital(AREA.AREA2, 20),
                new Hospital(AREA.AREA3, 30),
                new Hospital(AREA.AREA1, 40));
        MyCustomHospitalIterable hospitalIterable = new MyCustomHospitalIterable(hospitalArray);
        List<Hospital> hospitalList = new LinkedList<>();
        Iterator<Hospital> hospitalIter = hospitalIterable.iterator();
        while (hospitalIter.hasNext()) {
            Hospital hospital = hospitalIter.next();
            System.out.println(hospital);
            hospitalList.add(hospital);
        }
        System.out.println("---------------------");
        System.out.println(hospitalList);
}

这是如此不合逻辑和违反直觉的程序输出如下：

Hospital{area=AREA2, patients=20}
Hospital{area=AREA3, patients=30}
Hospital{area=AREA1, patients=40}
---------------------
[Hospital{area=AREA1, patients=40}, Hospital{area=AREA1, patients=40}, Hospital{area=AREA1, patients=40}]

更糟糕的是，想象一下当我们和 Streams 在 java 。以下java程序的输出是什么：

public static void main(String[] args) {
        List<Hospital> hospitalArray = Arrays.asList(
                new Hospital(AREA.AREA1, 10),
                new Hospital(AREA.AREA2, 20),
                new Hospital(AREA.AREA3, 30),
                new Hospital(AREA.AREA1, 40));
        MyCustomHospitalIterable hospitalIterable = new MyCustomHospitalIterable(hospitalArray);
        Map<AREA, Integer> sortedHospital =
                StreamSupport.stream(hospitalIterable.spliterator(), false)
                        .collect(Collectors.groupingBy(
                                Hospital::getArea, Collectors.summingInt(Hospital::getPatients)));
        System.out.println(sortedHospital);
}

这取决于我们使用并行流还是顺序流：在sequential中，一个输出如下：

{AREA2=20, AREA1=40, AREA3=30}

与之平行的是：

{AREA1=120}

作为一个用户，我想按他们的原样使用这个接口，而不关心这个接口的实现。
问题是我知道怎么做 MyCustomHospitalIterable 但在hadoopmapreduce中，我必须实现像bellow这样的方法，我不知道在哪里 Iterable<IntWritable> 从何而来，又是如何实施的。我只想把它当作一个纯粹的 Iterable 但正如我在上面所展示的，它并没有像预期的那样工作：

public void reduce(Text key, Iterable<IntWritable> values, Context context
        ) throws IOException, InterruptedException {
            List<IntWritable> list = new LinkedList<>();
            Iterator<IntWritable> iter = values.iterator();
            while (iter.hasNext()) {
                IntWritable count = iter.next();
                System.out.println(count);
                list.add(count);
            }
            System.out.println("---------------------");
            System.out.println(list);
}

我的问题是：为什么我的简单程序坏了？
不执行不可推卸的常规规则是不是错了 Iterable 以及 Iterator （或者有我没有注意到的关于这种行为的文档）？
还是因为java没有文档化 Iterable 以及 Iterator 接口在每次调用时返回新对象？
还是因为我是个程序员？