Storing numeric input - Why does Java Scanner nextInt() allows "invalid" zero filled integers?

Question

I'm creating a phone directory which will consist of multiple nameEntry objects each containing a surname and a phone extension.

public class nameEntry {

    public String surname;
    public String number;

    public nameEntry(String surname, int number) {
        this.surname = surname.toUpperCase();
        this.number = String.format("%04d", number); 
        // converts int literal to 0 filled string of numbers
    }

    public String toString() {
        return surname + "\t" + number; //eg HOOD     0123
    }
}

Having read into good java practice about storing alphanumerics I have programmed the nameEntry objects to take an int as a parameter and then convert it to a zero filled String, because storing as int Objects would be inappropriate given their nature. However, this approach means that I cannot create new nameEntry objects with zero filled numbers by this method as it tells me the integers are invalid;

nameEntry e = new nameEntry(surname, 0123); //this would be flagged as wrong

However if I use a Scanner nextInt(System.in) method, is it perfectly happy with me entering a zero filled digit and then using that object to create a new nameEntry object.

Why is this scenario valid?

Regardless, this all seems over the top just to get a single zero filled input string - what is a better way of allowing a user to enter a single number of up to 4 characters that is either zero filled, or will be automatically zero filled after entry?

It is but as pointed by @peter.petrov , it is an octal. Hence, 08 does not exist and is not a valid integer. 0123 still exists. — Arnaud Denoyelle, Feb 24 '14 at 20:01
Your example would *not* be "flagged as wrong" since `0123` is a perfectly valid octal literal. — Brian Roach, Feb 24 '14 at 20:02
@GIJoe So octals like 0123 are not integers? What are they - Strings, Lists, Maps? — peter.petrov, Feb 24 '14 at 20:02
"`0123` is not a *decimal* integer in Java" might convey your point more clearly. It certainly is *an* integer, just not the one you'd expect. — dimo414, Feb 24 '14 at 20:03
@peter.petrov: It is an octal literal. `83` is a decimal integer. — Engineer2021, Feb 24 '14 at 20:04
@davidhood2 to answer you, I don't understand why you take an int as an input and not a String? It would be easier to take a String and validate it with a regex. — Arnaud Denoyelle, Feb 24 '14 at 20:06
@GIJoe It's an *integer value*. The fact that it's expressed in octal doesn't matter. `int foo = 0123;` is perfectly valid Java. The OP's example is also valid and will not produce an error. — Brian Roach, Feb 24 '14 at 20:06
@GIJoe It is an octal literal, yes. And its value is integer, not double or float or boolean or char. — peter.petrov, Feb 24 '14 at 20:07
And in the end, the whole octal thing is just a red herring. Java ignores leading zeroes when parsing an int from a string when the radix is 10. Everyone (including myself) got sidetracked by the (non-related) octal literal in the OP's example. — Brian Roach, Feb 24 '14 at 20:23

score 1 · Accepted Answer · answered Feb 24 '14 at 20:16

storing [a phone number] as ints would be inappropriate given their nature.

So why are you reading them in as ints? Why not use Scanner.next() or Scanner.nextLine(), since you know phone numbers aren't (conceptually) numbers?

You should expect your user to pass in exactly the phone number they expect. Attempting to transform it (e.g. letting them leave leading 0s off and filling them in yourself) is a recipe for confusion and bugs. Rather than transforming the user's input, add sanity checks, such as a regex, to confirm the user provided valid input.

public class nameEntry {
  private static final Pattern VALID_NUMBER = Pattern.compile("\\d{4}");
  private String surname;
  private String number;

  public nameEntry(String surname, String number) {
    this.surname = surname;
    if(!VALID_NUMBER.matcher(number).matches()) {
      throw new IllegalArgumentException(number+
                " does not appear to be a valid phone number.");
    }
    this.number = number;
  }

  @Override
  public String toString() {
    return surname + "\t" + number; //eg HOOD     0123
  }
}

Sorry I forgot to mention that I used int's so that, when reading them in to create the object it throws an error if you attempt to put non numerical characters, whereas if it was a String I dont know how I would achieve the equivalent effect - but you've answered that anyway so thanks! — davidhood2, Feb 24 '14 at 20:41

Brian Roach · Answer 2 · 2014-02-24T20:26:24.610

1

When parsing an integer value from a String (including when you use a Scanner and its nextInt() method), Java simply ignores the leading zero when the radix is 10 (decimal, which is the default).

String bar = "0123";
int foo = Integer.valueOf(bar);
System.out.println(foo);

Output:

123

If you need to specifically exclude input that has a leading 0 then you would need to read the input as a String and check for yourself whether or not there's a leading zero.

edited Feb 24 '14 at 20:26

answered Feb 24 '14 at 20:21

Brian Roach

76,169
12
136
161

@davidhood2 Under the covers all `Scanner` is doing is exactly what I posted. You'd simply check for leading zeroes *first* then parse the `String` to an `int` as shown above if that's what you want. – Brian Roach Feb 24 '14 at 20:42

Storing numeric input - Why does Java Scanner nextInt() allows "invalid" zero filled integers?

2 Answers2