import java.lang.reflect.AccessFlag;
import java.util.*;

public class ClassDiagramGenerator {
    private final Map<Class<?>, Class<?>[]> realizationRelations = new HashMap<>();
    private final Map<Class<?>, Class<?>> inheritanceRelations = new HashMap<>();

    private final Set<Class<?>> analyzedClasses = new HashSet<>();

    public static void main(String[] args) {
        ClassDiagramGenerator generator = new ClassDiagramGenerator();
        generator.convert(args).forEach(generator::analyzeHierarchy);

        generator.generateClassDiagram();
        generator.generateNameMappingTable();
    }

    /**
     * Convert class name to the corresponding class object
     *
     * @param classNames give class names
     * @return a list that contains corresponding class objects
     */
    private List<Class<?>> convert(String[] classNames) {
        if (classNames.length == 0) {
            String hint = "Please refer to below usage and specify at least ONE class name!";
            String usage = "Usage: java ClassDiagramGenerator 'java.util.ArrayList' 'java.util.LinkedList'";
            throw new IllegalArgumentException(String.join(System.lineSeparator(), hint, usage));
        }

        List<Class<?>> classList = new ArrayList<>(classNames.length);
        for (String className : classNames) {
            try {
                Class<?> clazz = Class.forName(className);
                classList.add(clazz);
            } catch (ClassNotFoundException e) {
                String message = String.format("Class with name=%s can't be found, please check!", className);
                throw new RuntimeException(message);
            }
        }
        return classList;
    }

    /**
     * Generate header for Mermaid class diagram
     */
    private void generateHeader() {
        System.out.println("```mermaid");
        System.out.println("classDiagram");
        System.out.println();
    }

    /**
     * Generate footer for Mermaid class diagram
     */
    private void generateFooter() {
        System.out.println("```");
    }

    /**
     * Generate main content in Mermaid class diagram
     */
    private void generateClassDiagram() {
        generateHeader();
        doGenerateClassDiagram();
        generateFooter();
    }

    /**
     * Generate a Markdown table that contains name mapping
     */
    private void generateNameMappingTable() {
        System.out.println();
        System.out.println("| 在上圖中的類名/接口名 | `Fully Qualified Name` |");
        System.out.println("| --- | --- |");
        Map<String, String> classNames = new TreeMap<>();
        analyzedClasses.forEach(c -> {
            String simpleName = c.getSimpleName();
            if (classNames.containsKey(simpleName)) {
                String prevName = classNames.get(simpleName);
                String currName = c.getName();
                String message = String.format("Duplicated simple class name detected! (%s and %s have the same simple name)", prevName, currName);
                throw new IllegalArgumentException(message);
            }
            classNames.put(simpleName, c.getName());
        });

        classNames.forEach((simpleName, name) -> {
            String row = String.format("| `%s` | `%s` |", simpleName, name);
            System.out.println(row);
        });
    }

    private void doGenerateClassDiagram() {
        analyzedClasses.forEach(c -> {
            if (inheritanceRelations.containsKey(c)) {
                System.out.printf("%s <|-- %s%n", inheritanceRelations.get(c).getSimpleName(), c.getSimpleName());
            }
            if (realizationRelations.containsKey(c)) {
                String type = c.isInterface() ? "<|--" : "<|..";
                Arrays.stream(realizationRelations.get(c)).forEach(item -> {
                    System.out.printf("%s %s %s%n", item.getSimpleName(), type, c.getSimpleName());
                });
            }
        });

        generateSpecialClassAnnotation();
    }

    /**
     * This method generates annotation for
     * 1. Abstract classes
     * 2. Interfaces
     */
    private void generateSpecialClassAnnotation() {
        Set<Class<?>> abstractClasses = new LinkedHashSet<>();
        Set<Class<?>> interfaces = new LinkedHashSet<>();

        analyzedClasses.forEach(c -> {
            if (c.isInterface()) {
                interfaces.add(c);
            } else if (c.accessFlags().contains(AccessFlag.ABSTRACT)) {
                abstractClasses.add(c);
            }
        });

        if (!abstractClasses.isEmpty() || !interfaces.isEmpty()) {
            System.out.println();
            abstractClasses.forEach(c -> System.out.println("<<Abstract>> " + c.getSimpleName()));
            interfaces.forEach(c -> System.out.println("<<interface>> " + c.getSimpleName()));
        }
    }

    private void analyzeHierarchy(Class<?> currClass) {
        if (!analyzedClasses.contains(currClass)) {
            analyzeSuperClass(currClass);
            analyzeInterfaces(currClass);

            analyzedClasses.add(currClass);
        }
    }

    private void analyzeSuperClass(Class<?> currClass) {
        Class<?> superclass = currClass.getSuperclass();
        if (superclass == null || superclass == Object.class) {
            return;
        }
        analyzeHierarchy(superclass);
        inheritanceRelations.put(currClass, superclass);
    }

    private void analyzeInterfaces(Class<?> currClass) {
        Class<?>[] interfaces = currClass.getInterfaces();
        for (Class<?> item : interfaces) {
            analyzeHierarchy(item);
        }

        realizationRelations.put(currClass, interfaces);
    }
}

javac ClassDiagramGenerator.java

java ClassDiagramGenerator 'java.util.ArrayList'

java ClassDiagramGenerator 'java.util.LinkedList'

java ClassDiagramGenerator 'java.util.Arrays$ArrayList'

java ClassDiagramGenerator 'java.util.List' 'java.util.Set' 'java.util.Deque'

java ClassDiagramGenerator 'java.util.HashMap' 'java.util.LinkedHashMap' 'java.util.concurrent.ConcurrentHashMap'

java ClassDiagramGenerator 'java.util.ImmutableCollections$Set12' 'java.util.ImmutableCollections$SetN'

java ClassDiagramGenerator 'java.util.JumboEnumSet' 'java.util.RegularEnumSet'

java ClassDiagramGenerator 'java.util.concurrent.ThreadPoolExecutor'