Scala中的String类就是Java的String类,所以可以直接调用Java里String的所有方法。
- 查看字符串的类型
scala> "Hello, world".getClass.getName
res1: String = java.lang.String
- 获取字符串长度
scala> val s = "Hello, world"
s: String = Hello, world
scala> s.length
res2: Int = 12
- 连接字符串
scala> val s = "Hello" + " world"
s: String = Hello world
scala> s
res4: String = Hello world
- 把String当作字符序列来处理,可以通过foreach方法遍历字符串中的每个字符。
scala> "Hello".foreach(println)
H
e
l
l
o
- 可以通过for循环把字符串当做字符序列来处理
scala> for(c <- "hello") println(c)
h
e
l
l
o
- 可以将字符串当做字节序列
scala> s.getBytes.foreach(println)
72
101
108
108
111
32
119
111
114
108
100
- 字符串还可以使用filter这样的函数式方法
scala> val result = "hello world".filter(_ != '1')
result: String = hello world
- Scala拥有String和Collection中的功能
// drop(n)方法是从集合头部开始,丢弃n个元素,并保留剩余元素的集合方法
scala> "scala".drop(2)
res8: String = ala
// take(n)方法会保留所给集合的头n个元素,然后丢弃剩余的部分
scala> res8.take(2)
res9: String = al
scala> res9.capitalize
res10: String = Al
- 测试字符串相等
Scala中提供==操作符来比较两个字符串的实例
scala> val s1 = "Hello"
s1: String = Hello
scala> val s2 = "Hello"
s2: String = Hello
scala> val s3 = "H" + "ello"
s3: String = Hello
scala> s1 == s2
res11: Boolean = true
scala> s1 == s3
res12: Boolean = true
scala> s1 == s3
使用==,当字符串是null是也不会抛出NullPointerException
scala> val s4: String = null
s4: String = null
scala> s3 == s4
res14: Boolean = false
如果比较两个字符串时,不考虑字符大小写问题,可以直接将字符串先转成全部大写或者全部小写,然后使用==方法
scala> val s1 = "hello"
s1: String = hello
scala> val s2 = "hello"
s2: String = hello
scala> s1.toUpperCase == s2.toUpperCase
res16: Boolean = true
也可以忽略大小写比较两个字符串
scala> val a = "Marisa"
a: String = Marisa
scala> val b = "marisa"
b: String = marisa
scala> a.equalsIgnoreCase(b)
res17: Boolean = true
- 在Scala中,可以用三个双引号创建多行的字符串
scala> val foo = """This is
| a multiline
| String"""
foo: String =
This is
a multiline
String
scala> foo
res18: String =
This is
a multiline
String
使用如下方法左对齐第一行之后的每一行
scala> val speech = """Four score and
| |seven years age""".stripMargin
speech: String =
Four score and
seven years age
也可以自定义上面代码中的管道符,如下:
scala> val speech = """Four score and
| #seven years ago""".stripMargin('#')
speech: String =
Four score and
seven years ago
scala> speech
res19: String =
Four score and
seven years ago
将多个字符串转换成一个连续的行
scala> val speech = """Four score and
| |seven years ago
| |our fathers""".stripMargin.replace("\n", " ")
speech: String = Four score and seven years ago our fathers
scala> speech
res20: String = Four score and seven years ago our fathers
Scala中多行字符串可以包括单引号和双引号,无需对其进行转意
scala> val s = """This is know as a
| |"multline" string
| |or 'heredoc' syntax.""".stripMargin.replace("\n", " ")
s: String = This is know as a "multline" string or 'heredoc' syntax.
scala> s
res21: String = This is know as a "multline" string or 'heredoc' syntax.
- 分割字符串,使用String对象中的split()方法,作用的结果是产生一个以字符串为元素的一个数组
scala> "hello world".split(" ")
res22: Array[String] = Array(hello, world)
scala> "hello world".split(" ").foreach(println)
hello
world
scala> val s = "eggs,milk,butter,Coco Puffs"
s: String = eggs,milk,butter,Coco Puffs
scala> s.split(",")
res25: Array[String] = Array(eggs, milk, butter, Coco Puffs)
scala> s.split(",").map(_.trim)
res27: Array[String] = Array(eggs, milk, butter, Coco Puffs)
// 使用正则表达式空格分割一个字符串
scala> "hello world, this is Al".split("\\s+")
res29: Array[String] = Array(hello, world,, this, is, Al)
- 字符串中的变量替换,Scala中基础的字符串插值就是在字符串前加字幕‘s’,然后在字符串中放入变量,每个变量都应以‘$’开头。字符串前加字母‘s’时,其实是在创建一个处理字符串字面量
scala> val name = "GnahzNib"
name: String = GnahzNib
scala> val age = 33
age: Int = 33
scala> val weight = 140.0
weight: Double = 140.0
scala> println(s"$name is $age years old, and weights $weight pounds.")
GnahzNib is 33 years old, and weights 140.0 pounds.
在字符串字面量中使用表达式,“${}内可嵌入任何表达式”,包括等号表达式。
scala> println(s"Age next year: ${age + 1}")
Age next year: 34
scala> println(s"You are 33 years old:${age == 33}")
You are 33 years old:true
注意,在打印对象字段时使用花括号。
scala> case class Student(name: String, score: Int)
defined class Student
scala> val hannah = Student("Hannah", 95)
hannah: Student = Student(Hannah,95)
scala> println(s"${hannah.name} has a score of ${hannah.score}")
Hannah has a score of 95
字符串差值f(printf格式化)
scala> println(f"$name is $age years old, and weighs $weight%.2f pounds.")
GnahzNib is 33 years old, and weighs 140.00 pounds.
scala> printf(f"$name is $age years old, and weighs $weight%.2f pounds.")
GnahzNib is 33 years old, and weighs 140.00 pounds.
其他插入符
scala> s"gnahz\nnib"
res36: String =
gnahz
nib
- 挨个处理字符串中的字符
原始的String调用filter方法,创建一个新的字符串,生成的字符串调用map方法,遍历其每个字符。
scala> val upper = "hello, world".filter(_!='l').map(_.toUpper)
upper: String = HEO, WORD
跟map函数等价的for/yield循环的表示如下:
scala> val upper = for(c <- "hello, world") yield c.toUpper
upper: String = HELLO, WORLD
在for循环添加yield实际上是将每次循环的结果放到了一个临时存放区中,当循环结束时,在临时存放区中的所有元素以一个集合的形式返回。
scala> val result = for{
| c <- "hello, world"
| if c != 'l'
| }yield c.toUpper
result: String = HEO, WORD
总结:
map方法或者是for/yield都是将一个集合转换成为另一个新的集合,foreach则是典型的对每个元素进行操作但不返回结果的方法。
- 字符串中的查找模式
在一个String上调用.r方法可以创建一个Regex对象,之后再查找是否含有一个匹配时就可以用findFirstIn,当需要查找是否完全匹配时可以用findAllIn。
// 匹配一个或多个数字序列
scala> val numPatter = "[0-9]+".r
numPatter: scala.util.matching.Regex = [0-9]+
scala> val address = "123 Main Street Suite 101"
address: String = 123 Main Street Suite 101
scala> val match1 = numPatter.findFirstIn(address)
match1: Option[String] = Some(123)
scala> val match1 = numPatter.findAllIn(address)
match1: scala.util.matching.Regex.MatchIterator = non-empty iterator
scala> match1.foreach(println)
123
101
- 字符串中的替换模式
用正则表达式匹配一段字符串,然后替换它们。因为String是不可变的,不可以在它上面直接查找然后替换,但是可以创建一个新的String,而这个新的String包含了替换后的内容。
在一个String上调用replaceAll,要给结果赋一个新的变量
scala> val address = "123 Main Street".replaceAll("[0-9]", "x")
address: String = xxx Main Street
可以创建一个正则表达式,然后在正则表达式上调用replaceAllIn方法,要给结果赋一个新值。
scala> val regex = "[0-9]".r
regex: scala.util.matching.Regex = [0-9]
scala> val newAddress = regex.replaceAllIn("123 Main Street", "x")
newAddress: String = xxx Main Street
- 抽取String中模式匹配的部分
抽取一个或者多个在字符串中的正则匹配到的部分,定义想要抽取的正则表达式,在它们周围加上括号这样就可以将其当做“正则表达式组”来使用
scala> val pattern = "([0-9]+) ([A-Za-z]+)".r
pattern: scala.util.matching.Regex = ([0-9]+) ([A-Za-z]+)
scala> val pattern(count, fruit) = "100 Bananas"
count: String = 100
fruit: String = Bananas
- 访问字符串中的一个字符
得到字符串中指定位置的一个字符。
scala> "hello".charAt(0)
res43: Char = h
// Scala的Array符号
scala> "hello"(0)
res44: Char = h
- String中添加自定义的方法
定义一个隐式转换的类,然后在这个类中定义一些方法,来实现期望的行为。
scala> implicit class StringImprovements(s: String){
| def increment = s.map(c => (c + 1).toChar)
| }
defined class StringImprovements
scala> val result = "HAL".increment
result: String = IBM