java中的不同数据类型

Question

我在运行时使用反射从 Java 对象中提取字段类型。这些字段被分类为：

• 原始类型
• 包名称以 Java.lang.* 开头的字段
• 包名称以 Java.util.* 开头的字段
• 数组类型

对于字段中的自定义对象（用户定义）：再次探索它们的字段和分类的各自字段。（递归调用）

我想知道上述分类是否足以用于任何对象，或者是否需要一些额外的类别才能进行更有意义的分类。

Answer 1

我做这样的事情是为了调试，我只是检查Iterable，有时是Map。试图静态地考虑每一种可能的类型有点愚蠢。如果你想处理任何可能的类型，一个好主意是创建一个简单的方法来注册一个转换器函数。然后 API 的客户端基本上可以为所欲为。

这是一个相对简单的例子：

package mcve.reflect;

import java.lang.reflect.*;
import java.io.*;
import java.util.*;
import java.util.stream.*;
import java.util.function.*;

public interface DebugReadout {
    /**
     * Prints a readout of all instance fields in {@code this} to the
     * specified print stream.
     * 
     * @param   out 
     * @throws  NullPointerException
     */
    default void readout(PrintStream out) {
        Class<?> clazz = getClass();
        out.printf("%s {%n", clazz.getSimpleName());
        do {
            for (Field f : clazz.getDeclaredFields()) {
                if (!Modifier.isStatic(f.getModifiers())) {
                    String value;
                    try {
                        f.setAccessible(true);
                        value = Details.toString(f.get(this));
                    } catch (ReflectiveOperationException
                           | SecurityException x) {
                        value = "UNAVAILABLE";
                    }
                    out.printf("    %s = %s%n", f.getName(), value);
                }
            }
        } while((clazz = clazz.getSuperclass()) != Object.class);
        out.printf("}%n");
    }
    /**
     * Registers a converter function.
     * 
     * @param   <T>
     * @param   type
     * @param   fn 
     * @throws  NullPointerException
     */
    static <T> void put(Class<T> type, Function<? super T, String> fn) {
        Objects.requireNonNull(type);
        Objects.requireNonNull(fn);
        Details.CONVERTERS.put(type, fn);
    }
    /**
     * Returns a converter function or {@code null} if one didn't exist.
     * 
     * @param   <T>
     * @param   type
     * @return  a converter function
     */
    @SuppressWarnings("unchecked")
    static <T> Function<? super T, String> get(Class<T> type) {
        Objects.requireNonNull(type);
        synchronized (Details.CONVERTERS) {
            Function<?, String> fn = Details.CONVERTERS.get(type);
            if (fn == null) {
                for (Class<?> key : Details.CONVERTERS.keySet()) {
                    if (key.isAssignableFrom(type)) {
                        fn = Details.CONVERTERS.get(key);
                        break;
                    }
                }
            }
            return (Function<? super T, String>) fn;
        }
    }
}

class Details {
    static final Map<Class<?>, Function<?, String>> CONVERTERS =
        Collections.synchronizedMap(new HashMap<>());

    static <T> String toString(T obj) {
        if (obj == null) {
            return "null";
        }
        @SuppressWarnings("unchecked")
        Function<? super T, String> fn =
            (Function<? super T, String>)
                DebugReadout.get(obj.getClass());
        if (fn != null) {
            return fn.apply(obj);
        }
        if (obj.getClass().isArray()) {
            return IntStream.range(0, Array.getLength(obj))
                            .mapToObj(i -> toString(Array.get(obj, i)))
                            .collect(Collectors.joining(", ", "[", "]"));
        }
        if (obj instanceof Iterable<?>) {
            return StreamSupport.stream(((Iterable<?>) obj).spliterator(), false)
                                .map(e -> toString(e))
                                .collect(Collectors.joining(", ", "[", "]"));
        }
        if (obj instanceof Map<?, ?>) {
            return toString(((Map<?, ?>) obj).entrySet());
        }
        return obj.toString();
    }
}

一个更健壮的例程会为迄今为止看到的每个对象保留一个IdentityHashMap（可能不包括String 和Integer 等已知值类型），因此在两个对象的情况下不会出现无限递归互相参考。