scala学习计算开始基本语法2

上接scala学习开始基本语法1
第五步：数组的使用
在scala中，可以使用new来实例化对象，当你创建一个数组对象的时候，你可以使用数值或者是类型参数。但是在scala中，是使用[]来指明对象，java是使用<>。如下代码

package org.wq.learn
object day2 {
  def main(args: Array[String]): Unit = {
   val strs =  new Array[String](3)
   strs(0)="hello"
   strs(1)="!"
   strs(2)="scala~"
   strs.foreach(println)

  }
 }

从上面代码中可以看到，在Scala中使用[]来指明参数化对象，这里使用了String，在使用数组的时候，使用的是()。
在Scala中为什么要使用（）来访问数组元素，因为对于数组来说，它和其他数据类型并没有什么差别，当你在某个值后面添加了（），Scala把它翻译为调用对应对象的apply方法。

package org.wq.learn
object day2 {
  def main(args: Array[String]): Unit = {
   val strs =  new Array[String](3)
   strs(0)="hello"
   strs(1)="!"
   strs(2)="scala~"
   strs.foreach(println)
   var i=0
   for(i<- 0 to 2){
     println(strs(i))
   }
  }
 }

比如，strs(1),实际上是调用strs.apply(1)。这种方法步仅仅适用于数组，Scala中的任何对象都可以。如果在后面写()，就表示调用该对象的apply方法。如果是对某个对象赋值，如刚才的strs(2)=”scala~”就是调用apply方法，Scala会把赋值语句转化成该对象的update，就是strs(2,”scala~”)。
所以，上面的代码可以写成

package org.wq.learn
object day2 {
  def main(args: Array[String]): Unit = {
   val strs =  new Array[String](3)
   //赋值转化成update方法
   strs.update(0,"hello")
   strs.update(1,"!")
   strs.update(2,"scala~")
   var i=0
   for(i<- 0 to 2){
     //()调用成apply方法
     println(strs.apply(i))
   }
  }
 }

从上面可以看出来，数据就是一个Scala中普通的数据类型，没什么好特别的。但是为了方便使用，提供了下面的初始化数组的方法。

val v1s =  Array("hello","!","scala!")
val v2s=Array.apply("hello","!","scala!")

不用new ,直接使用Array。

第五步：使用Lists
Scala是一个面向函数的编程语言，面向函数的编程有一个特点，就是调用某个方法的时候，不应该有任何的副作用，参数一定，调用方法之后，只能得到返回值。这样的好处是函数是独立的，互相之间的关联减少了，从而是函数的重用性和可靠性编好了。使用这个原则，就表明，变量设置成不可修改的，也避免了多线程访问的互锁问题。
前面说的数组，他的元素是可以修改的。如果想使用不可修改的序列，请使用Lists，这点和java不同，java中的lists是可以修改的，我去。Scala中的Lists设计出来满足函数式编程的风格的。大款的使用方法：

val fruit = "apples" :: "oranges" :: "pears" :: Nil
    println(fruit.head)//头元素
    println(fruit.last)//尾元素
    println(fruit.length)//长度
    println(fruit.reverse)//反转
    println(fruit(1))//通过()访问

定义Lists为：

val list1 = List(1,2,3)
val list2 = List()
println(list1(1))

第六步：元组的使用（Tuples）
Scala中还有一个非常重要的容易，Tuples，元组和Lists不同，Lists和数组只能保存同一种数据类型的值，但是元组可以保存多种数据类型，所以Tuples在返回多个值的时候比较有用。定义了Tuples之后，就可以使用索引和._来访问元素

val tuples = ("wangqi",26)
println(tuples._1)
println(tuples._2)

这里注意的是，和lists和数组不同，Tuples的索引是从1开始的。
Tuples的分量的实际数据类型决定Tuples的类型。比如，上图的Tuples为 Tuples[String,Int]
第七步：使用Sets和Maps
Scala的目标是想然让开发者同时使用面向对象和面向函数的编程方式编写程序，因此它提供的集合分成了2个大类，2个部分，可以修改的集合和不可以修改的集合。比如Array是可以修改的，Lists是不可以修改的。Scala中也提供了两种Sets和Maps集合。
关于Sets，Scala中定义了基类，基类的类型为Trait的Set，类似java中的接口，但是Trait可以实现方法.。Set下面分开，有2个，一个是可变类型-Mutable.Set，一个是不可变类型Immutable.Set。看图使用-xmind画的，将就下，以后会改：

Set的基本使用：定义一个Set，添加一个元素，判断元素是否包含”wang”字符串

 var mysets=Set("wang","jia")
 mysets+="hello"
 println(mysets.contains("wang"))

Scala提供的另一个类型为Map，Scala也提供了2中，immutable和muttable

基本用法：定义，通过()访问，key可以相同，但是访问的是最后一个。

val maps= Map(1->"I",2->"am",3->"boy",4->"!")
println(maps(3))
结果为boy
val maps= Map(1->"I",3->"am",3->"boy",3->"!")
println(maps(3))
结果为!

第八步：函数式的编程风格
简单来看，如果代码中有var，就是指令式编程，不是函数式。如果代码中只有val，那么就很有可能是函数式编程，所以以后scala编程中，不要使用var，全部使用val。看个简单列子

def printStrs(args:Array[String]):Unit={
    var i =0
    while(i<args.length){
      println(args(i))
      i+=1
    }
  }
   val str = Array("hello","scala")
   printStrs(str)

这是java的写法，指令编程
我们去除vars变量，写成符合函数编程

def printStrs2(args:Array[String]):Unit={
    for(arg<-args){
      println(arg)
    }
  }
printStrs2(str)

还可以改成对象的foreach函数调用

def printStrs4(args:Array[String]):Unit={
    args.foreach(println)
  }

减少vars的使用，使代码简洁了，减少错误发生。所以scala开发原则是能减少mutable变量，就不使用。避免副作用，上面的println也是副作用哈。
今天加班有点累，就到这里吧……感谢引路蜂提供的教程……