Java – How to deal with accidental input of a double when using .nextInt() in Java

exceptionjavatry-catch

So I am trying to deal with the possible exception of a user entering a double when my scanner is expecting integral input:

boolean go = true;
do {
        System.out.print("Please enter one grade from 0 - 100. To end input, enter a        
        negative integral value.\n");
    try {
            int myInt = scanner.nextInt();
            .
            .
            .
    }
    catch (InputMismatchException e) {
            System.out.println("Oops!! Please enter only integral numbers");
    }
while (go);

This works for non-numerical input (i.e. a letter), but not if I enter, say 3.14 or another ASCII symbol like -. In that case, the lines below repeat until I kill the program.

Please enter one grade from 0 - 100. To end input, enter a negative integral value.
Oops!! Please enter only integral numbers.

Any ideas? 😀

Reply: I am using System.in, and java 6.

Best Solution

My guess, that when you say explodes, you mean that you are getting an infinite loop of

Oops!! Please enter only integral numbers

Try doing the following instead:

try {
  int myInt = scanner.nextInt();
  // …
}
catch (InputMismatchException e) {
  System.out.println("Oops!! Please enter only integral numbers");
  System.out.println(scanner.next() + " was not valid input.");
}

Edit: I see that my initial guess was right ;-)

The reason that this is happening is that when nextInt() fails, the internal pointer is not moved on, and so every time that you can nextInt again, it fails on the same token. So, you need to clear the token out first, which is what I am doing by printing out the text that is invalid input. This then causes a new token to be read from the input stream.

Related Solutions

Java – How to deal with “java.lang.OutOfMemoryError: Java heap space” error

Ultimately you always have a finite max of heap to use no matter what platform you are running on. In Windows 32 bit this is around 2GB (not specifically heap but total amount of memory per process). It just happens that Java chooses to make the default smaller (presumably so that the programmer can't create programs that have runaway memory allocation without running into this problem and having to examine exactly what they are doing).

So this given there are several approaches you could take to either determine what amount of memory you need or to reduce the amount of memory you are using. One common mistake with garbage collected languages such as Java or C# is to keep around references to objects that you no longer are using, or allocating many objects when you could reuse them instead. As long as objects have a reference to them they will continue to use heap space as the garbage collector will not delete them.

In this case you can use a Java memory profiler to determine what methods in your program are allocating large number of objects and then determine if there is a way to make sure they are no longer referenced, or to not allocate them in the first place. One option which I have used in the past is "JMP" http://www.khelekore.org/jmp/.

If you determine that you are allocating these objects for a reason and you need to keep around references (depending on what you are doing this might be the case), you will just need to increase the max heap size when you start the program. However, once you do the memory profiling and understand how your objects are getting allocated you should have a better idea about how much memory you need.

In general if you can't guarantee that your program will run in some finite amount of memory (perhaps depending on input size) you will always run into this problem. Only after exhausting all of this will you need to look into caching objects out to disk etc. At this point you should have a very good reason to say "I need Xgb of memory" for something and you can't work around it by improving your algorithms or memory allocation patterns. Generally this will only usually be the case for algorithms operating on large datasets (like a database or some scientific analysis program) and then techniques like caching and memory mapped IO become useful.

Java – How to invoke a Java method when given the method name as a string

Coding from the hip, it would be something like:

java.lang.reflect.Method method;
try {
  method = obj.getClass().getMethod(methodName, param1.class, param2.class, ..);
} catch (SecurityException e) { ... }
  catch (NoSuchMethodException e) { ... }

The parameters identify the very specific method you need (if there are several overloaded available, if the method has no arguments, only give methodName).

Then you invoke that method by calling

try {
  method.invoke(obj, arg1, arg2,...);
} catch (IllegalArgumentException e) { ... }
  catch (IllegalAccessException e) { ... }
  catch (InvocationTargetException e) { ... }

Again, leave out the arguments in .invoke, if you don't have any. But yeah. Read about Java Reflection

Best Solution

Related Solutions

Java – How to deal with “java.lang.OutOfMemoryError: Java heap space” error

Java – How to invoke a Java method when given the method name as a string

Related Question