Scala语言笔记 - 第一篇

Scala语言笔记 - 第一篇

目录

• Scala语言笔记 - 第一篇
  • 1 基本类型和循环的使用
  • 2 String相关
  • 3 模式匹配相关
  • 4 class相关
  • 5 函数调用相关

​ 最近研究了下scala语言，这个语言最强大的就是它强大的函数式编程（Function Programming）能力，记录下最近学习的一些新的和技巧。注意：本系列博客不会从头讲解该语言的语法，而是通过一些例子讲解该语言的一些技巧，如果需要从头学习scala，建议使用该教程快速入门。

1 基本类型和循环的使用

​ 看如下代码：

def main(args: Array[String]): Unit = {

     //声明类型，不写类型的话，scala会根据具体的值进行类型推断，如果不写类型，则必须进行初始化
    var sum:Int = 0

    /*
     * var: 可以进行重新赋值，但是需要注意的是：scala是静态语言，因此不能赋值为其他类型的
     * val: 不可变类型，类似于Java的final
     */
    var str = "hello world"
    //str = 1    //这样是不可以的，str已经是String类型，不可以再被赋值为Int
    //普通的函数调用
    val res = func(str)

    //包含5
    for (num <- 1 to 5) {
      print("num:" + num + "\t")
    }

    println("")
    //不包含5，这个<-不好打，不知道怎么想的o(*￣︶￣*)o
    for (num <- 1 until 5) {
      print("num:" + num + "\t")
    }
    println("Result" + res)
}

/**
    * Scala的函数定义，类型在后面，冒号后面的是返回值，{}的为函数体
    * 如果函数体只有一两行，那么可以不写大括号
    * @param str
    * @return
    */
  def func(str: String): String = {
    println("This is your str:" + str)
    //类似于Ruby，最后一行默认为返回值
    "my String"
  }

2 String相关

​ scala和Java类型，String类型是可以变类型，因此，构建String的时候，最好使用StringBuilder来进行拼接。

//因为string是不可变的，因此，可使用StringBuilder来处理该情况
  def strTest(): Unit = {
    var str = "hello world"
    var str1:String = " this is scala"
    println("str + str1:" + (str + str1))

    //使用StringBuilder进行字符串的拼接
    var sb = new StringBuilder
    //在scala中，++=其实是一个函数，这里是在进行函数调用
    sb ++= "hello"
    sb ++= "world"
    // += 是char
    sb += 'd'
    println("sb:" + sb.toString)

    /*
     * mkString是一个很好用的方法，三个参数分别为：head middle footer，因此这段代码最终生成的结果为:
     * /**
        * this is a comment
        * another line
        */
     * 一段标准的多行注释
     */
    str = "\nthis is a comment\nanother line"
    var res = str.split("(\r\n)|\r|\n").mkString("/**", "\n * ", " \n */")
    println(res)
  }

3 模式匹配相关

​ scala中最大的一个特点就是其强大的模式匹配功能，我们看下面的一段代码：

//模式匹配
def matchTest(): Unit ={
  println(matchTestInternal(1))
  println(matchTestInternal("hello"))
  println(matchTestInternal(2L))
}

//匹配到任何一个，就直接返回，不会再去匹配其他的，和switch不一样
//Any表示可以匹配任意类型
def matchTestInternal(x: Any) : Any = {
  x match {
    case 1 => "one"
    case str:String => "String"
    case integer:Int => "Integer"
    //other. similiar to default，在scala中_的用途非常多
    case _ => "Other"
  }
}

4 class相关

​ scala中的class可以定义在任何地方，没有Java文件名和类名必须保持一致的限制，且，在scala中，构造方法也和Java有很大的区别。

//scala定义class的方式有些不同，定义带参数的类时，参数是写在类里面的
def classTest(): Unit ={
    //在scala中，构造方法的参数是直接放在类名后面
  class HelloClass(val _name:String, val _age:Int){
    private var name = _name
    private var age = _age

    def getAge(): Int ={
      return age
    }

    //覆写非抽象方法，必须要有override
    override def toString: String = {
      "name:" + name + "  age:" + age
    }
  }

    //定义子类的时候，如果要覆盖父类中的变量，那么也需要写上override
  class HelloChildClass(override val _name:String, override val _age:Int) extends  HelloClass(_name, _age)
  {
    private var name = _name
    private var age = _age

    override def toString: String = {
      "Child class's toString[" + "name:" + name + " age:" + age + "]"
    }
  }

  //对刚才定义好的类进行调用
  val name = "name"
  val age = 10
  var child = new HelloChildClass(name, age)
  child.getAge()
  println(child.toString)

  var child2:HelloClass  = new HelloChildClass(name, age)
  child2.getAge()
  println(child2.toString)
}

5 函数调用相关

​ 因为scala对于函数式编程的天然支持，所以该语言中会出现大量的函数传值，并且还支持很多简略的写法，比如调用简单函数时可以不写()，比如支持函数的柯里化(Currying)

def funcTest(): Unit = {
  //函数可以作为参数进行传递，但是方法不行，并且函数必须要有参数列表
  //定义一个函数
  var x = 10
  var y = 20
  //传入函数
  funcWithFunc(myBody)
  //调用mybody2，把二元参数调用转换为一元参数调用，这种做法叫做函数的柯里化（Currying），是一个数学里面的概念
  myBody2(1)(2)

  //定义一个短小精悍的func
  var f1 = (x:Int, y:Int) => x * y
  //直接传给function
  funcWithFunc(f1)

  //函数传名调用和传值调用，传值调用：直接计算函数的值，然后传给另外一个函数，传名调用：在函数内部进行调用
  acceptTime(time())
  println("-----------------------")
  acceptTime2(time())

  println("-----------call aVerySumpleFunc---------------")
  //这里调用的时候，可以不用写()，自动进行调用
  println(aVerySimpleFunc.length)
  println("----------------------------------------------")

  println("-------------call funcWithFuncPara------------")
  //表示调用funcWithFuncPara函数，这个函数接受一个返回Int类型的函数作为参数，参数函数不需要传入任何参数，
  //因此，在scala中，可以采用大括号的方式快速创建一个没有任何参数的函数
  funcWithFuncPara {
      println("This is func para!")
      100
  }
  println("----------------------------------------------")
}

//该函数的参数为一个只返回Int类型的函数，调用这种函数的时候，可以采用大括号进行非常精简的调用
def funcWithFuncPara(f : => Int) : Unit = {
    println("This is a function with a simple function parameter")
    f
}

//一个非常简单的function，当调用这种func的时候，可以不用写()
def aVerySimpleFunc() = "String"

def myBody(x:Int, y:Int) : Int = {
  var sum = x + y
  println("x + y = " + sum)
  sum
}

//注意，也可以采用这种写法，两个连着的括号表示两个参数的传递，也可以使用myBody那种传统的写法
def myBody2(x:Int)(y:Int) : Int={
  println("--------------------myBody2---------------------------")
  println(s"x=$x  y=$y")
  println("--------------------end---------------------------")
  0
}

//可以接受函数作为参数的函数
def funcWithFunc(body : (Int, Int) => Int): Int =
{
  body(10,20)
}

def time() : Long ={
  println("Now, Get the nano time.")
  System.nanoTime()
}

// => 表示是一个传名调用，其实本质上就是接受一个函数为参数
def acceptTime(body : => Long): Unit = {
  println("acceptTime() enter...")
  println("Now, will call the body")
    //这里的body表示直接进行调用的意思
  println("body get time:" + body)
}

// 表示是一个普通调用，传值调用
def acceptTime2(body : Long) : Unit = {
  println("acceptTime2() enter...")
  println("Now, will call the body")
  println("body get time:" + body)
}