Java 迭代嵌套映射

我将这些方法放在一起，以帮助迭代嵌套映射（for）

您可以清楚地看到，前两个方法实际上几乎完全相同，除了它们的泛型之外，一个调用

iV

，另一个调用

iiV

。我有没有办法将它们折叠成一种方法，或者至少将机制的清晰复制移动到一个地方

如果操作正确，应该可以迭代任何深度的嵌套贴图

// Iterating across Maps of Maps of Maps.
static <K1, K2, K3, V> Iterator<Iterator<Iterator<V>>> iiiV(Map<K1, Map<K2, Map<K3, V>>> mmm) {
  final Iterator<Map<K2, Map<K3, V>>> mmi = iV(mmm);
  return new Iterator<Iterator<Iterator<V>>>() {
    @Override
    public boolean hasNext() {
      return mmi.hasNext();
    }

    @Override
    public Iterator<Iterator<V>> next() {
      return iiV(mmi.next());
    }

    @Override
    public void remove() {
      mmi.remove();
    }
  };
}

// Iterating across Maps of Maps.
static <K1, K2, V> Iterator<Iterator<V>> iiV(Map<K1, Map<K2, V>> mm) {
  final Iterator<Map<K2, V>> mi = iV(mm);
  return new Iterator<Iterator<V>>() {
    @Override
    public boolean hasNext() {
      return mi.hasNext();
    }

    @Override
    public Iterator<V> next() {
      return iV(mi.next());
    }

    @Override
    public void remove() {
      mi.remove();
    }
  };
}

// Iterating across Map values.
static <K, V> Iterator<V> iV(final Map<K, V> map) {
  return iV(map.entrySet().iterator());
}

// Iterating across Map.Entries.
static <K, V> Iterator<V> iV(final Iterator<Map.Entry<K, V>> mei) {
  return new Iterator<V>() {
    @Override
    public boolean hasNext() {
      return mei.hasNext();
    }

    @Override
    public V next() {
      return mei.next().getValue();
    }

    @Override
    public void remove() {
      mei.remove();
    }
  };
}

//在地图的地图之间迭代。
静态迭代器iiiV（映射mmm）{
最终迭代器mmi=iV（mmm）；
返回新的迭代器（）{
@凌驾
公共布尔hasNext（）{
返回mmi.hasNext（）；
}
@凌驾
公共迭代器next（）{
返回iiV（mmi.next（））；
}
@凌驾
公共空间删除（）{
mmi.remove（）；
}
};
}
//在地图的地图上迭代。
静态迭代器iiV（映射mm）{
最终迭代器mi=iV（mm）；
返回新的迭代器（）{
@凌驾
公共布尔hasNext（）{
返回mi.hasNext（）；
}
@凌驾
公共迭代器next（）{
返回iV（mi.next（））；
}
@凌驾
公共空间删除（）{
mi.remove（）；
}
};
}
//遍历映射值。
静态迭代器iV（最终映射）{
return iV（map.entrySet（）.iterator（））；
}
//在Map.Entries上迭代。
静态迭代器iV（最终迭代器mei）{
返回新的迭代器（）{
@凌驾
公共布尔hasNext（）{
返回mei.hasNext（）；
}
@凌驾
公共V next（）{
返回mei.next（）.getValue（）；
}
@凌驾
公共空间删除（）{
mei.remove（）；
}
};
}

为什么不：

static <K, V> Iterator<V> iV(final Iterator<V> mei) {
   return new Iterator<V>() {
     @Override
     public boolean hasNext() {
       return mei.hasNext();
     }

     @Override
     public V next() {
       if (Iterator.class.isAssignableFrom(V.class)) {
         Iterator it = iV((Iterator)V);
         return it.hasNext() ? it.next() : ((Iterator)mei.next()).next();
       }
       else
         return mei.next().getValue();
     }

     @Override
     public void remove() {
       mei.remove();
    }
  };
}

静态迭代器iV（最终迭代器mei）{
返回新的迭代器（）{
@凌驾
公共布尔hasNext（）{
返回mei.hasNext（）；
}
@凌驾
公共V next（）{
if（Iterator.class.isAssignableFrom（V.class））{
迭代器it=iV（（迭代器）V）；
返回它.hasNext（）？it.next（）：（（迭代器）mei.next（））.next（）；
}
其他的
返回mei.next（）.getValue（）；
}
@凌驾
公共空间删除（）{
mei.remove（）；
}
};
}

---

（未测试）

如果要在n深度贴图上迭代，那么方法签名和返回类型是什么？@khachik-请查看链接中的完整答案。您可以使用

NestedIterator（NestedIterator（Iterator i））

返回

Iterator

。这些方法只是用嵌套的

Map

s为

NestedIterator

构造函数构建嵌套迭代器的帮助。由于类型擦除，不确定是否可以执行

V.class

，但我喜欢这个想法。也许可以改为

mei.getClass（）

。哦，我想你是对的。但是

mei.getClass（）

将只返回

Iterator.class

。您可能应该选择一个元素，并使用

元素.getClass（）

检查这个元素，但要小心考虑空迭代器等。我已经遇到过类似的情况，我认为没有更干净的解决方案…：(