Feat: allow args filtering

src/main/java/org/javademos/Main.java

@@ -1,15 +1,18 @@
 package org.javademos;
 
 import org.javademos.commons.IDemo;
-import org.javademos.init.*;
+import org.javademos.commons.ArgsFilterUtil;
 
-import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.Map;
+
+import static org.javademos.init.JEPInfo.JEP_DEMO;
+import static org.javademos.init.JEPInfo.JEP_DATA;
 
 /**
  * This application helps to show some new features from Java 11 to Java 21.
- * The 'demoPool' array consists of simple IDemo interface implementations.
+ * The 'JEP_DATA' map consists of simple IDemo interface implementations.
  * Code logic is being implemented inside .demo() methods.
- * 
  * @see IDemo
  * 
  * You can try switching the compile/build settings back to Java 1.8 to see
@@ -19,14 +22,16 @@
  * @author alois.seckar@gmail.com
  */
 public class Main {
-    
+
     /**
-     * Simple main method.
-     * No complex logic - all available demo implementations are being put
-     * inside a list, and then being executed one by one.
-     * 
-     * @param args not supported (ignored) in this application
-     */
+     * Main method supports filtering demos based on command line arguments.
+     * Supported arguments and examples:
+     * --skip-links: Skip demos that are link-only to other JEP
+     * --code-only: Only run demos that contain code
+     * --jdk=17,25: Only run demos from specific JDK versions
+     * --only=382,409: Only run specific JEP numbers
+     * @see ArgsFilterUtil
+     * */
     public static void main(String[] args) {
 
         // https://stackoverflow.com/a/19165338/3204544
@@ -36,34 +41,18 @@ public static void main(String[] args) {
         System.out.println(System.getProperty("java.vendor"));
         System.out.println(System.getProperty("java.version"));
         System.out.println(System.getProperty("java.specification.vendor"));
-        //
-
-        var demoPool = new ArrayList<IDemo>();
-
-        // you may find useful to comment out other JDKs except the one
-        // you are about to examine
-        // it may be confusing to search the actual output of particular
-        // demo class implementation you are currently interested in
 
-        demoPool.addAll(Java11.getDemos());
-        demoPool.addAll(Java12.getDemos());
-        demoPool.addAll(Java13.getDemos());
-        demoPool.addAll(Java14.getDemos());
-        demoPool.addAll(Java15.getDemos());
-        demoPool.addAll(Java16.getDemos());
-        demoPool.addAll(Java17.getDemos());
-        demoPool.addAll(Java18.getDemos());
-        demoPool.addAll(Java19.getDemos());
-        demoPool.addAll(Java20.getDemos());
-        demoPool.addAll(Java21.getDemos());
-        demoPool.addAll(Java22.getDemos());
-        demoPool.addAll(Java23.getDemos());
-        demoPool.addAll(Java24.getDemos());
-        demoPool.addAll(Java25.getDemos());
-
-        // run method .demo() on each entry to see the output
-        demoPool.forEach(IDemo::demo);
-
+        var filteredJepData = ArgsFilterUtil.getFilteredJepData(args, JEP_DATA);
+
+        // Run only filtered demos, sorted by JDK version and JEP number
+        JEP_DEMO.entrySet().stream()
+                .filter(e -> filteredJepData.containsKey(e.getKey()))
+                .sorted(
+                        Comparator
+                                .comparingInt((Map.Entry<Integer, IDemo> e) -> JEP_DATA.get(e.getKey()).jdk())
+                                .thenComparingInt(Map.Entry::getKey)
+                )
+                .map(Map.Entry::getValue)
+                .forEach(IDemo::demo);
     }
-
 }

src/main/java/org/javademos/commons/ArgsFilterUtil.java

@@ -0,0 +1,158 @@
+package org.javademos.commons;
+
+import org.javademos.init.JEPInfo.JEPData;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * Utility class for filtering and parsing command-line arguments
+ * that determine which JEP demos should be executed.
+ * <p>
+ * This class provides filtering logic based on various criteria
+ * such as JDK version, JEP number, and demo type (code or link-only).
+ * </p>
+ *
+ * <h3>Supported arguments and examples:</h3>
+ * <ul>
+ *   <li><b>--skip-links</b> — Skip demos that only contain links to other JEPs.</li>
+ *   <li><b>--code-only</b> — Run only demos that contain executable code.</li>
+ *   <li><b>--jdk=17,25</b> — Run demos only from the specified JDK versions.</li>
+ *   <li><b>--only=382,409</b> — Run only demos with the specified JEP numbers.</li>
+ * </ul>
+ *
+* <h3>Multiple filters and examples:</h3>
+ * <p>
+ * Multiple filters can be combined. When multiple filters are specified,
+ * only demos that satisfy all active filters are executed.
+ * </p>
+ *
+ * <ul>
+ * <li><b>--jdk=24,25 --code-only</b></li>
+ * <li><b>--jdk=17,21 --skip-links</b></li>
+ * </ul>
+ *
+ *
+ * @author Alexander Schneider @ab-schneider
+ */
+public class ArgsFilterUtil {
+
+    private static final Set<Integer> jdkVersions = new HashSet<>();
+    private static final Set<Integer> specificJeps = new HashSet<>();
+    private static boolean skipLinks = false;
+    private static boolean codeOnly = false;
+
+    private static final String SKIP_LINKS = "--skip-links";
+    private static final String CODE_ONLY = "--code-only";
+    private static final String JDK = "--jdk=";
+    private static final String ONLY = "--only=";
+    private static final String DELIMITER = ",";
+
+    private ArgsFilterUtil() {
+    }
+
+    public static Map<Integer, JEPData> getFilteredJepData(String[] args, Map<Integer, JEPData> jepDataMap) {
+        parseArguments(args);
+        var filtered = filterJepData(jepDataMap);
+        printFilteredInfo(filtered);
+        return filtered;
+    }
+
+    private static void parseArguments(String[] args) {
+        for (String arg : args) {
+            if (SKIP_LINKS.equals(arg)) {
+                skipLinks = true;
+            } else if (CODE_ONLY.equals(arg)) {
+                codeOnly = true;
+            } else if (arg.startsWith(JDK)) {
+                String jdkValues = arg.substring(JDK.length());
+                parseJdkVersions(jdkValues);
+            } else if (arg.startsWith(ONLY)) {
+                String jepValues = arg.substring(ONLY.length());
+                parseSpecificJeps(jepValues);
+            } else {
+                throw new IllegalArgumentException("Unknown arg: " + arg);
+            }
+        }
+    }
+
+    private static void printFilteredInfo(Map<Integer, JEPData> filtered) {
+        System.out.println("\n=== FILTERED JEP INFORMATION ===");
+
+        if (!skipLinks && !codeOnly && specificJeps.isEmpty() && jdkVersions.isEmpty()) {
+            System.out.println("No filters applied. Total JEPs found: " + filtered.size());
+        } else {
+            if (skipLinks) {
+                var linkOnlyCount = filtered.values().stream()
+                        .filter(jepData -> !jepData.link())
+                        .count();
+                System.out.println("Skipped link demos. JEPs found: " + linkOnlyCount);
+            }
+
+            if (codeOnly) {
+                var codeOnlyCount = filtered.values().stream()
+                        .filter(jepData -> !jepData.code())
+                        .count();
+                System.out.println("Skipped no code demos. JEPs found: " + codeOnlyCount);
+            }
+
+            if (!jdkVersions.isEmpty()) {
+                System.out.println("JDK versions: " + jdkVersions);
+            }
+
+            if (!specificJeps.isEmpty()) {
+                System.out.println("Specific JEPs: " + specificJeps);
+            }
+        }
+
+        System.out.println("================================\n");
+    }
+
+    private static void parseJdkVersions(String jdkValues) {
+        String[] versions = jdkValues.split(DELIMITER);
+        for (String version : versions) {
+            try {
+                jdkVersions.add(Integer.parseInt(version.trim()));
+            } catch (NumberFormatException e) {
+                throw new IllegalArgumentException("Invalid JDK version: " + version);
+            }
+        }
+    }
+
+    private static void parseSpecificJeps(String jepValues) {
+        String[] jeps = jepValues.split(DELIMITER);
+        for (String jep : jeps) {
+            try {
+                specificJeps.add(Integer.parseInt(jep.trim()));
+            } catch (NumberFormatException e) {
+                throw new IllegalArgumentException("Invalid JEP number: " + jep);
+            }
+        }
+    }
+
+    private static Map<Integer, JEPData> filterJepData(Map<Integer, JEPData> jepDataMap) {
+        return jepDataMap.entrySet().stream()
+                .filter(entry -> matchesFilters(entry.getValue()))
+                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+    }
+
+    private static boolean matchesFilters(JEPData jepData) {
+        if (skipLinks && jepData.link()) {
+            return false;
+        }
+
+        if (codeOnly && !jepData.code()) {
+            return false;
+        }
+
+        if (!jdkVersions.isEmpty() && !jdkVersions.contains(jepData.jdk())) {
+            return false;
+        }
+
+        if (!specificJeps.isEmpty() && !specificJeps.contains(jepData.jep())) {
+            return false;
+        }
+
+        return true;
+    }
+}

src/main/java/org/javademos/commons/IDemo.java

@@ -1,5 +1,7 @@
 package org.javademos.commons;
 
+import org.javademos.init.JEPInfo;
+
 /// Simple interface to unify the demo building process.
 ///
 /// Override method 'demo()' in your implementation and include new instance
@@ -44,9 +46,9 @@ default void info(String demoName, String demoDscr) {
     /// This method accepts intended number of JEP and looks for data in DEMO_INFO map.
     ///
     /// @param jepNumber JEP number to be displayed
-    /// @see JEPInfo#JEP_INFO
+    /// @see JEPInfo#JEP_DATA
     default void info (int jepNumber) {
-        var demoInfo = JEPInfo.JEP_INFO.get(jepNumber);
+        var demoInfo = JEPInfo.JEP_DATA.get(jepNumber);
         if (demoInfo != null) {
             info(demoInfo.name(), demoInfo.dscr());
         } else {

src/main/java/org/javademos/commons/IDemoLoader.java

@@ -0,0 +1,11 @@
+package org.javademos.commons;
+
+import java.util.Map;
+
+/**
+ * Interface for loading demos for a specific Java version.
+ */
+public interface IDemoLoader {
+
+    void loadDemos(Map<Integer, IDemo> demos);
+}