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))
        //遍历元素
        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)
}