L'entrée du système dans Java ne fonctionne pas correctement

Question

J'essaye de créer un programme qui prend Ints et donne-moi une somme et je veux le faire en utilisant regex. L'entrée contient des chiffres, des symboles et des lettres. Par exemple, quand je vous écris: java GiveMeSum 4 2 1 -5 ou java GiveMeSum 4k « 2 1 programme -5 devrait écrire Mais il me donne non seulement une mauvaise réponse, mais aussi ne pas tout lu! mon entrée Quand j'écris.

java GiveMeSum 4 2 1 -5 

Exception in thread "main" java.util.InputMismatchException 
at java.util.Scanner.throwFor(Scanner.java:864) 
at java.util.Scanner.next(Scanner.java:1485) 
at java.util.Scanner.nextInt(Scanner.java:2117) 
at java.util.Scanner.nextInt(Scanner.java:2076) 
at GiveMeSum.main(GiveMeSum.java:12) 


public class GiveMeSum { 

public static void main(String[] args) throws IOException { 
    int sum = 0; 
    Scanner sc = new Scanner(System.in).useDelimiter("(\\D|^-)"); 
    for (int i = 0; i < args.length; i++) { 
     sum += sc.nextInt(); 
    } 
    System.out.println(sum); 
} 

}

Il n'y avait pas non plus cette exception. Cela vient de se manifester soudainement

Answer 1

Cela se produit parce que vous passez "4 2 1 -5" non pas comme entrée mais comme argument pour qu'ils entrent dans le paramètre args de la méthode main. Pour les transmettre comme entrée attente jusqu'à ce que le début de l'application et de les entrer ou utiliser input stream redirection

Mise à jour (code de traitement des arguments)

Comment devrais-je écrire en java pour prendre d'entrée comme arguments alors? Existe-t-il un moyen simple et spécifique?

Je dirais que l'utilisation d'arguments pour un nombre de paramètres d'entrée non-fixes n'est pas une bonne idée. Je dirais toujours que l'utilisation du flux d'entrée est la solution - c'est pour ça que ça a été conçu! De plus, vos exigences d'analyse sont un peu exagérées. Pourtant voici ma tentative

public class Main 
{ 
    static OptionalInt parseOnlyInt(String s) 
    { 
     String digitsOnly = s.replaceAll("[^0-9]", ""); 
     if (digitsOnly.length() == 0) 
      return OptionalInt.empty(); 
     else 
      return OptionalInt.of(Integer.parseInt(digitsOnly)); 
    } 

    public static void main(String[] args) 
    { 
     int sum = Arrays.stream(args) 
       .map(Main::parseOnlyInt) 
       // probably in Java 9 OptionalInt::stream would be better than next 2 lines 
       // see https://bugs.openjdk.java.net/browse/JDK-8050820 
       .filter(OptionalInt::isPresent) 
       .mapToInt(OptionalInt::getAsInt) 
       .sum(); 

     System.out.println(Arrays.toString(args)); 
     System.out.println(sum);  
    } 
} 

Ou si vous préférez l'ancienne (non-Java-8) ici il est

public static void main(String[] args) 
{ 
    int sum = 0; 
    for (int i = 0; i < args.length; i++) 
    { 
     String digitsOnly = args[i].replaceAll("[^0-9]", ""); 
     if (digitsOnly.length() != 0) 
      sum += Integer.parseInt(digitsOnly); 
    } 
    System.out.println(Arrays.toString(args)); 
    System.out.println(sum); 
} 

Answer 2

System.in est le flux d'entrée. Il obtient seulement des données après que votre programme commence. Essayez de regarder le paramètre args à main. C'est là que les données sont placées quand elles sont transmises au moment de l'invocation.

Answer 3

Une solution oneliner simple à prendre des arguments et somme d'impression

public static void main(String[] args) { 
    int sum = Arrays.stream(args) // Create a stream from the array 
      .mapToInt(Integer::parseInt) // Parse the strings as integers 
      .sum(); // Sum 
    System.out.println(sum); 
}