Scala实践4

一、数组

在Scala中，用()来访问元素，数组声明的语法格式如下：

var z:Array[String] = new Array[String](3)
或
var z = new Array[String](3)

类型参数化数组

Scala里用new实例化对象，实例过程中，可以用值和类型使对象参数化（在创建实例的同时完成对它的“设置”）。

scala> val greetString =new Array[String](3)
greetString: Array[String] = Array(null, null, null)

scala> greetString(0)="Hello"
scala> greetString(1)=","
scala> greetString(2)="world!"
scala> for(i<-0 to 2) print(greetString(i))
Hello,world!
scala>

　　注：由上可知数组greetString(0)是数组的首个元素，且i<-0 to 2即为(0).to(2)

数组缓存

ArrayBuffer与数组类似，保留了所有的Array操作，还允许在序列的开始或结束的地方添加和删除元素。

//先从可变集合包中引用
scala> import scala.collection.mutable.ArrayBufferimport scala.collection.mutable.ArrayBuffer

//必须指定ArrayBuffer参数类型，可以不指定长度，可自动调整分配空间
scala> val buf=new ArrayBuffer[Int]()
buf: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()

//使用+=添加元素
scala> buf +=12
res19: buf.type = ArrayBuffer(12)
scala> buf +=15
res20: buf.type = ArrayBuffer(12, 15)
scala> buf
res21: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(12, 15)

//缓存可用数组能用的方法
scala> buf.length
res22: Int = 2
scala> buf(0)
res23: Int = 12

二、列表list

列表是同质的，列表中的所有元素都具有相同的类型。元素类型为T的列表类型写作List[T]

Scala的列表类（List）创建方法如下：

scala> val oneTwoThree=List(1,2,3)//创建并初始化
oneTwoThree: List[Int] = List(1, 2, 3)

列表类中定义了“:::”方法实现叠加，用法如下：

scala> val oneTwoThree=List(1,2,3)
oneTwoThree: List[Int] = List(1, 2, 3)
scala> val four=List(4)
four: List[Int] = List(4)

scala> val ottf=oneTwoThree:::four
ottf: List[Int] = List(1, 2, 3, 4)

列表类中最常用的操作符是“::”，它可以把新元素组合到现有列表的最前端，然后返回作为执行结果的新列表。

scala> val oneTwoThree=List(1,2,3)
oneTwoThree: List[Int] = List(1, 2, 3)

scala> val oneTwoThreefour=4::oneTwoThree
oneTwoThreefour: List[Int] = List(4, 1, 2, 3)

Nil是空列表的简写，::是定义在List类上的方法1，2，3是Int类型，

scala> val oneTwoThreefour=1::2::3::4
<console>:11: error: value :: is not a member of Int
       val oneTwoThreefour=1::2::3::4
                                  ^

scala> val oneTwoThreefour=1::2::3::4::Nil
oneTwoThreefour: List[Int] = List(1, 2, 3, 4)

scala>

Scala里的列表类型是协变的。这意味着对于每一对类型，S是T的子类型，那么List[S]是List[T] 的子类型。
```
//List()同样是List[String]的
val xs:List[Sreing]=List()　
```
构造列表，所有的列表都是由两个基础的构造块Nil和::构造出来的。
列表的基本操作：head(返回列表的第一个元素)、tail(返回列表的第一个之外的所有元素)、isEmpty（判断是否为空，返回true）

scala> Nil.head//head和tail都仅能作用在非空列表上，否则抛出异常
java.util.NoSuchElementException: head of empty list
  at scala.collection.immutable.Nil$.head(List.scala:430)
  ... 28 elided

连接列表，连接操作是“:::”，它的两个操作元都是列表，且是右结合

scala> List(1,2):::(List(3,4,5):::List(9,8,7))
res12: List[Int] = List(1, 2, 3, 4, 5, 9, 8, 7)
scala> List(1,2):::List(3,4,5):::List(9,8,7)
res13: List[Int] = List(1, 2, 3, 4, 5, 9, 8, 7)

列表缓存

//先从可变集合包中引用
scala> import scala.collection.mutable.ListBuffer
import scala.collection.mutable.ListBuffer
//实例化
scala> val buf=new ListBuffer[Int]
buf: scala.collection.mutable.ListBuffer[Int] = ListBuffer()
//+=添加元素
scala> buf +=11
res24: buf.type = ListBuffer(11)
scala> buf +=12
res25: buf.type = ListBuffer(11, 12)
scala> buf
res26: scala.collection.mutable.ListBuffer[Int] = ListBuffer(11, 12)
scala> 3+:buf
res27: scala.collection.mutable.ListBuffer[Int] = ListBuffer(3, 11, 12)

scala> buf.toList
res28: List[Int] = List(11, 12)
scala> buf
res29: scala.collection.mutable.ListBuffer[Int] = ListBuffer(11, 12)

scala> 3 +: buf
res30: scala.collection.mutable.ListBuffer[Int] = ListBuffer(3, 11, 12)
scala> buf
res31: scala.collection.mutable.ListBuffer[Int] = ListBuffer(11, 12)
//出现问题，toList没有显示出3
scala> buf.toList
res32: List[Int] = List(11, 12)

　　出现问题，toList没有显示出3

三、元组

元组可以包含不同类型的元素，但是和列表一样不可变，把元组实例化需要的对象放在括号里，元组实例化后可以用点号、下划线和基于1的索引访问其他元素，如下：

scala> val pair=(99,"Luft")
pair: (Int, String) = (99,Luft)
scala> println(pair._1)
99
scala> println(pair._2)
Luft

　注：元组的实际类型取决于它含有的元素数量和这些元素的类型。故(11,25,s,ss)的类型是
Tupa: (Int, Int, Char, String)

四、集set和映射map

对于set和map来说，Scala同样有可变和不可变的，不过不是阁提供两种选择，而是通过类继承的差别把可变性差异蕴含其中。其中Scala的API包含了set的基本特质，Scala还提供了两个子特质，分别为可变和不可变set。（Java是实现接口，Scala是“扩展”/“混入”了特质。）其中，在Scala中，set和map的层级如下：

创建初始化和使用不可变集

scala> var jetSet =Set("Beoing","Airbus")
jetSet: scala.collection.immutable.Set[String] = Set(Beoing, Airbus)

scala> jetSet +="Lear"

scala> println(jetSet.contains("Cessna"))
false

scala> jetSet
res41: scala.collection.immutable.Set[String] = Set(Beoing, Airbus, Lear)

创建初始化和使用可变集

//没有引入包
scala> val movieSet = Set("Hitch","Poltergeist")
movieSet: scala.collection.immutable.Set[String] = Set(Hitch, Poltergeist)

scala> movieSet += "Shrek"
<console>:13: error: value += is not a member of scala.collection.immutable.Set[String]
  Expression does not convert to assignment because receiver is not assignable.
       movieSet += "Shrek"
//和上面的不可变集的前两步相同，
//主要是分别用val和var的区别

//引入包
scala> import scala.collection.mutable.Set
import scala.collection.mutable.Set

scala> val movieSet = Set("Hitch","Poltergeist")
movieSet: scala.collection.mutable.Set[String] = Set(Poltergeist, Hitch)

scala> movieSet += "Shrek"
res48: movieSet.type = Set(Poltergeist, Shrek, Hitch)

scala> println(movieSet)
Set(Poltergeist, Shrek, Hitch)

不可变的map是默认的，不用引用其他类，创建、初始化和使用不可变映射

scala> val romanNumral = Map(
     | 1->"I",2->"II",3->"III",4->"IV",5->"V"
     | )
romanNumral: scala.collection.immutable.Map[Int,String] = Map(5 -> V, 1 -> I, 2 -> II, 3 -> III, 4 -> IV)

scala> println(romanNumral(4))
IV

创建、初始化和使用可变映射

scala> import scala.collection.mutable.Map
import scala.collection.mutable.Map

scala> val treasureMap=Map[Int,String]()
treasureMap: scala.collection.mutable.Map[Int,String] = Map()
scala> treasureMap+=(1->"Good")
res44: treasureMap.type = Map(1 -> Good)
scala> treasureMap+=(2->"kid")
res45: treasureMap.type = Map(2 -> kid, 1 -> Good)
scala> treasureMap+=(3->"!")
res46: treasureMap.type = Map(2 -> kid, 1 -> Good, 3 -> !)
scala> println(treasureMap(2))
kid

　　没有导入包的测试如下：

scala> val treasureMap=Map[Int,String]()
treasureMap: scala.collection.immutable.Map[Int,String] = Map()

scala>  treasureMap+=(1->"Good")
<console>:13: error: value += is not a member of scala.collection.immutable.Map[Int,String]
  Expression does not convert to assignment because receiver is not assignable.
        treasureMap+=(1->"Good")

　　注：var和val的声明，和mutable和immuatble之间的联系