本文意在精简，掌握最常用的，最基本的用法，不断完善，一招鲜而吃遍天
字符串
在 Scala 中，字符串的类型实际上是 Java String，它本身没有 String 类，定义一个string类，其类型就是 String (java.lang.String)。
在 Scala 中，String 是一个不可变的对象，所以该对象不可被修改。这就意味着你如果修改字符串就会产生一个新的字符串对象。
由于scala中的String类和Java中的是同一个，所以其自带方法是相同的。常用方法如下所示：
常用string自带方法
| 返回值 | 方法 | 注释 |
|---|---|---|
| String | concat(String str) | 将指定字符串连接到此字符串的结尾 |
| boolean | contentEquals(StringBuffer sb) | 将此字符串与指定的 StringBuffer 比较。 |
| boolean | endsWith(String suffix) | 测试此字符串是否以指定的后缀结束 ，同理还有startsWith |
| boolean | equals(Object anObject) | 将此字符串与指定的对象比较 |
| boolean | equalsIgnoreCase(String anotherString) | 将此 String 与另一个 String 比较，不考虑大小写 |
| int | indexOf(String str, int fromIndex) | 返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始，后一个参数可为空 |
| int | length() | 返回此字符串的长度 |
| boolean | matches(String regex) | 告知此字符串是否匹配给定的正则表达式 |
| String | replace(char oldChar, char newChar) | 返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的 |
| String | replaceAll(String regex, String replacement) | 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串 |
| String[] | split(String regex) | 根据给定正则表达式的匹配拆分此字符串 |
| String | substring(int beginIndex, int endIndex) | 返回一个新的字符串，它是此字符串的一个子字符串，后一个参数可为空 |
| String | toLowerCase() | 使用默认语言环境的规则将此 String 中的所有字符都转换为小写 |
| String | toUpperCase() | 使用默认语言环境的规则将此 String 中的所有字符都转换为大写 |
| String | toUpperCase(Locale locale) | 使用给定 Locale 的规则将此 String 中的所有字符都转换为大写 |
| String | trim() | 删除指定字符串的首尾空白符 |
| string | String.valueOf(x) | 返回指定类型参数的字符串表示形式 |
| ... | ... | 其他方法在此不一一列举 |
StringBuilder
集合
scala的集合设计，整体上分为三大类,所有的集合都扩展自Iterable特质：
- Seq，序列。是一组有序的元素。 诸如Array，List
- Set，集。 是一组无序的，没有重复元素的集合。 诸如：
- Map，映射。是一组k-v对。key不可重复 诸如：
在Scala中集合有可变（mutable）和不可变（immutable）两种类型，immutable类型的集合初始化后就不能改变了（注意与val修饰的变量进行区别）
Array
Scala 语言中提供的数组是用来存储固定大小的同类型元素,数组中某个指定的元素是通过索引来访问的，元素索引从0开始。
创建数组
// 创建数组有两种方式：
// 1. 直接new Array[Int](3) 此种是定长数组，括号内必须填长度
val array1 = new Array[Int](2)
array1(0) = 1
array1(1) = 1
array1(2) = 1 //此行会报错，因为创建的是定长的数组，只有两个元素
// 2. 创建Int类型的数组，直接赋值
val array2=Array[Int](1,2,3)
如要看到数组里的全部内容，除了遍历外，还可以使用toBuffer
其实也可不加泛型
数组的遍历
// 遍历的两种方式
//直接for循环
for(i <- array2){
println(i)
}
// foreach
array2.foreach(i => {
println(i)
})
多维数组的定义和遍历
val array3 = new Array[Array[String]](2)
array3(0)=Array("1","2")
array3(1)=Array("4","5")
for(i <- 0 until array3.length){
for(j <- 0 until array3(i).length){
print(array3(i)(j)+" ")
}
println()
}
array3.foreach(i =>{
println(i.toBuffer)
i.foreach(j => {
println(j)
})
})
数组的常用方法
数组结合yield 或者 map,filter等使用(map filter等的用法，详见函数与方法一章)
数组求求和，最大最小值，排序
拉链操作
注意：拉链操作是将两个序列组合到一起，若两者长度不同，则生成的长度为较短的那个序列的长度
序列
Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质
在Scala中集合有可变（mutable）和不可变（immutable）两种类型，immutable类型的集合初始化后就不能改变了（注意与val修饰的变量进行区别）
不可变序列
不可变的序列 import scala.collection.immutable._
在Scala中列表要么为空（Nil表示空列表）要么是一个head元素加上一个tail列表。
List可添加元素，但添加元素后返回的其实是一个新的list
可变序列
可变的序列 import scala.collection.mutable._
ListBuffer可添加元素，但返回的其实还是原来那个listBuffer
类似于String和StringBuilder
list的创建
// 创建不可变序列
val list1 = List(1,2,3,4,5)
list的遍历
// for
val list = List(1,2,3,4,5)
for(x <- list){
print(x)
}
// foreach
list.foreach { x => println(x)}
可变序列的创建及元素增减
如下也可
//构建一个可变列表，初始有3个元素1,2,3
val list = ListBuffer[Int](1,2,3)
/创建一个空的可变列表
val lst1 = new ListBuffer[Int]
//向lst1中追加元素，注意：没有生成新的集合
lst1 += 4
lst1.append(5)
//将lst1中的元素最近到lst0中， 注意：没有生成新的集合
lst0 ++= lst1
//将lst0和lst1合并成一个新的ListBuffer 注意：生成了一个集合
val lst2= lst0 ++ lst1
//将元素追加到lst0的后面生成一个新的集合
val lst3 = lst0 :+ 5
list的常用方法
注意：list是可以添加元素的，但其实list是一个不可变序列，其添加后返回的是一个新的集合
# :: 操作符是将给定的头和尾创建一个新的列表,:: 操作符是右结合的，如9 :: 5 :: 2 :: Nil相当于 9 :: (5 :: (2 :: Nil))
//将0插入到lst1的前面生成一个新的List
val list2 = 0 :: list1
val list3 = list1.::(0)
val list4 = 0 +: list1
val list5 = list1.+:(0)
//将一个元素添加到lst1的后面产生一个新的集合
val list6 = list1 :+ 3
val list0 = List(4,5,6)
//将2个list合并成一个新的List
val list7 = list1 ++ list0
//将lst1插入到lst0前面生成一个新的集合
val list8 = list1 ++: list0
//将lst0插入到lst1前面生成一个新的集合
val list9 = list1.:::(list0)
// count,map,filter函数
//filter
val list1 = list.filter { x => x>3 }
list1.foreach { println}
//count
val value = list1.count { x => x>3 }
println(value)
//map
val nameList = List(
"hello beijing",
"hello shanghai",
"hello shenzhen"
)
val mapResult:List[Array[String]] = nameList.map{ x => x.split(" ") }
mapResult.foreach{println}
//flatmap
val flatMapResult : List[String] = nameList.flatMap{ x => x.split(" ") }
flatMapResult.foreach { println }
Set
同样的，对于set，同样分为可变Set和不可变Set，set会自动去重
set的创建和遍历
// 不可变set
import scala.collection.immutable.HashSet
val set1 = new HashSet[Int]()
//将元素和set1合并生成一个新的set，原有set不变
val set2 = set1 + 4
//set中元素不能重复
val set3 = set1 ++ Set(5, 6, 7)
val set0 = Set(1,3,4) ++ set1
println(set0.getClass)
// 可变set
import scala.collection.mutable
//创建一个可变的HashSet
val set1 = new mutable.HashSet[Int]()
//向HashSet中添加元素
set1 += 2
//add等价于+=
set1.add(4)
set1 ++= Set(1,3,5)
println(set1)
//删除一个元素
set1 -= 5
set1.remove(2)
println(set1)
set的遍历
val set1 = Set(1,2,3,4,4) //set会自动去重
val set2 = Set(1,2,5)
// set 的遍历
//foreach方式
set1.foreach { println}
//for循环的方式
for(s <- set1){
println(s)
}
set的常用方法
最大最小count，交并差集，转化为list转化为string
//set的交并差集，对于非Set集合，在做交集、并集、差集时必须转换为Set，否则元素不去重没有意义，对于非Set类型集合元素去重，可用distinct
//交集
val set3 = set1.intersect(set2)
val set4 = set1.&(set2)
//并集
Set(1,2,3) ++ Set(2,4)
Set(1,2,3) | Set(2,4) // |方法等同于union方法
Set(1,2,3) union Set(2,4)
//差集
set1.diff(set2).foreach { println }
set1.&~(set2).foreach { println }
//子集
set1.subsetOf(set2)
Map
map是key-value的结构，其key不可重复，如key重复的话，前面对应的value会被后面的替换掉（还是挺实用的）
map的创建
Map(1 -> "hello")
Map(2,"world")
//如下可以看到，map的初始化还是挺灵活的
val map = Map(
"1" -> "hello",
2 -> "world",
(3,"scala")
)
map的遍历和取值
map.get(“1”) 返回some（hello）,是否有值
map.get(“1”).get返回hello，具体值
map.get(4).getOrElse(“no value”)：如果map中没有对应项，赋值为getOrElse传的值。
遍历仍是for 和foreach两种方式
//map遍历
for(x <- map){
println("key:"+x._1+", value:"+x._2)
}
map.foreach(f => {
println("key:"+ f._1+", value:"+f._2)
})
//遍历key和value
//遍历key
val keyIterable = map.keys
keyIterable.foreach { key => {
println("key:"+key+", value:"+map.get(key).get)
} }
//遍历values
val valueIterable = map.values
valueIterable.foreach { value => {
println("value: "+ value)
} }
map的常用方法
// map的合并，合并后相同key的value会被覆盖掉
map1.++(map2) // map1中加入map2
map1.++:(map2) // map2中加入map1
//map的filter过滤
map.filter(_._2.equals("shsxt")).foreach(println)
//map的count方法
val count1 = map.count(p => {
p._2.equals("scala") //第二个元素是否是scala,返回个数【map的value是可重复】
})
//map是否包含某个key
map.contains(2)
//判断map中符合条件的记录是否存在
println(map.exists(x =>{
x._2.equals("scala")
}))
元组 tuple
scala tuple与列表类似，也是不可变的，但与列表不同的是元组可以包含不同类型的元素。
元组的值是通过将单个的值包含在圆括号中构成的，目前 Scala 支持的元组最大长度为 22。对于更大长度你可以使用集合，或者扩展元组。
tuple也是不可变的，有句话形容tuple很合适，那就是 身有残疾的只读列表 。
tuple的创建
val tuple = new Tuple（1）
val tuple2 = Tuple2(1,2)
val tuple3 = Tuple3(1,2,3)
// 最大支持到tuple22
tuple的遍历和取值
// tuple.productIterator得到迭代器，进而遍历
val tupleIterator = tuple10.productIterator
while(tupleIterator.hasNext){
println(tupleIterator.next())
}
//tuple的取值，使用._XX来获取值
val tuple2tuple2 = Tuple2((1,2),("hello","scala"))
println(tuple2tuple2._1._2)
tuple的常用方法
// swap元素翻转，只针对tuple2
tuple2.swap
//toString 终于有个支持tostring的了
println(tuple3.toString())