scala学习笔记2

package com.scala.stu
import scala.collection.mutable.Map
import scala.io.Source
/**
 * 第二章例子
 */
object t_002 {
  
  def main(args: Array[String]): Unit = {
    t_arr()
    t_list()
    t_tuple()
    t_mp()
    t_File()
  }
  
  /**
   * 例子一，数组的使用，使用的是获取匿名函数的方法构造函数体
   */
  def t_arr():Unit = {//函数中的Unit类似java中的void
    
    //注：用val定义的对象是不能够重新赋值的，但变量的对象内部却仍然可以改变
    val arr = new Array[String](3)//定义一个数组，并且定义他的长度,数组的长度是定常的
    val names = Array("q","w","e")//val names = Array.applay("q","w","e")
    arr(0) = "hello"//利用括号定义下标的value值
    arr(1) = ","//arr(1) 转化成arr.applay(1),所以scala 可以使用()来调用数组游标
    arr.update(2, "world!\n")
    
    //注：0 to 2 ，转化成方法调用(0).to(2)
    for(i <- 0 to 2){//for循环中的<-代表将右边的所有依次赋值给左边
      print(arr(i))
    }
    //1+1 被转化成(1).+(2)形式
    print((1).+(2))
  }
  
  /**
   *list的例子 
   */
  def t_list(): Unit = {
    
    val oneTwo = List(1,2)
    val threeFour = List(3,4)
    val oneTwoThreeFour = oneTwo ::: threeFour//list是列表类，中定义了:::叠加功能
    println(" " + oneTwo + " and " + threeFour + " were not mutated.")
    println("Thus, " + oneTwoThreeFour + " is a new List.")
    for(v <- oneTwoThreeFour){
      print(v);println
    }
    
    val twoThree = List(2,3)//这里不写成new List，因为“List.apply()”是定义的工厂方法
    val oneTwoThree = 1 :: twoThree//列表类中最常用的操作符‘::’,他可以把新元素
                                    //组合到现有列表的最前端，然后返回执行结果的新列表
                                    //1 :: twoThree 转化成twoThree.::(1)
    println(oneTwoThree)
    //List中没有append操作，因为他耗时呈线性增长，而::是固定时间
    val oneTwoThree2 = 1 :: 2 :: 3 :: Nil//Nil是空列表的缩写，可以用cons操作符把所有元素都串起来
    println(oneTwoThree2)
    
  }
  
  /**
   * 注：常用
   * 元组的例子，与列表不同，元组可以包含不同类型的元素
   */
  def t_tuple(): Unit = {
    val pair = (99,"jiu")
    print(pair._1+" ");println(pair._2)//之所以使用_1不用()是因为applay()返回的是相同的类型
    val pair2 =(99,pair,"九")
    print(pair2._1+" ");println(pair2._2._1,pair2._3)
  }
  
  /**
   * Map的例子
   */
  def t_mp(): Unit ={
    val map = Map[Int,String]()//这里定义需要导入import scala.collection.mutable.Map
    map += (1 -> "go")  //任何对象都能调用 ->的机制被称为隐式转换
    map += (2 -> "to")  //调用->机制返回的是二元元组
    map += (3 -> "here")//意思是:将Int 3 转化成 “here”字符串
    println(map(2))     //map中都会元组
  }
  
  /**
   * 从文件里读取文本行
   */
  def t_File():Unit = {
    //首先是进行包的导入import scala.io.Source
    for(line <- Source.fromFile("i:/doc/1.txt").getLines){//返回的是一个枚举器，一旦遍历完，枚举器就会失效
      print(line+ " ")
    }
    
    //将从文件中读取的枚举器转化成一个列表器，这样就可可以把整个文件存入到内存当中供我们随时使用
    val lines = Source.fromFile("i:/doc/1.txt").getLines.toList
    var maxWidth = 0 
    for(line <-lines)
      maxWidth = maxWidth.max(widthOfLength(line))//函数的比较两个值得最大值
      println("\n最大的行："+ maxWidth)
      
      //reduceLeft方法把传入的方法参数应用于lines的第一，二个元数，产生结果，然后再应用于这个结果和lines
      //接下去的一个元素，依次类推直至整个列表。最后返回最后应用的结果
      val longestLine = lines.reduceLeft(
        (a,b) => if(a.length > b.length) a else b    
      )
      val maxWidth2 = widthOfLength(longestLine)
      println("最大行数："+maxWidth2)
  }
  
  /**
   * 统计文本的最大长度的行数
   * 使用函数是的函数
   */
  def widthOfLength(s: String) = s.length().toString().length
  
}