Scala-集合

目录
    1.可变集合和不可变集合
    2.列表
    3.序列
    4. 集(Set)和集的操作
    5.模式匹配
    6.样本类(CaseClass)

1.可变集合和不可变集合

(1)可变集合:

(2)不可变集合：

• 集合从不改变，因此可以安全地共享其引用。
• 甚至是在一个多线程的应用程序当中也没问题。

//不可变的集合
val math = scala.collection.immutable.Map("Alice"->80,"Bob"->90,"Mary"->85)

//可变的集合
val english = scala.collection.mutable.Map("Alice"->80,"Bob"->90,"Mary"->85)
val chinese = scala.collection.mutable.Map("Alice"->80,"Bob"->90,"Mary"->85)

(3)集合的操作：

a.获取集合中的值

chinese.get("Bob")

chinese.get("Tomdfsdfd")

chinese("Bob")

chinese.getOrElse("Tomsdlkfjlskdjfls",-1)

chinese("Tomdfsdfd")

b.更新集合中的值：注意：必须是一个可变集合

chinese

chinese("Bob")=0

chinese

math

math("Bob")=0

c.添加新元素

chinese += "Tom"->85

d.移除元素

chinese -= "Bob"

2.列表

(1)不可变列表(List)

//不可变列表：List
//字符串列表
val namelist = List("Bob","Mary","Mike")
//整数列表
val intList = List(1,2,3,4,5)
//空列表
val nullList:List[Nothing] = List()
//二维列表
val dim:List[List[Int]] = List(List(1,2,3),List(4,5,6))

不可变列表的相关操作：
a.head：列表中的第一个元素

//输出列表中的值：head,tail,isEmpty
println("第一个人的名字："+namelist.head)

b.tail:不是返回最后一个元素，而是返回除去第一个元素后，剩下的元素列表

println(namelist.tail)

c.isEmpty:判断列表是否为空

println("列表是否为空："+namelist.isEmpty)

(2)可变列表(LinkedList)：scala.collection.mutable.LinkedList

LinkedList和不可变列表List类似，只不过我们可以修改列表中的值

//可变列表：
val myList = scala.collection.mutable.LinkedList(1,2,3,4,5)
//操作：将上面可变列表中的每个值乘以2
//列名 elem
//定义一个指针指向列表的开始
var cur = myList

//Nil:代表Scala中的null
while(cur != Nil){
  cur.elem = cur.elem*2
  //将指针指向下一个元素
  cur = cur.next
}
//查看结果
println(myList)

myList

myList.map(_*2)

移除元素

myList.drop(2)

myList.dropWhile(_%2!=0)

dropWhile 去除当前数组中，符合条件的元素，碰到第一个不满足条件的元素，就结束。

3.序列

常用的序列有：Vector和Range

(1)Vector是ArrayBuffer的不可变版本，是一个带下标的序列

//Vector:为了提高list列表随机存取的效率而引入的新的集合类型
//支持快速的查找和更新
val v= Vector(1,2,3,4,5,6)

//返回的是第一个满足条件的元素
v.find(_>3)
v.updated(2,1000)

(2)Range表示一个整数序列

//Range：有序的通过空格分割的Int序列
//以下几个例子Range是一样

Range(0,5)
println("第一种写法："+Range(0,5))
println("第二种写法："+(0 until 5))
println("第三种写法："+(0 to 4))

//两个range可以相加
('0' to '9')++('A' to 'Z')

//可以将Range转换为List
1 to 5 toList

4. 集(Set)和集的操作

• 集Set是不重复元素的集合
• 和列表不同，集并不保留元素插入的顺序。默认是HashSet

(1)示例1：创建集

//a.**创建一个Set**
var s1 = Set(2,0,1)

//往s1中添加一个重复元素
s1+1

//往s1中添加一个不重复元素
s1+100

//创建一个LinkedHashSet,一定要先import下面这个，否则会保错
import collection.mutable
var weeksday = mutable.LinkedHashSet("星期一","星期二","星期三","星期四")

//创建一个排序的集
var s2 = mutable.SortedSet(1,2,3,10,4)

(2)示例2：集的操作

a.添加

weeksday+"星期五"

b.判断元素是否存在

weeksday contains("星期二")

c.判断一个集是否是另一个集的子集

Set("星期二","星期四","星期日") subsetOf(weeksday)

d.集的运算，union并集，intersect交集，diff差集

var set1=Set(1,2,3,4,5)

var set2=Set(5,6,7,8,9,10)
//并集：集合相加，去掉重复元素
set1 union set2
//intersect交集
set1 intersect set2
//差集
set1 diff set2

5.模式匹配

(1)Scala有一个强大的模式匹配机制，可以应用在很多场合：

• switch语句
• 类型检查

(2)Scala还提供了样本类(case class)，对模式匹配进行了优化

(3)模式匹配示例：

• 更好的switch

//更好的switch
var sign =0

var ch1 = '-'

ch1 match{
  case '+' => sign = 1
  case '-' =>sign = -1
  case _ =>sign = 0
}
println(sign)

(4)Scala的守卫:匹配某种类型的所有值

//scala的守卫：匹配某种类型的所有值
var ch2='6'
var digit:Int = -1
ch2 match{
  case '+' => println("这是一个+")
  case '-' => println("这是一个-")
  case _ if Character.isDigit(ch2) => digit = Character.digit(ch2,10)
 case _ => println("其他类型")
}

println("Digit:"+digit)

(5)模式匹配中的变量

//模式匹配的变量
var str3 = "Hello World"

str3(7) match{
  case '+' => println("这是一个+")
  case '-' => println("这是一个+")
  case ch => println("这是字符："+ch)
}

(6)类型模式

//类型模式
var v4:Any =100
v4 match{
  case x:Int => println("这是一个整数："+x)
  case s:String => println("这是一个字符串："+s)
  case _ => println("这是其他类型")
}

(7)匹配数组和列表

//匹配数组和列表
var myArray = Array(1,2,3)
myArray match{
  case Array(0) => println("0")
  case Array(x,y) =>println("这是数组包含的两个元素，和是："+(x+y))
  case Array(x,y,z) => println("这是数组包含的三个元素，乘积是："+(x*y*z))
  case Array(x,_*) => println("这是一个数组")
}

var myList = List(1,2,3)
myList match{
  case List(0) => println("0")
  case List(x,y) =>println("这是列表包含的两个元素，和是："+(x+y))
  case List(x,y,z) =>println("这是列表包含的三个元素，乘积是："+(x*y*z))
  case List(x,_*) => println("这个列表包含多个元素")
}

6.样本类(CaseClass)

    简单的来说，Scala的case class就是在普通的类定义前加case这个关键字，然后你可以对这些类来模式匹配。

case class带来的最大的好处是它们支持模式识别。

    首先，回顾一下前面的模式匹配：

    其次，如果我们想判断一个对象是否是某个类的对象，跟Java一样可以使用isInstanceOf

下面这个好像有点问题

最后，在Scala中有一种更简单的方式来判断，就是case class

注意：需要在class前面使用case关键字