Main.java

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.lang.reflect.*;
import java.util.*;
import java.util.stream.Collectors;

public class Main {

 // Path for the output file and the number of top entries to include
 private static String outputFilePath;
 private static int topN;
 private static List<Class<?>> classes;

 // Maps to store counts of fields, methods, subtypes, and supertypes for each class
 private static final Map<String, Integer> fieldsDeclared = new HashMap<>(), 
 fieldsAll = new HashMap<>(), 
 methodsAll = new HashMap<>(), 
 methodsDeclared = new HashMap<>(), 
 subtypesTotal = new HashMap<>(), 
 supertypesTotal = new HashMap<>();

 public static void main(String[] args) {

 // Handle command-line arguments to set file paths and topN limit
 switch (args.length) {
 case 1 -> {
 // Case with 1 argument: Set topN, default output file path, and load all JDK classes
 topN = Integer.parseInt(args[0]);
 outputFilePath = "resources" + File.separator + "output.txt";
 classes = ClassScanner.totalClasses();
 }
 case 3 -> {
 // Case with 3 arguments: Set input and output file paths and topN, then load classes
 String inputFilePath = args[0];
 outputFilePath = args[1];
 topN = Integer.parseInt(args[2]);
 classes = inputClasses(new ArrayList<>(), inputFilePath);
 }
 default -> {
 // Invalid usage; print instructions and exit
 System.out.println("Invalid arguments. Usage:");
 System.out.println("1 argument: java Main <value-of-N>");
 System.out.println("3 arguments: java Main <input-file> <output-file> <value-of-N>");
 return;
 }
 }

 // If classes were successfully loaded, proceed with analysis
 if (!classes.isEmpty()) {
 System.out.println("Found " + classes.size() + " Classes");
 classes.stream().forEach(clazz -> exploreHierarchy(clazz)); // Analyze each class's hierarchy

 // Prepare output lines with results for fields, methods, subtypes, and supertypes
 List<String> outputLines = new ArrayList<>();
 outputLines.add("1a: " + sortMapByValueToString(fieldsDeclared, topN));
 outputLines.add("1b: " + sortMapByValueToString(fieldsAll, topN));
 outputLines.add("2a: " + sortMapByValueToString(methodsDeclared, topN));
 outputLines.add("2b: " + sortMapByValueToString(methodsAll, topN));
 outputLines.add("3: " + sortMapByValueToString(subtypesTotal, topN));
 outputLines.add("4: " + sortMapByValueToString(supertypesTotal, topN));

 // Write results to the specified output file
 writeFile(outputFilePath, outputLines);
 }
 }

 /**
 * Reads class names from the specified input file, loads each class, and adds it to the classes list.
 * @param classes List to hold the loaded classes
 * @param inputFilePath Path to the file containing class names
 * @return List of loaded classes
 */
 private static List<Class<?>> inputClasses(List<Class<?>> classes, String inputFilePath) {
 try (BufferedReader br = new BufferedReader(new FileReader(inputFilePath))) {
 String typeName;
 while ((typeName = br.readLine()) != null) {

 // Skip entries that are not valid class names
 if (typeName.endsWith("package-info") || typeName.endsWith("module-info") || typeName.contains("META-INF")) {
 System.out.println("Skipped non-class entry: " + typeName);
 continue;
 }

 try {
 // Attempt to load the class by its name
 Class<?> clazz = Class.forName(typeName);
 classes.add(clazz);
 System.out.println("Loaded: " + clazz.getName());
 } catch (ClassNotFoundException e) {
 System.out.println("Type not found: " + e.getMessage());
 }
 }
 } catch (IOException e) {
 System.out.println("An error occurred while reading the file: " + e.getMessage());
 }

 return classes;
 }

 /**
 * Analyzes each class by counting its declared fields, methods, subtypes, and supertypes.
 * @param clazz The class to be analyzed
 */
 private static void exploreHierarchy(Class<?> clazz) {

 // Sets to track unique field names, method names, and supertypes for each class
 Set<String> uniqueFieldNames = new HashSet<>(), 
 uniqueMethodNames = new HashSet<>(),
 supertypes = new HashSet<>();

 // Count declared fields and methods
 for (Field field : clazz.getDeclaredFields()) uniqueFieldNames.add(field.getName());
 for (Method method : clazz.getDeclaredMethods()) uniqueMethodNames.add(method.getName());

 // Store counts for declared fields and methods
 fieldsDeclared.put(clazz.getName(), uniqueFieldNames.size());
 methodsDeclared.put(clazz.getName(), uniqueMethodNames.size());

 // Recursively explore superclass and interfaces to count inherited fields, methods, and supertypes
 exploreRecursive(clazz, uniqueFieldNames, uniqueMethodNames, supertypes);

 // Store counts for all (declared + inherited) fields and methods, and supertypes
 fieldsAll.put(clazz.getName(), uniqueFieldNames.size());
 methodsAll.put(clazz.getName(), uniqueMethodNames.size());
 supertypesTotal.put(clazz.getName(), supertypes.size());
 }

 /**
 * Recursively explores superclass and interfaces, adding inherited fields, methods, and supertypes.
 * @param clazz The current class in the hierarchy
 * @param uniqueFieldNames Set of unique field names to track inherited fields
 * @param uniqueMethodNames Set of unique method names to track inherited methods
 * @param supertypes Set of supertypes for the current class
 */
 private static void exploreRecursive(Class<?> clazz, Set<String> uniqueFieldNames,
 Set<String> uniqueMethodNames, Set<String> supertypes) {

 // Process the superclass, if it exists
 Class<?> superclass = clazz.getSuperclass();
 if (superclass != null) {
 // Add non-private fields and methods from the superclass
 for (Field field : superclass.getDeclaredFields()) {
 if (!Modifier.isPrivate(field.getModifiers())) uniqueFieldNames.add(field.getName());
 }
 for (Method method : superclass.getDeclaredMethods()) {
 if (!Modifier.isPrivate(method.getModifiers())) uniqueMethodNames.add(method.getName());
 }
 subtypesTotal.put(superclass.getName(), subtypesTotal.getOrDefault(superclass.getName(), 0) + 1);
 supertypes.add(superclass.getName());

 // Recursive call to explore superclass hierarchy
 exploreRecursive(superclass, uniqueFieldNames, uniqueMethodNames, supertypes);
 }

 // Process each interface implemented by the class
 for (Class<?> superInterface : clazz.getInterfaces()) {
 for (Field field : superInterface.getDeclaredFields()) uniqueFieldNames.add(field.getName());
 for (Method method : superInterface.getDeclaredMethods()) {
 if (!Modifier.isPrivate(method.getModifiers())) uniqueMethodNames.add(method.getName());
 }
 subtypesTotal.put(superInterface.getName(), subtypesTotal.getOrDefault(superInterface.getName(), 0) + 1);
 supertypes.add(superInterface.getName());

 // Recursive call to explore interface hierarchy
 exploreRecursive(superInterface, uniqueFieldNames, uniqueMethodNames, supertypes);
 }
 }

 /**
 * Writes the formatted output data to the specified output file.
 * @param outputFilePath Path to the output file
 * @param outputLines List of strings representing the formatted output data
 */
 private static void writeFile(String outputFilePath, List<String> outputLines) {
 File file = new File(outputFilePath);

 try (BufferedWriter writer = new BufferedWriter(new FileWriter(outputFilePath))) {
 for (String line : outputLines) {
 writer.write(line);
 writer.newLine();
 }
 System.out.println("Output written to " + file.getAbsolutePath());
 } catch (IOException e) {
 System.err.println("Error writing to output file: " + e.getMessage());
 }
 }

 /**
 * Sorts a map by value in descending order and returns a formatted string of the top N entries.
 * @param entries Map with class names as keys and counts as values
 * @param topN The maximum number of top entries to include
 * @return Formatted string of the top N entries
 */
 private static String sortMapByValueToString(Map<String, Integer> entries, int topN) {
 return entries.entrySet().stream()
 .sorted((e1, e2) -> {
 // Primary sorting by value in descending order
 int valueComparison = Integer.compare(e2.getValue(), e1.getValue());
 
 // If values are the same, apply secondary sorting by key in alphabetical order
 return valueComparison != 0 ? valueComparison : e1.getKey().compareTo(e2.getKey());
 })
 .limit(topN) // Limit to the top N entries
 .map(entry -> entry.getKey() + " (" + entry.getValue() + " occurrences)") // Format each entry
 .collect(Collectors.joining(", ")); // Join formatted entries into a single string
 }
}