[原创]Scala学习：Tuple,Array,Map ,文件操作

1.Tuple：元祖。是一个有用的容器对象。

　　1）特点：

　　　 ① 元祖是不可变的,即,当声明完了一个元祖，那么它的长度就不可以在改变；

　　　 ② 元祖可以包含不同类型的数据，对象；

　　 　③ 索引是从 '_1' 开始，读取元祖中的内容

　　　 ④标识：' () '

　　2）代码

1   //元祖
2   def doTuple() {
3     //'()' 定义元祖
4     val pair = (100, "scala", "spark") //元祖的类型val pair: (Int, String, String) 由scala类型推倒
5     println(pair._1)
6     println(pair._2)
7   }

 

　　　

2.Array：类型参数化数组

　　1）特点：　

　　    ①参数化的意思是指创建实例的同时完成对它的“设置”，即赋值；

　　　 ②scala数组通过索引值加圆括号进行访问，array(i);有别于java中的方括号；

　　　③Array长度不可变，但是它的值可变；

　　2）代码：

 1   //数组
 2   def doArray() {
 3     //通过Array 关键字定义数组
 4     val array = Array(1, 2, 3, 4, 5)
 5     //      for(i <- 0 until array.length){
 6     //        println(array(i))
 7     //      }
 8 
 9     //      增强for循环，推荐
10     for (elemt <- array) println(elemt)
11 
12   }

 

 

3.Map

 

 1  //map操作
 2   def doMap() {
 3     //通过Map关键字 定义一个Map
 4     val ages = Map("jason" -> 27, "hadoop" -> 20)
 5 
 6     for ((k, v) <- ages)   println("key is :" + k + ", hadoop is :" + v) //key is :jason, hadoop is :27  key is :hadoop, hadoop is :20
 7 
 8     // "_ " 是一个占位符
 9     //     for((k,_) <- ages) println("key is :"+ k )//key is :jason  key is :hadoop
10 
11   }

 

 

函数式编程：方法没有副作用是函数式风格 编程的重要思想，计算并返回值应该是方法的唯一目的。

　　1.方法之间的耦合度降低，更加可靠和易于重用

　　2.(在静态类型语言里)方法的参数和返回值都要经过检查器的检查，因此，可以比较容易的根据类型错误推断其中隐含的逻辑错误

 

 

 

4.文件的操作：source类中的静态方法

 

1  def doFile() {
2 
3     // 通过scala.io.Source 对象
4     val file = Source.fromFile("E:\\java_workspase\\scalaProgramWorkSpace\\test.txt")
5     for (line <- file.getLines()) println(line)
6 
7   }

 

转载于:https://www.cnblogs.com/jasonHome/p/5517670.html