Taking an integer from a scanner token that may or may not include symbols

I have a function that takes a scanner of a text file as input, and I need to extract integer values from each line. These lines might not follow a rigid syntax.

I have tried to to use skip() to ignore specific non-integers, but I fear I may be using it for something it's not capable of.

I've also tried turning the token into a string and using replaceAll(";", ""), but that quickly turns my code into a mess of if statements and String to int conversions. It gets bad quite fast considering I have a lot of different variables that need to be set here.

Is there is a more elegant solution?

Here is my input file:

pop 25; // my code must accept this
pop 25 ; // and also this
house 3.2, 1; // some lines will set multiple values
house 3.2 , 1 ; // so I will need to ignore both commas and semicolons

Here is my code:

static int population = -1;
static double median = -1;
static double scatter = -1;

private static void readCommunity(Scanner sc) {
    while (sc.hasNext()) {
        String input = sc.next();
        if ("pop".equals(input)) {
            sc.skip(";*"); // my guess is this wouldn't work unless the
                           // token had a ';' BEFORE the integer
            if (sc.hasNextInt()) {
                population = sc.nextInt();
            } else { // throw an error. not important here }
            sc.nextLine();
        } else if ("house".equals(input)) {
            sc.skip(",*");
            if (sc.hasNextDouble()) {
                median = sc.nextDouble;
                sc.skip(";*");
                if (sc.hasNextDouble()) {
                    scatter = sc.nextDouble();
                } else { // error }
            } else { // error }
            sc.nextLine();
        }
    } 
}

In my opinion, I think it's just easier to read each entire file data line then split that line into what I need, and do validations on the read in data values, etc. For example:

private static void readCommunity(String dataFilePath) {
File file = new File(dataFilePath);
if (!file.exists()) {
System.err.println("File Not Found! (" + dataFilePath + ")");
return;
}
int lineCount = 0;   // For counting file lines.
// 'Try With Resources' used here so as to auto-close reader.
try (Scanner sc = new Scanner(file)) {
while (sc.hasNextLine()) {
String fileInput = sc.nextLine().trim();
lineCount++;   // Increment line counter.
// Skip blank lines (if any).
if (fileInput.isEmpty()) {
continue;
}
/* Remove comments from data line (if any). Your file 
example shows comments at the end of each line. Yes, 
I realize that your file most likely doesn't contain 
these but it doesn't hurt to have this here in case 
it does or if you want to have that option. Comments
can start with // or /*. Comments must be at the end
of a data line. This 'does not' support any Multi-line 
comments. More code is needed for that.            */
if (fileInput.contains("//") || fileInput.contains("/*")) {
fileInput = fileInput.substring(0, fileInput.contains("//")
? fileInput.indexOf("//") : fileInput.indexOf("/*"));
}
// Start parsing the data line into required parts...
// Start with semicolon portions
String[] lineMainParts = fileInput.split("\\s{0,};\\s{0,}");
/* Iterate through all the main elemental parts on a 
data line (if there is more than one), for example:
pop 30; house 4.3, 1; pop 32; house 3.3, 2   */
for (int i = 0; i < lineMainParts.length; i++) {
// Is it a 'pop' attribute?
if (lineMainParts[i].toLowerCase().startsWith("pop")) {
//Yes it is... so validate, convert, and display the value.
String[] attributeParts = lineMainParts[i].split("\\s+");
if (attributeParts[1].matches("-?\\d+|\\+?\\d+")) {   // validate string numerical value (Integer).
population = Integer.valueOf(attributeParts[1]);  // convert to Integer
System.out.println("Population:\t" + population); // display...
}
else {
System.err.println("Invalid population value detected in file on line "
+ lineCount + "! (" + lineMainParts[i] + ")");
}
}
// Is it a 'house' attribute?
else if (lineMainParts[i].toLowerCase().startsWith("house")) {
/* Yes it is... so split all comma delimited attribute values
for 'house', validate each numerical value, convert each 
numerical value, and display each attribute and their 
respective values.  */
String[] attributeParts = lineMainParts[i].split("\\s{0,},\\s{0,}|\\s+");
if (attributeParts[1].matches("-?\\d+(\\.\\d+)?")) {   // validate median string numerical value (Double or Integer).
median = Double.valueOf(attributeParts[1]);        // convert to Double.
System.out.println("Median:     \t" + median);     // display median...
}
else {
System.err.println("Invalid Median value detected in file on line "
+ lineCount + "! (" + lineMainParts[i] + ")");
}
if (attributeParts[2].matches("-?\\d+|\\+?\\d+")) {   // validate scatter string numerical value (Integer).
scatter = Integer.valueOf(attributeParts[2]);     // convert to Integer
System.out.println("Scatter:    \t" + scatter);   // display scatter...
}
else {
System.err.println("Invalid Scatter value detected in file on line "
+ lineCount + "! (" + lineMainParts[i] + ")");
}
}
else {
System.err.println("Unhandled Data Attribute detected in data file on line " + lineCount + "! ("
+ lineMainParts[i] + ")");
}
}
}
}
catch (FileNotFoundException ex) {
System.err.println(ex);
}
}

There are several Regular Expressions (RegEx) used in the code above. Here is what they mean in the order they are encountered in code:

"\\s{0,};\\s{0,}"

Used with the String#split() method for parsing a semicolon (;) delimited line. This regex pretty much covers the bases for when semicolon delimited string data needs to be split but the semicolon may be spaced in several different fashions within the string, for example:

"data;data ;data; data ; data;      data       ;data"

• \\s{0,} 0 or more whitespaces before the semicolon.
• ; The literal semicolon delimiter itself.
• \\s{0,} 0 or more whitespaces after the semicolon.

"\\s+"

Used with the String#split() method for parsing a whitespace (" ") delimited line. This regex pretty much covers the bases for when whitespaced delimited string data needs to be split but there may be anywhere from 1 to several whitespace or tab characters separating the string tokens for example:

"datadata"                      Split to: [datadata] (Need at least 1 space)
"data data"                     Split to: [data, data] 
"data   data"                   Split to: [data, data] 
"data        data       data"   Split to: [data, data, data] 

"-?\\d+|\\+?\\d+"

Used with the String#matches() method for string numerics validation. This regex is used to see if the tested string is indeed a string representation of a signed or unsigned integer numerical value (of any length). Used in the code above for numerical string validation before converting that numerical value to Integer. String representations can be:

-1   1   324   +2   342345   -65379   74   etc.

• -? If the string optionally starts with or doesn't start with the
  Hyphen character indicating a signed value.
• \\d+ The string contains 1 or more (+) digits from 0
  to 9.
• | Logical OR
• \\+? If the string optionally starts with or doesn't start with the
  Plus character.
• \\d+ The string contains 1 or more (+) digits from 0
  to 9.

"\\s{0,},\\s{0,}|\\s+" (must be in this order)

Used with the String#split() method for parsing a comma (,) delimited line. This regex pretty much covers the bases for when comma delimited string data needs to be split but the comma may be spaced in several different fashions within the string, for example:

"my data,data"            Split to: [my, data, data] 
"my data ,data"           Split to: [my, data, data] 
"my data, data"           Split to: [my, data, data] 
"my data , data"          Split to: [my, data, data] 
"my   data,      data"    Split to: [my, data, data] 
"my    data      ,data"   Split to: [my, data, data] 

• \\s{0,} 0 or more whitespaces before the comma.
• , The literal comma delimiter itself.
• \\s{0,} 0 or more whitespaces after the comma.
• | Logical OR split on...
• \\s+ Just one or more whitespace delimiter.

So in other words, split on either: just comma OR split on comma and one or more whitespaces OR split on one or more whitespaces and comma OR split on one or more whitespaces and comma and one or more whitespaces OR split on just one or more whitespaces

"-?\\d+(\\.\\d+)?"

Used with the String#matches() method for string numerics validation. This regex is used to see if the tested string is indeed a string representation of a signed or unsigned integer or double type numerical value (of any length). Used in the code above for numerical string validation before converting that numerical value to Double. String representations can be:

-1.34   1.34   324   2.54335   342345   -65379.7   74   etc.

• -? If the string optionally starts with or doesn't start with the
  Hyphen character indicating a signed value.
• \\d+ The string contains 1 or more (+) digits from 0
  to 9. [The string would be considered Integer up to this point.]
• ( Start of a Group.
• \\. If the string contains a literal Period (.) after the first set of digits.
• \\d+ The string contains 1 or more (+) digits from 0 to 9 after the Period.
• ) End of Group.
• ? The data expressed within the Group expression may or may not be there making the Group an Option Group.

Hopefully, the above should be able to get you started.

A regex would probably be a better choice instead of a nextInt or a nextDouble. You could fetch each decimal value using

Pattern p = Pattern.compile("\\d+(\\.\\d+)?");
Matcher m = p.matcher(a);
while(m.find()) {
System.out.println(m.group());
}

The regex checks for all occurrences of a decimal or non-decimal number in the given string.

\\d+ - One or more occurrence of a digit

(\\.\\d+) - Followed by a decimal and one or more digits

? - The expression in the parantheses is optional. So, the numbers may or may not contain decimals.

This will print the below for the data you provided

25
25
3.2
1
3.2
1

EDIT:

The problem you have with commas and semi-colons while parsing the line can be avoided by fetching the entire line using nextLine() instead of next(). next() only fetches one token at a time from the input. Using nextLine and a regular expression, you can read individual numbers as below.

      while (sc.hasNext()) {
Pattern p = Pattern.compile("\\d+(\\.\\d+)?");
Matcher m ;
int population = -1;
double median = -1;
double scatter = -1;
String input = sc.nextLine();	// fetches the entire line		
if (input.contains("pop")) {							
m = p.matcher(input);
while (m.find()) {
population = Integer.parseInt(m.group());
}
} else if (input.contains("house")) {
m = p.matcher(input);
m.find();
median = Double.parseDouble(m.group());
m.find();
scatter = Double.parseDouble(m.group());
}   			
}