Scala学习第二天

1，加载scala脚本

 编译一个后缀为scala文件名的文件，写入scala语句，使用:load执行scala脚本

文件内容:
for(i <- 1 to 9){
 for(j <- 1 to 9){
 if(j <= i){
 print(j+"*"+i+"="+j*i+" ")
 }
 }
 println("")
}

scala> :load H:/test/for99.scala
Loading H:\test\for99.scala...
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

2,函数

1）函数定义:

   def 方法名(参数:参数类型):返回类型=方法体   如果方法体不在同一行必须在等号后面加上大括号，scala中没有return 默认最后一条语句返回   注意:参数必须跟参数类型，返回类型有时候可以不定义，他会自动给你推导出类型

2）递归函数：(阶乘操作)

def recursion(n:Int):Int={
if(n==1){
1}else{
n * recursion(n-1)}
}

调用递归:
recursion(5)
返回120

3）函数中默认参数和命名参数

比如定义一个函数，给上参数,a就是普通参数，而b和c就是默认参数
def param(a:Int,b:String=0,c:String="S")=a+b+c

调用这个函数传入参数
param(1)  //如果你这样写，里面他就会默认调用使用默认参数
param(1,"2") //这样他就会把相对应的默认值替换成2
param(c="s",a=3,b="t") //这样就是命名参数

4）变长参数

1，变长参数就是可以指定多个参数他们都是一个类型，我们做一个求和操作
def param(args:Int*):Int={
var x=0
for(i <- args){
 x=x + i
}
x
}

param(1,2,3,4,5)
结果:15

还有一种方式可以填入更多的数字:
param(1 to 10) //这个是不对的，它产生的是1到10的区间数
param(1 to 10:_*) //这样写的话他就会告诉编译器把这些区间数当成列表对待

2，变长参数使用递归操作
def param(args:Int*):Int={
if(args.length==0){
0}else{
args.head + param(args.tail:_*)
}
}

head函数获取第一个数，tail函数获取除第一个的所有数，在把他们解释成每一个列表，就可以继续递归取值了

5）过程函数

过程函数不能加上等号，并且只会执行你里面的过程不会返回有返回值和返回类型，不过里面比如有打印语句可以显示数据，如果你强行加上不是过程语句比如随便一个表达式会报警告

def test(a:Int){println(a);100}
这个就是一个过程函数，他不会执行到100只会打印a这个参数值

注意:如果函数没有参数定义时可以不带括号，那么调用时也不能带括号；如果定义时带括号，那么调用时可有可无

3，延迟加载

定义方式就是在开头加上一个lazy关键字，他的作用就是在定义的时候不会对里面的内容进行加载，如果你写的语句有错也不会报，只会在你调用时候才会出结果或者报错

4，异常

因为之前学过java，scala中的异常其实和java中的几乎一样，不过他的异常类的根类都是throwable

不同就是他try catch中catch中的异常声明可能不一样

之前java中的异常try catch是
try{



}catch(Exception ex){
ex.println();
}


scala中
try{

}catch{
ex:Exception => ex
}

5.数组(Array)

1）定长数组

Array在java中就是我们所说的数组只要定义好了长度就不可改变 
他所在的类是scala.collection.immutable.Array   是不可变这个包下的

（1）定义方式: 1,Array(1,2,3,4)   Array("a","b","c") //这种是直接定义数据
         2,new Array[Int](10) //这种比较像java定义方式，他是new出了一个Array对象，泛型是Int可添 
                                加10个长度的Int类型的数据
（2）赋值(也可更新):val a=Array(1,2,3,4)    a(0)=9  //把1改成9

（3）可以使用for循环遍历里面的内容
           for(i <- a)println(i)

2）变长数组

变长数组  ArrayBuffer 他所在的类是在scala.collection.mutable.ArrayBuffer
（1）定义变长数组:
     首先要导入变长数组 import scala.collection.mutable.ArrayBuffer
      val a=ArrayBuffer[Int]();
 (2)常用操作变长数组
   a += 1      //追加1到数组里
   a += (1,4,5) //追加多个到数组里
   a ++= Array(6,7,8) //追加到一个数组到数组里
   a.trimEnd(4)   //过滤后4个数据
   a.trimStrat(4) //过滤前4个数据
   a.insert(1,1,2,3,4)   //第一个是索引，意思是在索引位置插入1,2,3,4若干个数据
   a.append(5,6,7)  //在末尾追加5,6,7若干个数据
   a.appendAll(array(5,6,7)) //在末尾追加一个数组
   a.remove(3,5) //在3到5这个区间删除所有数
   a.toArray  //转成一个定长数组

3）数组常用的函数

1,filter   //过滤函数
  a.filter(_%2==0)  //过滤出偶数元素
2,map     //组成新的集合
  a.map(_*2)  //每个数都乘于2组成新的集合
3，(sum,min,max)等等一些聚合函数
  a.sum()
4，sorted   //排序，升序排序
  a.sorted 
5,mkString   //输出数组，可以指定字符串分隔符 
  a.mkString(":") //他会以:来充当分隔符

4）二维数组

定义二维数组:
val a:Array[Array[Int]]=Array.ofDim(3,4);  //定义一个3行4列且默认值为0的二维数组

二维插入数据:
a(1)(1)=2 

遍历二维数组
 for (i <- 0 until a.length ){
 for (j <- 0 until a(i).length){
 println(a(i)(j))
 }}

6，对偶(Map) 

map就会由多个key value组成的一个类似集合的东西，在scala中叫对偶，在java中叫集合，而且我们也可以把每个map里的每个key value看成一个二位的tuple

1)定义map:（他默认定义的是不可代表的map）
val a=Map("1" -> a,"2" -> b,"3" -> c);或者Map((1,"a"),(2,"b"),(3,"c"))
val b=scala.collection.mutable.Map("1" -> a ,"2" -> b ,"3" -> c); //可改变的map

2)获取摸个key的值
 1，  a("key")  //String类型取法
     a(key) //真是类型取法
 2，使用getOrElse()方法来获取值他有两个参数，第一个是取值的key，第二个是假如取不到赋予一个默认值
    a.("1",a)
3)map添加数据
 1,可变map添加数据和修改数据
   b.put("4","d")    
   b += ("5" -> "a") 或者 b +=(("5","b"))
   修改的话就是填上指定的key改不同的值
 2,不可变添加数据  //不可变map准确的说应该是不能添加数据的，说是能加数据其实添加后就已经是
                    另一个新的map了，而原有map不会发生改变
   a + ("4" -> "a") 或者 a +  (("4","a"))
4)map删除数据
  1，可变map删除
    b -= (key)
  2, 不可变map删除
    b - (key)

注意:如果在定义key的时候类型不一定，那么只能是什么类型的key，决定要不要加引号

5)迭代map
  1,使用普通for循环
   for((k,v) <- m)println(k+"=====>"+v)
  2,单独输出key
   for(k <- m.keySet)println(k)
  3,单独输出value
   for(v <- m.values)println(v)

6）排序map  sortedMap
  定义方式和map一样只不过自带key排序功能  

7，元组(tuple)

元组就是一堆任意类型组成一起的类型要tuple，他最多可定义22个

1)tuple定义:
      val t=(1,"tuple",Array(1,2,3)) //里面可以定任意类型
2)获取tuple数据(下标从1开始)
     t._1  //获取第一个元素

8，zip操作

就是可以把两个数组拉倒一块，形成一个tuple为2的数组

我们先定义两个不同类型不同长度的数组
val a=Array(1,2,3,4,5)
val b =Array("a","b","c","d")

使用zip方法
a.zip(b)
结果: Array[(Int, String)] = Array((1,a), (2,b), (3,c), (4,d)) //匹配不到的数据直接弃掉