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.数组中的每个元素