Scala学习之初探"数组、列表、元组、集、映射"

本章内容主要以代码展示，呈现一个使用初态,主要内容：
1、概念介绍
2、代码实例

概念介绍

数组(Array)：

val geetStrings = new Array[String] (3)

声明了一个字符串数组类型，大小为3。

val  geetStrings2 = Array("10"，"13"，"30")

这在声明的同时直接赋值。完整的声明方式其实是这样的：

val geetStrings ： Array[String] = new Array[String] (3)

，但是Scala的简洁性要求了我们不要采用这种完整式声明。数组元素的调用也是通过索引，不过调用写法略有区别，

geetStrings(1)

而不是

geetStrings[1]

。

geetStrings(1)

在Scala内部会转化成

geetStrings.apply(1)

这实质上是调用某个元素的apply方法。与之类似的更新，其实也是

geetStrings(1) = "55"

到

geetStrings.update(1,"55")

的一个转换。

Scala数组是可变的同类对象序列，例如Array[String]里的所有元素都是String类型的。我们要清楚的是，数组在实例化后长度固定，但是它的元素值是可变的。所以说数组是可变的。

列表(List)：List不同于数组，List是不可变的同类对象序列，和数组一样，

List[String]

仅包含

String

。

但Scala的List和Java中的不同，它一旦创建了就不可改变了。

实际上，Scala的列表设计是为了实现函数编程风格而设计的。所以列表中有诸如”：：”(把新元素结合到现有集合的最前端)和”：：：”(集合叠加)的方法，将集合拼接重新赋值给新的集合并返回。

很明显看到，图中的编译失败：



元组(Tuple)：与列表相同，元组也是不可变的，不同点是，元组可以容纳不同类型的元素。

val pair = ("name"，34，54.9)

。元组实例化后，可以用点号，下划线，索引访问其中的成员，

pair._(2) = 34

。注意元组索引是从1开始的，这是因为对拥有静态类型元组的其他语言的传统保留，不必纠结。

集(set)和映射(map)：对于set和map来说，Scala拥有可变的和不可变的类型。

var jetSet = Set("Boss","Diss")

中调用了apply方法，返回了默认的不可变的Set实例(

scala.collection.immutable.Set

)。Scala编译器推导其类型为不可变。引入可变set，需要导入

scala.collection.mutable.Set

。

package two
/**
* @author wangzha
*
*/
object SecondScala {
def main(args: Array[String]) {
println("go go go")
//定义变量，注意var是可变的，val是不可变的
var msg = "hello,world"
println(msg)
//调用函数
println(max(2, 5))
println(max2(5, 8))

var i = 0
var str = "123"
//常规遍历str----while循环
while (i < str.length) {
print(str(i) + ",")
i += 1
if (!(i < str.length)) {
println("")
}
}
//函数式编程风格遍历str----3种方式
str.foreach((str: Char) => println(str))
str.foreach(str => println(str))
str.foreach(println)
for (str <- str) print("AAA" + str)

/** ********数组 *********/
var array = new Array[String](3);
array(0) = "zero"
array(1) = "one"
array(2) = "two"
for (i <- 0 to 2)
println(array(i))
//该种方式循规蹈矩，并不推荐
val array2: Array[String] = new Array[String](3)
for (i <- (0).to(2))
println(array2.apply(i))
array2.update(2, "look")
//简洁方式，函数式风格，注意：array2.apply(i)和array2(i)是等价的，后者是一种简写
var array3 = Array("zero", "one", "two")
for (i <- 0 to 2) println(array3(i))

/** ********List **********/
val oneTwo = List(1, 2)
val threeFour = List(3, 4)
//将oneTwo和threeFour两个集合，合并成一个新的集合赋值给oneTwoThreeFour
val oneTwoThreeFour = oneTwo ::: threeFour
println("oneTwo:" + oneTwo)
println("threeFour:" + threeFour)
println("oneTwoThreeFour:" + oneTwoThreeFour)
println("newOneTwo:" + (1 :: oneTwo))
println("newOneTwo:" + (oneTwo.::(1)))
//将1、2、3、null  4个元素合并成一个新的集合赋值给newOneTwoThree
val newOneTwoThree = 1 :: 2 :: 3 :: Nil
println("newOneTwoThree:" + newOneTwoThree)
/** Example **/
println(List())
println(List("A", "B") ::: List("C", "D"))
var thrill = "Will" :: "fill" :: "until" :: Nil
//计算长度为4的字符串的个数
println(thrill.count(s => s.length == 4))
println("thrill:" + thrill)
//索引为2的元素
println(thrill(2))
//去掉前2个后的集合
println("thrill1:" + thrill.drop(2))
//去掉后2个后的集合
println("thrill2" + thrill.dropRight(2))
//是否存在元素和until一样
println(thrill.exists(s => s == "until"))
//长度为4的元素组成新的List，且返回
println(thrill.filter(s => s.length == 4))
//遍历元素

b5b0
thrill.foreach(s => println(s))
thrill.foreach(print)
//返回头元素
println(thrill.head)
//返回除了最后一个以外的元素组成新列表
println(thrill.init)
//判断是否为空
println(thrill.isEmpty)
//返回每个String元素都加了"y"构造的列表
println(thrill.map(s => s + "y"))
//返回列表元素组成的字符串
println(thrill.mkString("+"))
//返回列表元素逆序组成的新列表
println(thrill.reverse)
//返回列表元素按照第一个字符字母小写排序之后依次组成的新列表
println(thrill.sortWith((s, t) => s.charAt(0).toLower < t.charAt(0).toLong))
//返回除了第一个之外的元素组成的新列表
println(thrill.tail)

/** *********元组(Tuple) ***********/
val pair = (99, "Luftballons")
println(pair._1)
println(pair._2)
val pairTwo = new Tuple6[Char, Char, String, Int, Int, String]('a', 'a', "wangzha", 1, 4, "hongdousu")
val newPairTwo = ('a', 'a', "wangzha", 1, 4, "hongdousu")

/** **********set和map ************/
//可变的集合和不可变的集合的区别
var jetSet = Set("Boeing", "Airbus")
jetSet += "Lear"
println("jetSet:" + jetSet)
println(jetSet.contains("Cessna"))
val movieSet = scala.collection.mutable.Set("one", "two")
movieSet += "Shrek"
println("movieSet:" + movieSet)
val hashSet = HashSet("Tomatoes", "Chillies")
println(hashSet + "Coriander")
var hashSet2 = scala.collection.mutable.HashSet("three", "five")
println(hashSet2 + "gogogo")

var treasureMap = Map[Int, String]()
treasureMap += (1 -> "Go to island.")
treasureMap += (2 -> "Find big x on ground.")
treasureMap += (3 -> "Big.")
println(treasureMap(2))

val romanNumeral = Map(1 -> "one", 2 -> "two", 3 -> "three", 4 -> "four", 5 -> "five")
println(romanNumeral(4))
formatArgs(array3)
}