Extracting numbers from a String using regular expressions

[Nicholas van Orton]

Hi all,

I'm completely new to regular expressions and I'm having a little trouble grasping all the concepts behind how to use regular expressions.

I have a String array that contains a series of weights:

weights[0] = "100 kg", weights[1] = "105 kg", etc.

At the moment, I'm adding up all the weights using a StringTokenizer to extract the numbers as follows:

int totalWeight = 0;
 
for (int i = 0; i < weights.length; i++) {
     StringTokenizer st = new StringTokenizer(weights[i]);
     totalWeight += Integer.parseInt(st.nextToken());
}

I'm figuring that this is a rather inefficient way of doing things, as a new StringTokenizer object is created and subsequently destroyed on every run through the for loop.

Thus I turned to regular expressions for help. At the moment I've got:

Pattern p = Pattern.compile(\\d\\d\\d);
Matcher m = null;
 
for (int i = 0; i < weights.length; i++) {
     m = p.matcher(weights[i]);
}

What I'm suppose to do now is where I'm lost. I've even tried the following, to no avail.

Pattern p = Pattern.compile(\\d\\d\\d);
int totalWeights = 0;
 
for (int i = 0; i < weights.length; i++) {
     totalWeights += Integer.parseInt(p.split(weights[i]));
}

Any help would be very much appreciated.

Thanks

[Alan Moore]

Pattern p = Pattern.compile(\\d+);
Matcher m = null;
int totalWeights = 0;
 
for (int i = 0; i < weights.length; i++) {
    m = p.matcher(weights[i]);
    if (m.find()) {
        totalWeights += Integer.parseInt(m.group());
    } 
}

[Garrett Rowe]

To capture a matche using Pattern/Matcher you need to do something like this

String regex = "\\d+"
 
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(someString);
 
while (matcher.find())
{
   String match = matcher.group();
 
   //do something with match
}
 
//to change the String the Matcher is looking at use:
matcher.reset(newString);

[Stefan Wagner]

"A foolproof method for sculpting an elephant: first, get a huge block of marble, then you chip away everything that doesn't look like an elephant."

Integer.parseInt (weight[i].replaceAll (" kg", "")); //�

� weight[i].substring (0, len-3); is another idea that comes to mind - consult the api-doc for the right usage of the numeric parameters (from, to).

It is another diskussion, how many objects are created behind the scene by using ([Pattern/ Matcher], [replaceAll], [StringTokenizer]).

Create a program to compare these approaches, and increase the number of weights until the results differ significantly, but study techniques for microbenchmarks first, because it's easy to do it wrong.

Or analyze the sourcecode of ([Pattern/ Matcher], [replaceAll], [StringTokenizer]).

Don't forget to post the results.
[ March 30, 2006: Message edited by: Stefan Wagner ]

[Nicholas van Orton]

I really appreciate all of these replies, thank you.

This is definately a great place to learn more about and share ideas about Java.