Scala：(三) 字符串、集合(Array、List、Set、Map)、元组（tuple）

本文意在精简，掌握最常用的，最基本的用法，不断完善，一招鲜而吃遍天

字符串

在 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特质：

1. Seq，序列。是一组有序的元素。 诸如Array，List
2. Set，集。 是一组无序的，没有重复元素的集合。 诸如：
3. 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())