scala初学之Tuple、Array、Map、文件操作入门实战

特此声明，本文中的代码 部分或全部来源王家林的scala教程；虽然王家林一直被大家所诟病，而且也无法确定这些scala的程序代码是不是他的。但是作为一个初学者觉得就算代码不是他的，他只是拿过来翻译一次，看他的视频也是能了解一些东西的；但是很多东西讲的确实欠缺；所以在学习的过程中把自己的很多思考注释到了他的代码中。一是当作自己的备忘，二也希望能够给大家带来一些些的帮助。

 

 

/**
 * @author user
 *tuple 这个东西我最初接触实在storm中，在storm中消息都被封装在tuple中,
 * 后来发现在python中也有tuple
 * 可见tuple已经被广泛的作为一种数据结构被使用了
 * 其实tuple的实质很简单，就是一组数据的组合，累死于object数组 
 * 
 */
object TupleOps {
  
  
   def main(args:Array[String]):Unit={
     /*定义一个triple的tuple变量 在sacla中定义一个tuple只需要用()把你要放的一堆数据放进去，然后用逗号分割就可以了
      * 在这里，定义了一个有三个元素的tuple，第一个是100（整数），第二个是SCALA（字符串），第三个是0.2（Double）
      * 在开始说tuple和Object数组类似，但是在scala中，你把鼠标放在triple变量上的时候会显示：
      * val triple : (Int,String,Double) 而不是 val triple : (Object,Object,Object)
      * 说明scala已经通过类型推导确定了triple中三个值的类型；这也就让我们在使用tuple的时候，每一个值都能有了明确的类型，不用去类型转换了。
      * */
     val triple = (100,"SCALA",0.2)
     /*分别输出triple中的第一个，第二个，第三个值*/
     println(triple._1)
     println(triple._2)
     println(triple._3)
     
     /*延伸一下下
      * 我们可以定义一个匿名的tuple 就像下面那样 val(a,v,_)=triple
      * 这样，我们不知这个tuple的具体名字，却知道tuple中的值的名字,所以可以直接使用a和v
      * 在下面就在println中使用了a和v来打印匿名tuple中的第一个和第二个值
      * 最后一个是_，这个_表示我不关心这个值的名称，可以有任意多个；（只要你不想关心的tuple中的某个值，就给他取名字叫_）
      * 这样在下面的方法中就无法使用了。 _的出现的最主要的原因是你接收值的tuple的值的个数必须和给这个tuple返回的赋值
      * tuple的值的个数相同。 就如同下面，返回了三个值，我不关心第三个，但是又必须在()里面有三个值的名称，可是我只用
      * 两个，第三个起个名字还要费脑子啊--所以_就是最佳的选择了。
      * */
     val (a,v,_) =triple
     println(a)
     println(v)
   }
}

 

 

 

 

 

 

/**
   * 
   * 在scala中失去了String x [] = new String[10];这样定义数组的机会
   * 所有的数组都封装成了Array对象来使用
   * 
   * */
  def main(args:Array[String]):Unit={
    
    /*定义一个Array,初始序列位1,2,3,4,5 
     * 这里直接写 val array = Array(1,2,3,4,5)
     * 其实用到了Array类的伴生对象
     * 具体来说，就是我们定义了一个class Array //（1） 然后定义一个 object Array //（2）
     * 那么（2）就是（1）的伴生对象
     * 在伴生对象中可以定义一个apply(.....这里的参数由自己定义)方法
     * 这个apply一般就是在伴生对象中区初始化一个类的对象
     * 也就是在（2）中通过apply来初始化一个（1）的具体对象
     * 所以可以有 val array = Array.apply(1,2,3,4,5)
     * 然后scala做了优化，就变成了Array(1,2,3,4,5)就是调用apply方法 
     * */
    /*鼠标放到array上面，可以看到array的类型   val array:Array[Int]*/
    val array = Array(1,2,3,4,5)
    /*由上面可以知道，我们这样写也是正确的 在这里我们指明了 array_1是一个数组 并且数组内的元素都是Int*/
    val array_1:Array[Int] = Array(6,7,8,9,10)
        
    /*所以  下面这样是错的 因为根本就不是array*/
    //val  array_2:Array =2
    /*下面这样也是错的 因为数组元素不对应*/
    //val array_3:Array[Int]=Array("1","2")
    
    /*要获得数组中的某个元素，直接使用 .apply(index) 方法*/
    println(array_1.apply(2))
    /*apply方法可以简写为 */
    println(array_1(2))
    /*在scala中,的Array是不变量  也就是所一旦被创建，那么大小，内容就都不会改变了
     * 所以我们无法改变Array的长度以及内容
     * */
     /*但是在scala中还是提供了 .+: 这样的方法，这个方法允许我们把当前array的数组元素的超类和当前array的全部元素
      * 合并为一个新的array并返回*/
    val array_x=array.+:(10) //生成了一个新的数组，以前的array还是那个array没有任何改变；array_x的内容位 10,1,2,3,4,5
      /*同时可以直接和一个数组合并，生成一个新的数组*/
    val array_y=array.++:(array_1) //array_y的内容位 6,7,8,9,10,1,2,3,4,5 都是在前面插入

    /*也可以通过new的方式来创建  在创建的时候指定了泛型的类型 和数组的长度  长度是必须指定的，泛型不写就是Nothing，具体效果还没有研究过）*/
    /*但是Array默认是不可改变的，所以个人感觉这样来创建Array的意义不大。  后面会有可变的Array*/
    val arr0:Array[String] =new Array(10)
    val arr1 =new Array[String](10)
    
    
    /*for循环来遍历数组*/
    for(i <- 0 until array.length){
      println(array(i))
    }
    
    /*增强for循环*/
    for(elem <- array) println(elem)
  }
}

 

 

 

 

 

 

import scala.collection.Map
import scala.collection.immutable.HashMap

object MapOperations {
  
  def main(args:Array[String]):Unit={
    
    /*
     * 在scala中，定义一个Map和Array差不多
     * 这里也是使用Map类的伴生对象来创建ages
     * 其原理也是调用Map伴生对象中的apply方法来实例化
     * 
     * Map的很多方面和Array很相似，
     * */
    /*这里在初始化的时候，要同时放入key和value
     * 在scal中就使用 key->value来表示一个key value对
     * */
    val ages =Map("Rocky"->27,"Spark"->5)
    val agess=Map("LL"->2,"PP"->3)
    
    val ages1=ages.+(("S",2))//返回一个新的Map 新的Map中包含了ages的所有元素和 "S"->2
    val ages2=ages.++:(agess)//返回一个新的Map 新的Map中包含了ages和agess的所有元素
    
    
    /*通过for循环来遍历Map
     * 不得不说scala确实简化了好多操作
     * 在java中要遍历一个map是这样的
     * for(Entry<String, String> en:new HashMap<String,String>().entrySet()){
     * ......................
     * }
     * 在scala中只需要 (k,v) <-ages 就可以了
     *             (k,v)是一个匿名的tuple，前面说过 可见ages的迭代返回tuple 第一个是key 第二个是value
     * */
    for((k,v) <-ages){
      println("Key is : "+k+" Value is : "+v)
    }
    
    println("----------------------------------------------")
    
    for((k,_) <-ages){//同样的，如果我们只关心key，那么v可以用_来代替
      println("Key is : "+k)
    }
  }
}

 

import scala.io.Source

object FileOps {
  /**
   * 这里其实没什么内容，就是Source的两个方法
   * 一个从本地读，一个从网址读
   * 而且用起来真的很爽，不用关心异常，不用去关闭流···
   * 
   * */
  def main(args:Array[String]):Unit={
    /*只要记住Source就是要操作的资源  要从文件取，就fromFile 要从网址取就fromURL*/
    val file = Source.fromFile("E:\\test.txt")
    val urlFile=Source.fromURL("http://spark.apache.org/")
    
    for(line <- file.getLines()){//通过for循环来一行一行的输出 file.getLines()返回一个文件内容的按行迭代
      println(line)
    }
    
    for(line <- urlFile.getLines()){//同上
      println(line)
    }
  }
}