Dozer很好，看看Jean-Remy的回答。
此外，如果变量具有符合JavaBeans标准的getter和setter，则有许多技术可以帮助您，例如。Apache Commons / BeanUtils

示例代码（未测试）：

final Map<String, Object> aProps = BeanUtils.describe(a);
final Map<String, Object> bProps = BeanUtils.describe(b);
aProps.keySet().retainAll(bProps.keySet());
for (Entry<String, Object> entry : aProps.entrySet()) {
    BeanUtils.setProperty(b,entry.getKey(), entry.getValue());
}

更新：

如果你没有getter和setter，这里有一个快速的技巧，只要字段具有共同的名称和类型，就可以将字段值从一个类复制到另一个类。我还没有测试过，但作为一个起点应该是可以的：

public final class Copier {

    public static void copy(final Object from, final Object to) {
        Map<String, Field> fromFields = analyze(from);
        Map<String, Field> toFields = analyze(to);
        fromFields.keySet().retainAll(toFields.keySet());
        for (Entry<String, Field> fromFieldEntry : fromFields.entrySet()) {
            final String name = fromFieldEntry.getKey();
            final Field sourceField = fromFieldEntry.getValue();
            final Field targetField = toFields.get(name);
            if (targetField.getType().isAssignableFrom(sourceField.getType())) {
                sourceField.setAccessible(true);
                if (Modifier.isFinal(targetField.getModifiers())) continue;
                targetField.setAccessible(true);
                try {
                    targetField.set(to, sourceField.get(from));
                } catch (IllegalAccessException e) {
                    throw new IllegalStateException("Can't access field!");
                }
            }
        }
    }

    private static Map<String, Field> analyze(Object object) {
        if (object == null) throw new NullPointerException();

        Map<String, Field> map = new TreeMap<String, Field>();

        Class<?> current = object.getClass();
        while (current != Object.class) {
            for (Field field : current.getDeclaredFields()) {
                if (!Modifier.isStatic(field.getModifiers())) {
                    if (!map.containsKey(field.getName())) {
                        map.put(field.getName(), field);
                    }
                }
            }
            current = current.getSuperclass();
        }
        return map;
    }
}

调用语法：

Copier.copy(sourceObject, targetObject);

你听说过道瑟吗：http://dozer.sourceforge.net/
推土机
Dozer是一个JavaBean到JavaBean的Map器，它递归地将数据从一个对象复制到另一个对象。通常，这些Java Bean将具有不同的复杂类型。
Dozer支持简单属性Map、复杂类型Map、双向Map、隐式-显式Map以及递归Map。这包括Map也需要在元素级别Map的集合属性。
Dozer允许您MapJava Bean：

• 使用它们的名称（隐式Map），即将ClassA.xMap到ClassB.x
• 提供了使用（非常简单的）XML或注解配置Map具有不同名称的不同结构（显式Map）的能力。

以下是图书馆网站上的一个XML示例：

<?xml version="1.0" encoding="UTF-8"?>
<mappings xmlns="http://dozer.sourceforge.net"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://dozer.sourceforge.net
          http://dozer.sourceforge.net/schema/beanmapping.xsd">
          
  <mapping> 
    <class-a>org.dozer.vo.TestObject</class-a>
    <class-b>org.dozer.vo.TestObjectPrime</class-b>   
    <field>
      <a>one</a>
      <b>onePrime</b>
    </field>
  </mapping>  

      <!-- SNIP ... -->

</mappings>

这将把对象org.dozer.vo.TestObjectMap到TestObjectPrime，把所有相同的变量Map到一起（就像在您的例子中一样），把变量TestObjectFoo.oneFooMap到TestObjectFooPrime. oneFooPrime。
很棒，不是吗？

你看。使用BeanUtils.copyProperties(newObject, oldObject);即可

新的答案
我建议去多佛看看，因为它看起来很简单。
第二种选择是将类序列化为XML，并仅对匹配的成员反序列化为目标类。
我在评论中提到的第三个选项是使用反射-http://java.sun.com/developer/technicalArticles/ALT/Reflection/
这种技术允许一个很好的设计模式，称为Introspection -Java introspection and reflection，它反过来允许你发现某个类的成员。
现在，已经说过了，我们可以简单地“发现”ClassA的成员，用他们的名字填充一个ArrayList，发现ClassB的成员，用他们的名字填充另一个ArrayList，并复制交集的值。至少这是我的想法。