Question

我创建了一个小型Java程序，它使用反射来检查对象的字段，并递归地横向移动它的结构，以构建其所有成员的树，类似于调试器在检查变量时所做的事情。

最大的问题是有时会出现循环引用。我的树成了图！然后我的程序进入无限循环并最终抛出StackOverflow异常（哦，具有讽刺意味！）

我的问题是......为了实现任何标准的图横向算法，怎么能“标记”任意对象？我不能使用hashCode（），因为任何对象都可以用作输入，不同的对象可以返回相同的哈希码。任何线索？

先谢谢！

public class ClassHierarchyItem {

private boolean parent;
private String id;
private String parentId;
private String name;
private String type;
private String value;

public ClassHierarchyItem(boolean parent, String id, String parentId, String name, String type, String value){
    this.parent = parent;
    this.id = id;
    this.parentId = parentId;
    this.name = name;
    this.type = type;
    this.value = value;
}

public String toString() {
    return (isParent() ? "+" : "") + name + " - " + type + " - " + value + " [id=" + id + ", pId=" + parentId + "]";  
}
//Getters and setters follow (cutted)
}

public class ClassHierarchyNavigator {

public static void main(String[] args) {
    Integer i = 123;

    // Fails with StackOverflow exception (some reference inside Integer points back to base object)
    System.out.println(renderHirearchy(i));
}

public static List<ClassHierarchyItem> renderHirearchy(Object o) {

    List<ClassHierarchyItem> items = new ArrayList<ClassHierarchyItem>();

    boolean parent = (o.getClass().getDeclaredFields().length > 0 && !o.getClass().isPrimitive() && o.getClass() != String.class)
            || o.getClass().isArray();

    buildObjectTree(items, o, parent, "root", o.getClass().getName(), "r", "");

    return items;
}

private static boolean isParent(Field field) {

    return (field.getClass().getDeclaredFields().length > 0 && !field.getType().isPrimitive() && field.getType() != String.class)
            || field.getType().isArray();
}

private static void buildObjectTree(List<ClassHierarchyItem> items, Object object, boolean parent,
        String objectName, String objectType, String objectId, String parentId) {

    long subItemCount = 1;
    String value = object == null ? "null" : object.toString();

    ClassHierarchyItem item = new ClassHierarchyItem(parent, objectId, parentId, objectName, objectType,
            value.substring(0, value.length() > 80 ? 80 : value.length()));
    items.add(item);

    if (!parent) {
        return;
    }

    // if (isArray) {
    // do_array_treatment
    // } else {
    for (Field field : object.getClass().getDeclaredFields()) {
        field.setAccessible(true);
        Object child;
        try {
            child = field.get(object);
        } catch (IllegalArgumentException e) {
            continue;
        } catch (IllegalAccessException e) {
            continue;
        }

        String childId = objectId + "-" + subItemCount++;
        String fieldName = field.getName();
        boolean childIsParent = child != null && !"this$0".equals(fieldName) && isParent(field);

        buildObjectTree(items, child, childIsParent, fieldName, field.getType().getName(), childId, objectId);
    }

}
}

Answer 1

使用哈希表数据结构，例如HashMap，并将对象用作键。实际上，一些哈希会发生冲突，但是冲突解决是哈希表背后的根本思想：每个哈希都会导致包含每个具有相同哈希的键/值对的桶，从而允许您检索对象。

但是，如果您的对象也重新实现了equals（），以便两个对象可能相等，那就是一个问题，因为冲突解决方法无法区分同一个存储桶中的两个键。如果是这样，请使用hashcode（）设计自己的hastable以获取哈希值，但使用语言“==”进行比较以按内存地址比较对象。

在遍历对象层次结构时将节点标记为已访问

1 个答案: