Scala学习

Scala是运行在JVM上的一门语言，一种纯粹的面向对象编程语言，而又无缝地结合了命令式和函数式的编程风格。

scala安装目录下scala/api/scala-library/index.html 可查看scala的api文档

scala变量定义

var str : String = "zhangsan"

常量定义

val str2 : String = "zhangsan"

注：在scala中，对于变量必须要初始化，不允许只声明而不初始化。

scala的函数都有返回值，当函数定义有“=”时，返回值是最后一行语句执行的内容，如果最后一行语句没有返回内容

或函数定义时没有“=”，则该函数的返回值是Unit类型，即一个“()”.

  def add(a:Int,b:Int) = {    a + b  }  var c = add(1,2)  print(c)

返回值3

  def add(a:Int,b:Int) = {    println(a + b)  }  var c = add(1,2)  print(c)

返回值是Unit类型  即()

  def add(a:Int,b:Int){    a + b  }  var c = add(1,2)  print(c)

返回值是Unit类型 即()

判断结构

  var a : Int = 1    if (a == 1) {    println(1)  }else if (a == 2) {    println(2)  }else {    println(0)  }

while循环结构

  while (true) {      }

for循环1到10 包含10

  for(i <- 1 to 10){    println(i)  }

也可以使用方法调用形式1到10

  for(i <- 1.to(10)){    println(i)  }

for循环1到10 不包含10

  for(i <- 1 until 10){    println(i)  }

倒着遍历

  for(i <- 1.to(10) reverse){    println(i)  }

遍历1,3,5,7,9 即步长是2

  for(i <- 1.to(10,2)){    println(i)  }

循环中判断i等于3时输出，在scala中称为守卫

  for(i <- 1.to(10,2); if i == 3){    println(i)  }

双重for循环

  for(i <- 1.to(10); j <- 1.to(5)){    println(i + " " + j)  }

for的推导式，将循环结果保存为一个Vector

  var a = for (i <- 1.to(10)) yield (i)  println(a)

数组，可以指定统一类型，也可以省略。减一统一类型

  //定长数组定义  长度为3的定长数组  var arr1 = new Array[Int](3)  arr1(0) = 1<pre name="code" class="html">  arr1(1) = 2<pre name="code" class="html">  arr1(2) = 3

//直接给数组赋值var arr = Array[Int](1,2,3,4)  for(i <- arr) println(i) println(arr(2))//获取第三个元素<pre name="code" class="html"> println(arr.length)//数组长度

for(i <- 0 until arr.length)//遍历整个数组
  println(i)

  println(arr.mkString(","))//数组元素以逗号连接返回字符串
 
  println(arr.sum)//数组中元素总和
 
  println(arr.max)//数组中最大值

变长数组ArrayBuffer

  var arr = ArrayBuffer[Int]()  arr += 1  arr += 1  println(arr.mkString(","))

Array如果想添加元素的话需要先转成ArrayBuffer，调用Array的toBuffer

将一个数组添加到另一个数组中

arr ++= arr1

Map

  //mutable包中的map可以修改，immutable中的map不可以修改，默认会使用不可修改的  var map1 = scala.collection.mutable.Map[String,Int]("zhangsan"->32,"lisi"->34)    map1 += ("wangwu"->35)    map1("lisi") = 20    println(map1("zhangsan"))  println(map1)    if(map1.contains("zhaoliu"))    println(map1("zhaoliu"));    println(map1.getOrElse("zhaoliu", "默认值"))//如果不存在key，返回指定的默认值    for((k,v) <- map1)    println(k + ":" + v)      for(item <- map1)    println(item)

元祖

  //元祖,用于函数的返回值不止一个的情况下  var t1 = (1,2,3,"aa")    println(t1)  //元祖的下标从1开始  println(t1._1)  println(t1 _3)//空格也可以。。。    var (first,second,third,forth) = t1    println(second)    //将Hello World进行分区返回一个元祖，分区的条件是是否是大写的  println("Hello World".partition { _.isUpper })  var arr1 = Array("a","b","c")  var arr2 = Array(1,2,3)  var arr3 = arr1.zip(arr2)  println(arr3.mkString(","))//(a,1),(b,2),(c,3)  println(arr3.toMap)//Map(a -> 1, b -> 2, c -> 3)

类中定义属性

object Demo3 extends App{  var a = new Acount()    println(a.value)    a.value = 10    println(a.value)    //添加@BeanProperty(不能和private同时使用) 可以使用get set方法    a.setValue(40)    println(a.getValue())  }class Acount{  @BeanProperty var value = 0}

类构造器

object Demo4 extends App{  var a = new Acount2(20)//调用主构造器    var a2 = new Acount2("a",20)//调用辅助构造器    println(a.value)    a value = 10//可以用空格代替(.)    println(a.value)    //添加@BeanProperty(不能和private同时使用) 可以使用get set方法    a.setValue(40)    println(a.getValue())  }//类构造器class Acount2(@BeanProperty var value : Int){  //辅助构造器，第一行必须调用主构造器  def this(a:String,b:Int){    this(0)    println("辅助构造器" + a + b);  }}

伴生对象

//scala类中不能提供静态字段和静态方法，需要借助伴生对象，即与类同名的对象/** * @author Administrator */object Demo5 extends App{    }object Acount3{  private var id:Int = 10}//类可以调用伴生对象中私有属性class Acount3{  private var value:Int = 0  def toStr {    println(Acount3.id)  }}

函数

  //将函数赋值给变量  def f(a:Int) = {    a + 1  }  var fun = f _  println(fun(1))

  //直接定义匿名函数赋值给变量，指定形参和函数体  var fun2 = (a:Int,b:Int)=>{a+b}  println(fun2(1,2))

  //将函数作为形参，定义新函数fun3.形参函数的形参是两个Int类型变量，返回值是一个Int类型变量，然后在函数体内调用形参函数  def fun1(a:Int,b:Int) = {a + b + 1}  def fun3(fun:(Int,Int)=>Int)={fun(3,3)}  println(fun3(fun1 _))  println(fun3(fun2))//fun2为上面定义的匿名函数

  //1.匿名函数作为形参  //2.该匿名函数只有一个形参  //3.函数体只有一行  //可简写为下面的形式  def fun4(a:Int,fun:(Int)=>Int) = {fun(a)}  println(fun4(3,(a:Int)=>{a + 3}))//该匿名函数形参满足条件要求  println(fun4(3,_+3))//简写形式 该匿名函数形参部分可省略，函数体中将形参替换为_

@BeanProperty

<span style="font-size:18px;">object Demo3 extends App{  var a = new Acount()    println(a.value)    a.value = 10    println(a.value)    //添加@BeanProperty(不能和private同时使用) 可以使用get set方法    a.setValue(40)    println(a.getValue())  }class Acount{  @BeanProperty var value = 0}</span>

高阶函数

<span style="font-size:18px;">  //将函数赋值给变量  def f(a:Int) = {    a + 1  }  //fun拥有了f函数的功能  var fun = f _  println(fun(1))    //直接定义匿名函数赋值给变量  var fun2 = (a:Int,b:Int)=>{a+b}  println(fun2(1,2))    //将函数作为形参，定义新函数fun3.形参函数的形参是两个Int类型变量，返回值是一个Int类型变量，然后在函数体内调用形参函数  def fun1(a:Int,b:Int) = {a + b + 1}  def fun3(fun:(Int,Int)=>Int)={fun(3,3)}//fun:(Int,Int)=>Int意思是传入函数fun，fun的参数类型是(Int,Int)，返回值类型是Int  println(fun3(fun1))  println(fun3(fun2))    //1.匿名函数作为形参  //2.该匿名函数只有一个形参  //3.函数体只有一行  //可简写为下面的形式  def fun4(a:Int,fun:(Int)=>Int) = {fun(a)}  println(fun4(3,(a:Int)=>{a + 3}))//该匿名函数形参满足条件要求  println(fun4(3,_+3))//简写形式  该匿名函数形参部分可省略，函数体中将形参替换为_</span>

sacla中下划线(_)代表的意义

1.获取元祖的值 (t1._1 获取元祖t1的第一个元素)

2.将函数赋给变量 ( var fun = f _)

3.数组中的每个元素