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 ），因此在兩個對象相互引用的情況下，最終不會產生無限遞歸。