Scala语言的基础知识与简单应用(主要是Scala的判断与循环)

今日内容
    0.值类型隐式转换
    1.强制类型装换
    2.值类型和字符串类型的转换
    3.判断语句
    4.循环语句 
    5.循环跳出语句 
    6.元祖的介绍和使用
    7.数组的介绍和使用
    8.集合的介绍和使用
    
0.隐式转换(高阶隐式转换和隐式函数,这里我们先不讲)
        当scala程序在进行赋值或者运算的时候,精度小的类型
    自动转换为精度大的类型,这个就是自动类型转换(隐式转换)
    //char  -> Int
    var a: Int = 'a'
    //int -> double
    var d: Double=100
    
    细节注意:
        1)有多种类型进行混合运算时,系统首先将所有的类型,转换成精度最大
         的那种数据类型,然后再进行计算
        例子 4.5f+10 ==> float
          val a = 12.12f
          val b=10
          val c=a+b
        2)当我们把精度大的类型赋值给精度小的类型时,就会出现错误,反之就是
         自动类型转换.
        3)(byte,short)和char之间是不会进行类型转换的
           val a: Byte = 10
           val b: Char = a
        4)byte ,short ,char  三者是可以计算,计算的时候首先转换成Int类型
            val a: Byte = 10
            val b: Char = 90
            val c:Short =a+b
            
            val d:Short = 10+90 
            
            val e:Short =100
        
1.强制类型装换
            它是自动转换类型的逆过程,将容量大的数据类型转换成容量小的数据类型,
        使用的时候要加上强制转换函数,但可能造成精度的降低和溢出,使用的时候 
        要格外的注意
        案例:
             //java中的强制类型转换:int a=(int)12312.1231;
             val a:Int=2.345.toInt
             val b:Int=2.345f.toInt
             
        细节注意:
            1)当进行数据的从大-->小的转换的时候,我们需要使用强制转换
            2)强制转换至针对最近的操作数有效,往往需要使用小括弧,提升其优先级
                    val b=10*3.5.toInt+7*1.5.toInt
                    println(b)
                    val c=(10*3.5+7*1.5).toInt
                    println(c)
            3)Byte和Short类型,在运算的时候当做Int类型来处理
            
    2.值类型和字符串类型的转换
        1)基本数据类型转换为String
            //double-->String
            val d = 3.5
            val c = d + ""  //看到灰色的下划线,说明编译类型做了转换
            //boolean --> String
            val a = true + ""
            println(a)
            println(true.getClass.getName)
        2)String类型转换为基本数据类型
            val s1="21"
            val int = s1.toInt
            val float = s1.toFloat
            val double = s1.toDouble
            val byte = s1.toByte
            val long = s1.toLong
            val short = s1.toShort

        细节注意:
            1)在将String转化为基本类型时,确保能够有效的转换
            2)思考"1.25"   转换成Int
             val int1 = "1.25".toInt  //error
             val int2 = "1.25".toDouble.toInt  //ok
             println(int1)
    3.键盘输入语句
        当我们测试,或者是写小项目的时候,需要用到从控制台输入信息
        版本问题:
        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-library</artifactId>
            <version>2.12.2</version>
        </dependency>
        //1.新版本
           val naem=StdIn.readInt()
         //2.老版本
        

2.判断语句
        判断语句 
        1)if 语句的语法格式如下：
            if(布尔表达式)
                {
                   // 如果布尔表达式为 true 则执行该语句块
                }
        例子:
            object Test {
               def main(args: Array[String]) {
                  var x = 10;

                  if( x < 20 ){
                     println("x < 20");
                  }
               }
            }

        2)if...else 语句对应的语法如下:

            if(布尔表达式){
               // 如果布尔表达式为 true 则执行该语句块
            }else{
               // 如果布尔表达式为 false 则执行该语句块
            }
        例子:
            object Test {
               def main(args: Array[String]) {
                  var x = 30;

                  if( x < 20 ){
                     println("x 小于 20");
                  }else{
                     println("x 大于 20");
                  }
               }
            }

        3)if...else if...else 语句
            if...else if...else 语法格式如下：

            if(布尔表达式 1){
               // 如果布尔表达式 1 为 true 则执行该语句块
            }else if(布尔表达式 2){
               // 如果布尔表达式 2 为 true 则执行该语句块
            }else if(布尔表达式 3){
               // 如果布尔表达式 3 为 true 则执行该语句块
            }else {
               // 如果以上条件都为 false 执行该语句块
            }

        例子:
            object Test {
               def main(args: Array[String]) {
                  var x = 30;

                  if( x == 10 ){
                     println("X 的值为 10");
                  }else if( x == 20 ){
                     println("X 的值为 20");
                  }else if( x == 30 ){
                     println("X 的值为 30");
                  }else{
                     println("无法判断 X 的值");
                  }
               }
            }
        4)嵌套判断
            if(){
                if(){
                }
            }
        案例：
            val a = 10
            val b = 15
            if (a > 4) {
              if (b > 10) {
                println("这是嵌套判断-------")
              }
            }
    2.循环语句
            scala的循环语句给我们提供了三类
            1)while 
            2)do   while
            3)for  
            
        1)while    
            1.语法格式如下：
                while(条件)
                    {
                       方法体
                    }
            2.案例    
            // 局部变量
            var a = 10
            // while 循环执行
            while (a>3){
              a-=1
              println(a)
            }
            
            
        2)do   while
            a.语法格式如下：
                do {
                  方法题
                } while( 条件 );
                注意：他是先执行一次方法题
            b.案例
                  // 局部变量
                    var a = 10
                    // while 循环执行
                   do {
                      println("Value of a: " + a)
                      a = a + 1
                    }while (a < 10)
                  }
            
        3)for 
            a.基本语法
             for (循环条件) {
                  方法体
                }
            b.案例
             for (i <- 0 to 10) {
                  println(i)
                }
            c.for 循环保护式，也成条件判断式
                基本案例：//if i!=2  相当于我们的continue,它不是退出，而是跳过
                     for(i<-0 to 3 if i!=2){  //注意这里，没有关键字的时候，一定要有分号
                      println(i)
                    }
                    
            //新的知识点
            d.for 循环返回值
               1.基本语法
                yield :可有把for循环的内容放到一个Vector集合里面,并返回 
                //Vector 是一个容器，可以保存其他数据对象，也称为集合,后续内容会讲到
               2.案例1
                val list=for(i<- 0 to 10) yield i
                println(list)
               3.案例2
               val vec = for (i <- 0 to 10) yield {
                  if (i % 2 == 0) {
                    i
                  } else {
                    "不是偶数"
                  }
                }

                println(vec)

    5.循环跳出语句
    
           循环控制语句(scala 中不支持break  continue)    
           // 创建 Breaks 对象
            val loop = new Breaks

            // 在 breakable 中循环
            loop.breakable {
              // 循环
              while (true) 
                println("这里只循环一次-------")
                loop.break;
              }
            }
                        

    6.元组
        1)概念
            元祖是scala中一个非常有用的容器对象,用于存放不同类型的数据元素,当然他是不可变的
            关键字:不同类型  长度不可变
        2)元组的创建
            val tuple=(1,"abc",false)
            val tuple1 = new Tuple2(1,2)
        3)元组的操作
            元组是通过下划线+下标索引进行访问的,并且是从1开始
             val tuple = (1, 2, 3, 4)
            // println()
            val a = tuple._1 + tuple._2 + tuple._3 + tuple._4
            
            println(s"元祖中所有元祖的和是: $a")
            
    
    7.数组
        1)概念
        数组是一个存放相同类型元素的集合
        分为可变数组和定长数组
        2)数组创建方式
            a.定长数组的创建
                val array = new Array[String](3)
                val arr02 =  Array("a", "b", "c")
            b.变长数组创建
              val arrayBuffer = new ArrayBuffer[String]()
              val arrayBuffer01 = ArrayBuffer()
        2)数组的操作使用
            a.定长数组的赋值和访问   注意:数据的访问时通过下标索引,是从0开始的
                array(0) = "a"
                array(1) = "b"
                array(2) = "c"
                println(array(0))
                println(array(1))
                println(array(2))
                    
            b.变长数据的赋值和访问
                arrayBuffer.append(1)
                arrayBuffer.append(2)
                arrayBuffer.append(3)
                println(arrayBuffer(0))
                println(arrayBuffer(1))
                println(arrayBuffer(2))
                    
            c.定长数组遍历操作    
                 for (item <- array) {
                      println(item)
                    }
            
            d.变长数组遍历操作    
                  for (item<-arrayBuffer){
                      println(item)
                    }
                    
            e.数组的常用函数
                 //元素求和
                println(arrayBuffer.sum)
                //最大值
                println(arrayBuffer.max)
                //最小值
                println(arrayBuffer.min)
                //排序(默认是升序)
                println(arrayBuffer.sorted)
                 //降序
                println(arrayBuffer.sortWith(_>_))
    
        8.集合 
            a.展示一张关系图
                        
            b.集合的分类
                List(列表) :有序 可重复
                Set(集合)  :无序 不可重复
                Map(映射)  :键值对 (key  不可重复)
                tuple(元祖):是不同类型值的集合
                Vector(容器):是一个容器,可以保存不同数据对象
                
            
            1)List(列表) :有序 可重复
                列表类似于元祖,他们所有的元素的类型都是一样
                1.list的定义
                
                //为什么不需要new:不适用new 关键字创建对象 而是通过object   apply :类似于构造器
                
                   //1.字符串列表
                     val strings = List("abc","d","e")
                    //2.整数列表
                    val ints = List(1,2,3,4)
                    //3.二维列表
                    val intses = List(List(1,2,3,4),List(1,2,3,4))
                2.List的操作
                    for循环遍历打印列表中的元素
                    //循环遍历集合
                     for(i<- 0 until strings.length ){
                         println( strings(i))
                        }
                    //
                           for (item <- list) {
                          println(item)
                        }
                    list.head:返回列表第一个元素
                    list.tail:返回一个列表  处理第一元素以外的其他元素
                    list.isEmpty:列表如果为空的时候放回出
                     list.last  :获取最后一个元素
                    //合并两个列表(两种方式)
                     // val strss=strings:::strings01
                     val strss = List.concat(strings, strings01)
                     // 适应.fill创建一个重复次数为n次的列表
                      val site = List.fill(3)("gao") 
                      println( "site : " + site  )
                      println(site(0).getClass.getName)
                3.scala中List 和listBuffer的区别
                    //可变的
                    val buffer = ListBuffer[String]()
                    //向可变的buffer中添加元素,并打印查看
                        buffer.append("a")
                        buffer.append("b")
                        buffer.append("c")
                        println(buffer)
                    //元素移除
                        buffer.remove(1)
            2)Set(集合)  :没有重复的对象集合,所有元素都是唯一
                            特点:无序 ,不重复
                            //1.Set的定义
                                不能变集合定义
                                val set=Set(1,2,3)
                                可变集合的定义
                                 val set = collection.mutable.Set[String]()
                            //2.Set的操作
                                增加元素
                                //1.赋值
                                添加元素
                                set.add("a")
                                set.add("b")
                                set.add("c")
                                set+="d"
                                减少元素
                                set.drop(1)
                                set-="b"
                                //2.打印
                                set.foreach(item => {
                                  println(item)
                                })
                                
                            
            3)Map(映射)  
                    参考一下:https://www.runoob.com/scala/scala-maps.html
                    Map(映射)是一种可迭代的键值对（key/value）结构
                    key不可重复
                    分类:可变的不可变
                            1.Map的定义
                                //不可变
                                var A:Map[Type,Type] = Map()
                                val map = Map("key01" -> "value01", "key02" -> "value02")
                                //可变的 
                                val map = collection.mutable.Map[String,String]()
                                //添加
                                map.put("", "")
                                //去除
                                map.remove("k1")
                                //获取所有的keys
                                println(map.keys)
                                //获取所有的value
                                println(map.values)
                                //判断是否为空
                                println(map.isEmpty)
            4).Vector 是Scala标准包的一部分，我们可以直接使用，不需要导包
            1)创建 Vector
              无需使用new关键字就可以创建 Vector 容器实例。创建实例的同时我们可以放入元素
               //创建Vector对象
               val vec = Vector(1,2,3)
               //Vector通过索引下标访问元素,Vector 的元素索引是从0开始的， 使用 圆括号将索引号括起来可以获得指定元素
               println(vec(0))
               //Vector的遍历
                 for (item <- vec) {
                  println(item)
                }
                //倒转 Vector
                  val vec = Vector(1, 2, 3)
                  println(vec)
                  println(vec.reverse)
                //Vector的排序
                val vec = Vector(1, 2, 3,1,4,7,1,3,9)
                println(vec)
                println(vec.sorted)
                //返回第一元素
                vec.head  
                //返回除了第一个元素的所有元素
                vec.tail  
        
    
    
    
    
    
    
    
    
    
    
    

今日内容
    0.值类型隐式转换
    1.强制类型装换
    2.值类型和字符串类型的转换
    3.判断语句
    4.循环语句 
    5.循环跳出语句 
    6.元祖的介绍和使用
    7.数组的介绍和使用
    8.集合的介绍和使用
    
0.隐式转换(高阶隐式转换和隐式函数,这里我们先不讲)
        当scala程序在进行赋值或者运算的时候,精度小的类型
    自动转换为精度大的类型,这个就是自动类型转换(隐式转换)
    //char  -> Int
    var a: Int = 'a'
    //int -> double
    var d: Double=100
    
    细节注意:
        1)有多种类型进行混合运算时,系统首先将所有的类型,转换成精度最大
         的那种数据类型,然后再进行计算
        例子 4.5f+10 ==> float
          val a = 12.12f
          val b=10
          val c=a+b
        2)当我们把精度大的类型赋值给精度小的类型时,就会出现错误,反之就是
         自动类型转换.
        3)(byte,short)和char之间是不会进行类型转换的
           val a: Byte = 10
           val b: Char = a
        4)byte ,short ,char  三者是可以计算,计算的时候首先转换成Int类型
            val a: Byte = 10
            val b: Char = 90
            val c:Short =a+b
            
            val d:Short = 10+90 
            
            val e:Short =100
        
1.强制类型装换
            它是自动转换类型的逆过程,将容量大的数据类型转换成容量小的数据类型,
        使用的时候要加上强制转换函数,但可能造成精度的降低和溢出,使用的时候 
        要格外的注意
        案例:
             //java中的强制类型转换:int a=(int)12312.1231;
             val a:Int=2.345.toInt
             val b:Int=2.345f.toInt
             
        细节注意:
            1)当进行数据的从大-->小的转换的时候,我们需要使用强制转换
            2)强制转换至针对最近的操作数有效,往往需要使用小括弧,提升其优先级
                    val b=10*3.5.toInt+7*1.5.toInt
                    println(b)
                    val c=(10*3.5+7*1.5).toInt
                    println(c)
            3)Byte和Short类型,在运算的时候当做Int类型来处理
            
    2.值类型和字符串类型的转换
        1)基本数据类型转换为String
            //double-->String
            val d = 3.5
            val c = d + ""  //看到灰色的下划线,说明编译类型做了转换
            //boolean --> String
            val a = true + ""
            println(a)
            println(true.getClass.getName)
        2)String类型转换为基本数据类型
            val s1="21"
            val int = s1.toInt
            val float = s1.toFloat
            val double = s1.toDouble
            val byte = s1.toByte
            val long = s1.toLong
            val short = s1.toShort

        细节注意:
            1)在将String转化为基本类型时,确保能够有效的转换
            2)思考"1.25"   转换成Int
             val int1 = "1.25".toInt  //error
             val int2 = "1.25".toDouble.toInt  //ok
             println(int1)
    3.键盘输入语句
        当我们测试,或者是写小项目的时候,需要用到从控制台输入信息
        版本问题:
        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-library</artifactId>
            <version>2.12.2</version>
        </dependency>
        //1.新版本
           val naem=StdIn.readInt()
         //2.老版本
        

2.判断语句
        判断语句 
        1)if 语句的语法格式如下：
            if(布尔表达式)
                {
                   // 如果布尔表达式为 true 则执行该语句块
                }
        例子:
            object Test {
               def main(args: Array[String]) {
                  var x = 10;

                  if( x < 20 ){
                     println("x < 20");
                  }
               }
            }

        2)if...else 语句对应的语法如下:

            if(布尔表达式){
               // 如果布尔表达式为 true 则执行该语句块
            }else{
               // 如果布尔表达式为 false 则执行该语句块
            }
        例子:
            object Test {
               def main(args: Array[String]) {
                  var x = 30;

                  if( x < 20 ){
                     println("x 小于 20");
                  }else{
                     println("x 大于 20");
                  }
               }
            }

        3)if...else if...else 语句
            if...else if...else 语法格式如下：

            if(布尔表达式 1){
               // 如果布尔表达式 1 为 true 则执行该语句块
            }else if(布尔表达式 2){
               // 如果布尔表达式 2 为 true 则执行该语句块
            }else if(布尔表达式 3){
               // 如果布尔表达式 3 为 true 则执行该语句块
            }else {
               // 如果以上条件都为 false 执行该语句块
            }

        例子:
            object Test {
               def main(args: Array[String]) {
                  var x = 30;

                  if( x == 10 ){
                     println("X 的值为 10");
                  }else if( x == 20 ){
                     println("X 的值为 20");
                  }else if( x == 30 ){
                     println("X 的值为 30");
                  }else{
                     println("无法判断 X 的值");
                  }
               }
            }
        4)嵌套判断
            if(){
                if(){
                }
            }
        案例：
            val a = 10
            val b = 15
            if (a > 4) {
              if (b > 10) {
                println("这是嵌套判断-------")
              }
            }
    2.循环语句
            scala的循环语句给我们提供了三类
            1)while 
            2)do   while
            3)for  
            
        1)while    
            1.语法格式如下：
                while(条件)
                    {
                       方法体
                    }
            2.案例    
            // 局部变量
            var a = 10
            // while 循环执行
            while (a>3){
              a-=1
              println(a)
            }
            
            
        2)do   while
            a.语法格式如下：
                do {
                  方法题
                } while( 条件 );
                注意：他是先执行一次方法题
            b.案例
                  // 局部变量
                    var a = 10
                    // while 循环执行
                   do {
                      println("Value of a: " + a)
                      a = a + 1
                    }while (a < 10)
                  }
            
        3)for 
            a.基本语法
             for (循环条件) {
                  方法体
                }
            b.案例
             for (i <- 0 to 10) {
                  println(i)
                }
            c.for 循环保护式，也成条件判断式
                基本案例：//if i!=2  相当于我们的continue,它不是退出，而是跳过
                     for(i<-0 to 3 if i!=2){  //注意这里，没有关键字的时候，一定要有分号
                      println(i)
                    }
                    
            //新的知识点
            d.for 循环返回值
               1.基本语法
                yield :可有把for循环的内容放到一个Vector集合里面,并返回 
                //Vector 是一个容器，可以保存其他数据对象，也称为集合,后续内容会讲到
               2.案例1
                val list=for(i<- 0 to 10) yield i
                println(list)
               3.案例2
               val vec = for (i <- 0 to 10) yield {
                  if (i % 2 == 0) {
                    i
                  } else {
                    "不是偶数"
                  }
                }

                println(vec)

    5.循环跳出语句
    
           循环控制语句(scala 中不支持break  continue)    
           // 创建 Breaks 对象
            val loop = new Breaks

            // 在 breakable 中循环
            loop.breakable {
              // 循环
              while (true) 
                println("这里只循环一次-------")
                loop.break;
              }
            }
                        

    6.元组
        1)概念
            元祖是scala中一个非常有用的容器对象,用于存放不同类型的数据元素,当然他是不可变的
            关键字:不同类型  长度不可变
        2)元组的创建
            val tuple=(1,"abc",false)
            val tuple1 = new Tuple2(1,2)
        3)元组的操作
            元组是通过下划线+下标索引进行访问的,并且是从1开始
             val tuple = (1, 2, 3, 4)
            // println()
            val a = tuple._1 + tuple._2 + tuple._3 + tuple._4
            
            println(s"元祖中所有元祖的和是: $a")
            
    
    7.数组
        1)概念
        数组是一个存放相同类型元素的集合
        分为可变数组和定长数组
        2)数组创建方式
            a.定长数组的创建
                val array = new Array[String](3)
                val arr02 =  Array("a", "b", "c")
            b.变长数组创建
              val arrayBuffer = new ArrayBuffer[String]()
              val arrayBuffer01 = ArrayBuffer()
        2)数组的操作使用
            a.定长数组的赋值和访问   注意:数据的访问时通过下标索引,是从0开始的
                array(0) = "a"
                array(1) = "b"
                array(2) = "c"
                println(array(0))
                println(array(1))
                println(array(2))
                    
            b.变长数据的赋值和访问
                arrayBuffer.append(1)
                arrayBuffer.append(2)
                arrayBuffer.append(3)
                println(arrayBuffer(0))
                println(arrayBuffer(1))
                println(arrayBuffer(2))
                    
            c.定长数组遍历操作    
                 for (item <- array) {
                      println(item)
                    }
            
            d.变长数组遍历操作    
                  for (item<-arrayBuffer){
                      println(item)
                    }
                    
            e.数组的常用函数
                 //元素求和
                println(arrayBuffer.sum)
                //最大值
                println(arrayBuffer.max)
                //最小值
                println(arrayBuffer.min)
                //排序(默认是升序)
                println(arrayBuffer.sorted)
                 //降序
                println(arrayBuffer.sortWith(_>_))
    
        8.集合 
            a.展示一张关系图
                        
            b.集合的分类
                List(列表) :有序 可重复
                Set(集合)  :无序 不可重复
                Map(映射)  :键值对 (key  不可重复)
                tuple(元祖):是不同类型值的集合
                Vector(容器):是一个容器,可以保存不同数据对象
                
            
            1)List(列表) :有序 可重复
                列表类似于元祖,他们所有的元素的类型都是一样
                1.list的定义
                
                //为什么不需要new:不适用new 关键字创建对象 而是通过object   apply :类似于构造器
                
                   //1.字符串列表
                     val strings = List("abc","d","e")
                    //2.整数列表
                    val ints = List(1,2,3,4)
                    //3.二维列表
                    val intses = List(List(1,2,3,4),List(1,2,3,4))
                2.List的操作
                    for循环遍历打印列表中的元素
                    //循环遍历集合
                     for(i<- 0 until strings.length ){
                         println( strings(i))
                        }
                    //
                           for (item <- list) {
                          println(item)
                        }
                    list.head:返回列表第一个元素
                    list.tail:返回一个列表  处理第一元素以外的其他元素
                    list.isEmpty:列表如果为空的时候放回出
                     list.last  :获取最后一个元素
                    //合并两个列表(两种方式)
                     // val strss=strings:::strings01
                     val strss = List.concat(strings, strings01)
                     // 适应.fill创建一个重复次数为n次的列表
                      val site = List.fill(3)("gao") 
                      println( "site : " + site  )
                      println(site(0).getClass.getName)
                3.scala中List 和listBuffer的区别
                    //可变的
                    val buffer = ListBuffer[String]()
                    //向可变的buffer中添加元素,并打印查看
                        buffer.append("a")
                        buffer.append("b")
                        buffer.append("c")
                        println(buffer)
                    //元素移除
                        buffer.remove(1)
            2)Set(集合)  :没有重复的对象集合,所有元素都是唯一
                            特点:无序 ,不重复
                            //1.Set的定义
                                不能变集合定义
                                val set=Set(1,2,3)
                                可变集合的定义
                                 val set = collection.mutable.Set[String]()
                            //2.Set的操作
                                增加元素
                                //1.赋值
                                添加元素
                                set.add("a")
                                set.add("b")
                                set.add("c")
                                set+="d"
                                减少元素
                                set.drop(1)
                                set-="b"
                                //2.打印
                                set.foreach(item => {
                                  println(item)
                                })
                                
                            
            3)Map(映射)  
                    参考一下:https://www.runoob.com/scala/scala-maps.html
                    Map(映射)是一种可迭代的键值对（key/value）结构
                    key不可重复
                    分类:可变的不可变
                            1.Map的定义
                                //不可变
                                var A:Map[Type,Type] = Map()
                                val map = Map("key01" -> "value01", "key02" -> "value02")
                                //可变的 
                                val map = collection.mutable.Map[String,String]()
                                //添加
                                map.put("", "")
                                //去除
                                map.remove("k1")
                                //获取所有的keys
                                println(map.keys)
                                //获取所有的value
                                println(map.values)
                                //判断是否为空
                                println(map.isEmpty)
            4).Vector 是Scala标准包的一部分，我们可以直接使用，不需要导包
            1)创建 Vector
              无需使用new关键字就可以创建 Vector 容器实例。创建实例的同时我们可以放入元素
               //创建Vector对象
               val vec = Vector(1,2,3)
               //Vector通过索引下标访问元素,Vector 的元素索引是从0开始的， 使用 圆括号将索引号括起来可以获得指定元素
               println(vec(0))
               //Vector的遍历
                 for (item <- vec) {
                  println(item)
                }
                //倒转 Vector
                  val vec = Vector(1, 2, 3)
                  println(vec)
                  println(vec.reverse)
                //Vector的排序
                val vec = Vector(1, 2, 3,1,4,7,1,3,9)
                println(vec)
                println(vec.sorted)
                //返回第一元素
                vec.head  
                //返回除了第一个元素的所有元素
                vec.tail