正文

Scala中正则表达式以及与模式匹配结合(多种方式)

︶ㄣSDDLL学院 メ
SDDLL学院V管理员 / 阅读
0701
这篇文章主要介绍了Scala中正则表达式以及与模式匹配结合,本文给大家介绍了多种模式匹配方式，需要的朋友可以参考下

这篇文章主要介绍了Scala中正则表达式以及与模式匹配结合,本文给大家介绍了多种模式匹配方式，需要的朋友可以参考下

正则表达式

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

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

?
1
2
3
4
5
/** 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()

模式匹配一

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

说明：findAllIn(…)函数简介

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
/** 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)

Scala中正则表达式以及与模式匹配结合(多种方式)

 

模式匹配二

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

Scala中正则表达式以及与模式匹配结合(多种方式)

 

模式匹配三

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

Scala中正则表达式以及与模式匹配结合(多种方式)

 

模式匹配四

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

Scala中正则表达式以及与模式匹配结合(多种方式)

 

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

Scala中正则表达式以及与模式匹配结合(多种方式)

 

本节所有程序源码

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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...")
 }
 }
}

Scala中正则表达式以及与模式匹配结合(多种方式)

总结

以上所述是小编给大家介绍的Scala中正则表达式以及与模式匹配结合(多种方式)，希望对大家有所帮助，如果大家有任何疑问欢迎给我留言，小编会及时回复大家的！

原文链接：https://blog.csdn.net/yizheyouye/article/details/49204595