View difference between Paste ID: gGSZCQvu and y1LxLZNM

 import java.util.Map;
 import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.ArrayList;
 import java.util.InputMismatchException;
 import java.util.Iterator;
 
 public class ArgParser{
 
     public static void main(String[] args) {
         Map<String, List<String>> parsedArgs = parseArgs(args);
         Map<String, String[]> rules = new HashMap<String, String[]>();
 
         rules.put("-filmes", new String[]{"nome_ator1", "nome_ator2", "decada"});
         rules.put("-episodios", new String[]{"nome_ator", "titulo_serie"});
         rules.put("-generos", new String[]{"nome_ator"});
-        if(!validateArgs(parsedArgs, rules, true, true))
+
-            return;
+        if(validateArgs(parsedArgs, rules, false, true, true))
             for(Map.Entry<String, List<String>> arg: parsedArgs.entrySet()) {
-        for(Map.Entry<String, List<String>> arg: parsedArgs.entrySet()) {
+                System.out.println(arg.getKey());
-            System.out.println(arg.getKey());
+
                 if(arg.getValue() != null)
-            if(arg.getValue() != null)
+                    for(String subArg: arg.getValue())
-                for(String subArg: arg.getValue())
+                        System.out.println("\t" + subArg);
-                    System.out.println("\t" + subArg);
+
     }
 
     public static Map<String, List<String>> parseArgs(String[] args) {
         Map<String, List<String>> result = new LinkedHashMap<String, List<String>>();
         List<String> params = null;
 
         for(String arg: args)
             if(arg.startsWith("-"))
                 result.put(arg, params = new ArrayList<String>());
             else if(params != null)
                 params.add(arg);
             else
                 result.put(arg, null);
 
         return result;
     }
 
     public static Boolean validateArgs(Map<String, List<String>> args, Map<String, String[]> rules, Boolean anonArgs, Boolean aLeastOne, Boolean sanitize) {
-    public static Boolean validateArgs(Map<String, List<String>> args, Map<String, String[]> rules, Boolean anonArgs, Boolean aLeastOne) {
+
 
         Iterator<Map.Entry<String, List<String>>> it = args.entrySet().iterator();
-        if(aLeastOne && args.isEmpty())
+        while(it.hasNext()) {
             Map.Entry<String, List<String>> arg = it.next();
 
-        for(Map.Entry<String, List<String>> arg: args.entrySet()) {
+
 
             if(rules.containsKey(arg.getKey())) {
                 if(params != null && (arg.getValue() == null || arg.getValue().size() != params.length)) {
                     String Msg = String.format("O argumento <%s> espera %d parametro(s).\nModo de uso: <%s>"
                                               , arg.getKey(), params.length, arg.getKey());
 
                     for(String str: params)
                         Msg += " <" + str + ">";
 
                     System.err.println(Msg);
                     result = false || sanitize;
-                    result = false;
+                    if(sanitize)
                         it.remove();
                 }
             } else if(arg.getValue() != null || !anonArgs) {
-                result = false;
+
                 result = false || sanitize;
                 if(sanitize)
                     it.remove();
             }
         }
 
         if(aLeastOne && args.isEmpty()) {
             System.err.println("E necessario ao menos um argumento!");
             result = false;
         }
 
         return result;
     }
 }