Scala中正则表达式以及与模式匹配结合

正则表达式

    //"""原生表达
    val regex="""([0-9]+)([a-z]+)""".r
    val numPattern="[0-9]+".r
    val numberPattern="""\s+[0-9]+\s+""".r

• 说明：.r()方法简介：Scala中将字符串转换为正则表达式

  /** You can follow a string with `.r`, turning it into a `Regex`. E.g.
   *
   *  `"""A\w*""".r`   is the regular expression for identifiers starting with `A`.
   */
  def r: Regex = r()

模式匹配一

    //findAllIn()方法返回遍历所有匹配项的迭代器
    for(matchString <- numPattern.findAllIn("99345 Scala,22298 Spark"))
      println(matchString)

• 说明：findAllIn(…)函数简介

  /** Return all non-overlapping matches of this `Regex` in the given character 
   *  sequence as a [[scala.util.matching.Regex.MatchIterator]],
   *  which is a special [[scala.collection.Iterator]] that returns the
   *  matched strings but can also be queried for more data about the last match,
   *  such as capturing groups and start position.
   * 
   *  A `MatchIterator` can also be converted into an iterator
   *  that returns objects of type [[scala.util.matching.Regex.Match]],
   *  such as is normally returned by `findAllMatchIn`.
   * 
   *  Where potential matches overlap, the first possible match is returned,
   *  followed by the next match that follows the input consumed by the
   *  first match:
   *
   *  {{{
   *  val hat  = "hat[^a]+".r
   *  val hathaway = "hathatthattthatttt"
   *  val hats = (hat findAllIn hathaway).toList                     // List(hath, hattth)
   *  val pos  = (hat findAllMatchIn hathaway map (_.start)).toList  // List(0, 7)
   *  }}}
   *
   *  To return overlapping matches, it is possible to formulate a regular expression
   *  with lookahead (`?=`) that does not consume the overlapping region.
   *
   *  {{{
   *  val madhatter = "(h)(?=(at[^a]+))".r
   *  val madhats   = (madhatter findAllMatchIn hathaway map {
   *    case madhatter(x,y) => s"$x$y"
   *  }).toList                                       // List(hath, hatth, hattth, hatttt)
   *  }}}
   *
   *  Attempting to retrieve match information before performing the first match
   *  or after exhausting the iterator results in [[java.lang.IllegalStateException]].
   *  See [[scala.util.matching.Regex.MatchIterator]] for details.
   *
   *  @param source The text to match against.
   *  @return       A [[scala.util.matching.Regex.MatchIterator]] of matched substrings.
   *  @example      {{{for (words <- """\w+""".r findAllIn "A simple example.") yield words}}}
   */
  def findAllIn(source: CharSequence) = new Regex.MatchIterator(source, this, groupNames)

模式匹配二

    //找到首个匹配项
    println(numberPattern.findFirstIn("99ss java, 222 spark,333 hadoop"))

模式匹配三

    //数字和字母的组合正则表达式
    val numitemPattern="""([0-9]+) ([a-z]+)""".r
    val numitemPattern(num, item)="99 hadoop"

模式匹配四

    //数字和字母的组合正则表达式
    val numitemPattern="""([0-9]+) ([a-z]+)""".r
    val line="93459 spark"
    line match{
      case numitemPattern(num,blog)=> println(num+"\t"+blog)
      case _=>println("hahaha...")
    }

val line="93459h spark"
    line match{
      case numitemPattern(num,blog)=> println(num+"\t"+blog)
      case _=>println("hahaha...")
    }

本节所有程序源码

package kmust.hjr.learningScala19


/**
 * Created by Administrator on 2015/10/17.
 */
object RegularExpressOps {
  def main(args:Array[String]):Unit={
    val regex="""([0-9]+)([a-z]+)""".r//"""原生表达
    val numPattern="[0-9]+".r
    val numberPattern="""\s+[0-9]+\s+""".r

    //findAllIn()方法返回遍历所有匹配项的迭代器
    for(matchString <- numPattern.findAllIn("99345 Scala,22298 Spark"))
      println(matchString)

    //找到首个匹配项
    println(numberPattern.findFirstIn("99ss java, 222 spark,333 hadoop"))

    //数字和字母的组合正则表达式
    val numitemPattern="""([0-9]+) ([a-z]+)""".r

    val numitemPattern(num, item)="99 hadoop"

    val line="93459h spark"
    line match{
      case numitemPattern(num,blog)=> println(num+"\t"+blog)
      case _=>println("hahaha...")
    }
  }
}

附录