Extract number from string. Regular expression vs Try construct? - regex

Question

This question was inspired by Extract numbers from String Array question.
Consider we have a List of arbitrary alphabetic and numeric strings:
val ls = List("The", "first", "one", "is", "11", "the", "second", "is" "22")
The goal is to form a list of numbers extracted from the original list: val nums: List[Int] = List(11, 22)
There are two different approaches possible (AFAIK):
Using Try construct:
val nums = ls.flatMap(s => Try(s.toInt).toOption)
This solution looks concise but it will have a huge overhead to handle exceptions.
Using matches method:
val nums = ls.filter(_.matches("\\d+")).map(_.toInt)
Here the most time-consuming part is regexp matching.
Which one is better by performance?
From my point of view usage of exception mechanism in such simple operation is a like "using a sledge-hammer to crack a nut".

Answer 1

I highly recommend you test this stuff out yourself, you can learn a lot! Commence Scala REPL:
scala> import scala.util.Try
import scala.util.Try
< import printTime function from our repo >
scala> val list = List("The", "first", "one", "is", "11", "the", "second", "is", "22")
list: List[String] = List(The, first, one, is, 11, the, second, is, 22)
scala> var x: List[Int] = Nil
x: List[Int] = List()
OK, the environment is set up. Here's your first function (Try):
scala> def f1(l: List[String], n: Int) = {
var i = 0
while (i < n) {
x = l.flatMap(s => Try(s.toInt).toOption)
i += 1
}
}
f1: (l: List[String], n: Int)Unit
The second function (regex):
scala> def f2(l: List[String], n: Int) = {
var i = 0
while (i < n) {
x = l.filter(_.matches("\\d+")).map(_.toInt)
i += 1
}
}
f2: (l: List[String], n: Int)Unit
Timings:
scala> printTime(f1(list, 100000)) // Try
time: 4.152s
scala> printTime(f2(list, 100000)) // regex
time: 565.107ms
Well, we've learned that handling exceptions inside a flatMap is a very inefficient way to do things. This is partly because exception handling produces bad assembly code, and partly because flatMaps with options do a lot of extra allocation and boxing. Regex is ~8x faster! But...is regex fast?
scala> def f3(l: List[String], n: Int) = {
var i = 0
while (i < n) {
x = l.filter(_.forall(_.isDigit)).map(_.toInt)
i += 1
}
}
f3: (l: List[String], n: Int)Unit
scala> printTime(f3(list, 100000)) // isDigit
time: time: 70.960ms
Replacing regex with character isDigit calls gave us another order of magnitude improvement. The lesson here is to avoid try/catch handling at all costs, avoid using regex whenever possible, and don't be afraid to write performance comparisons!