你可以使用Collector：

import java.util.*;
import java.util.stream.Collectors;
public class Defensive {
  public static void main(String[] args) {
    Map<String, Column> original = new HashMap<>();
    original.put("foo", new Column());
    original.put("bar", new Column());
    Map<String, Column> copy = original.entrySet()
        .stream()
        .collect(Collectors.toMap(Map.Entry::getKey,
                                  e -> new Column(e.getValue())));
    System.out.println(original);
    System.out.println(copy);
  }
  static class Column {
    public Column() {}
    public Column(Column c) {}
  }
}

Map<String, Integer> map = new HashMap<>();
map.put("test1", 1);
map.put("test2", 2);
Map<String, Integer> map2 = new HashMap<>();
map.forEach(map2::put);
System.out.println("map: " + map);
System.out.println("map2: " + map2);
// Output:
// map:  {test2=2, test1=1}
// map2: {test2=2, test1=1}

你可以使用forEach方法来做你想做的事情。
你在做的是：

map.forEach(new BiConsumer<String, Integer>() {
    @Override
    public void accept(String s, Integer integer) {
        map2.put(s, integer);     
    }
});

我们可以将其简化为lambda：

map.forEach((s, integer) ->  map2.put(s, integer));

因为我们只是调用一个现有的方法，所以我们可以使用method reference，这给了我们：

map.forEach(map2::put);

保持简单，使用Java 8：

Map<String, AccountGroupMappingModel> mapAccountGroup=CustomerDAO.getAccountGroupMapping();
 Map<String, AccountGroupMappingModel> mapH2ToBydAccountGroups = 
              mapAccountGroup.entrySet().stream()
                         .collect(Collectors.toMap(e->e.getValue().getH2AccountGroup(),
                                                   e ->e.getValue())
                                  );

不将所有条目重新插入到新Map中的方法应该是最快的，但它不会，因为HashMap.clone也在内部执行反汇编。

Map<String, Column> newColumnMap = originalColumnMap.clone();
newColumnMap.replaceAll((s, c) -> new Column(c));

如果在项目中使用Guava（最低v11），则可以使用Maps：：transformValues。

Map<String, Column> newColumnMap = Maps.transformValues(
  originalColumnMap,
  Column::new // equivalent to: x -> new Column(x) 
)

注意：这个Map的值是延迟计算的。如果转换的代价很高，你可以将结果复制到一个新的Map上，就像Guava文档中建议的那样。
当返回的map不需要是视图时，为了避免延迟计算，请将返回的map复制到您选择的新map中。

这里有另一种方法，可以让你同时访问键和值，以防你必须做某种转换。

Map<String, Integer> pointsByName = new HashMap<>();
Map<String, Integer> maxPointsByName = new HashMap<>();
Map<String, Double> gradesByName = pointsByName.entrySet().stream()
        .map(entry -> new AbstractMap.SimpleImmutableEntry<>(
                entry.getKey(), ((double) entry.getValue() /
                        maxPointsByName.get(entry.getKey())) * 100d))
        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

如果你不介意使用第三方库，我的cyclops-react库有所有JDK集合类型的扩展，包括Map。您可以直接使用map或bimap方法来转换Map。一个MapX可以从一个现有的Map构建，例如。

MapX<String, Column> y = MapX.fromMap(orgColumnMap)
                               .map(c->new Column(c.getValue());

如果您还希望更改密钥，则可以编写

MapX<String, Column> y = MapX.fromMap(orgColumnMap)
                               .bimap(this::newKey,c->new Column(c.getValue());

bimap可用于同时转换键和值。
当MapX扩展Map时，生成的map也可以定义为

Map<String, Column> y

从Java 9开始，在流的map部分进行转换变得更加容易。已经可以使用new AbstractMap.SimpleImmutableEntry了，但是Map接口有一个额外的静态方法Map.entry，它也可以创建一个条目，用于这种情况。

Java 9+

import java.util.Map;
import java.util.Map.Entry;
import java.util.stream.Collectors;
public class App {
    public static void main(String[] args) {
        Map<String, Column> x;
        Map<String, Column> y = x.entrySet().stream()
                .map(entry -> Map.entry((entry.getKey(), new Column(entry.getValue())))
                .collect(Collectors.toMap(Entry::getKey, Entry::getValue));
    }
}