Scala总结

常量与变量的定义

• 变量(var)

//语法
//var VariableName : DataType [=  Initial Value]
var year = 	2018
var year2 : Int = 2018
var name = "Scala"
var name2 : String = "Scala"

• 常量(val)

//语法
//val VariableName : DataType [=  Initial Value]
val year = 2018
val year2 : Int = 2018
val name = "Scala"
val name2 : String = "Scala" 

• 多个变量常量申明

var year1,year2 = 2018
val name1,name2 = "Scala"

Scala常用数据类型

数据类型	描述
Byte	8位有符号补码整数 数值区间为 -128 到 127
Short	16位有符号补码整数。数值区间为 -32768 到 32767
Int	32位有符号补码整数。数值区间为 -2147483648 到 2147483647
Long	64位有符号补码整数。数值区间为 -9223372036854775808 到 9223372036854775807
Float	32位IEEE754单精度浮点数
Double	64位IEEE754单精度浮点数
Char	16位无符号Unicode字符, 区间值为 U+0000 到 U+FFFF
String	字符序列
Boolean	true或false
Unit	表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。
Null	null 或空引用
Nothing	Nothing类型在Scala的类层级的最低端；它是任何其他类型的子类型。
Any	Any是所有其他类的超类
AnyRef	AnyRef类是Scala里所有引用类(reference class)的基类

• Int 或 Long

//Int
var n1 = 10
//Long
var n2 = 10L

• Double 或 Float

//Double
var n1 = 10.5
//Float
var n2 = 10.5F

String 对象是可变还是不可变？假如要创建一个可以修改的字符串，应该使用哪个类？

不可变。使用StringBuilder类

val buf = new StringBuilder
      buf += 'a'
      buf ++= "bcdef"

转义字符

转义字符	Unicode	描述
\b	\u0008	退格(BS) ，将当前位置移到前一列
\t	\u0009	水平制表(HT) （跳到下一个TAB位置）
\n	\u000a	换行(LF) ，将当前位置移到下一行开头
\f	\u000c	换页(FF)，将当前位置移到下页开头
\r	\u000d	回车(CR) ，将当前位置移到本行开头
"	\u0022	代表一个双引号(")字符
’	\u0027	代表一个单引号（’）字符
\	\u005c	代表一个反斜线字符 ‘’

IF…ELSE 语法

//第一种
if(布尔表达式)
{
   // 如果布尔表达式为 true 则执行该语句块
}

//第二种
if(布尔表达式){
   // 如果布尔表达式为 true 则执行该语句块
}else{
   // 如果布尔表达式为 false 则执行该语句块
}

//第三种
if(布尔表达式 1){
   // 如果布尔表达式 1 为 true 则执行该语句块
}else if(布尔表达式 2){
   // 如果布尔表达式 2 为 true 则执行该语句块
}else if(布尔表达式 3){
   // 如果布尔表达式 3 为 true 则执行该语句块
}else {
   // 如果以上条件都为 false 执行该语句块
}

Scala循环-for循环

语法：

for( var x <- Range ){
	statement(s);
 }

以上语法中，Range 可以是一个数字区间表示 i to j ，或者 i until j。左箭头 <- 用于为变量 x 赋值。

//i to j,包含j
var i = 0
for(i <- 1 to 3){
	println(i)//结果：1，2，3
}


//i until j,不包含j
var j = 0 
for(j <- 1 until 3){
	println(j)//结果：1,2
}

函数

• 函数定义

//语法
def functionName ([参数列表]) : [return type] = {
   function body
   return [expr]
}

例1：

//传入参数，得到返回值
def addFunction(a:Int,b:Int) : Int={
	//可不写return，默认返回最后一行的值
	return a+b
}

例2：

//没有返回值
def printMethod = println("无返回值")
//Unit
def printMethod2 : Unit = println("无返回值2")
//
def printMethod3() = println("无返回值2")

例3：

//默认参数
def defaultMethod(name:String='doudou'):String={
	name
}

例4:

  // 变长参数
  def sum(nums: Int*) = {
    var result = 0
    for(num <- nums) {
      result += num
    }
    result
  }

闭包

闭包是一个函数，返回值依赖于声明在函数外部的一个或多个变量。

var n1 = 10
val result = (n3:Int) => n3+n1

11.val a = 10，怎样将a转为double类型、String类型？

a.toString
a.toDouble
a.asinstanOf[Double]

12.Scala函数中是把方法体的最后一行作为返回值，需不需要显示调用return？

不需要

13.怎样定义一个字符串数组？下标是从1开始的吗？

var z:Array[String] = new Array[String](3)
var z = new Array[String](3)
var z = Array("1","2","3")

下标从0开始

14.1 to 10 ==> 1.to(10)，10包含不包含？

包含

15.Range(1, 10)，1 until 10包含不包含？

都不包含

16.Scala 模式匹配语法是什么？

match

object Test {
   def main(args: Array[String]) {
      println(matchTest(3))
   }
   def matchTest(x: Int): String = x match {
      case 1 => "one"
      case 2 => "two"
      case _ => "many"
   }
}

17.异常报错是语法？

import java.io.FileReader
import java.io.FileNotFundExcepiton
import java.io.IOException

Object Test{
	def main(args : Array[String){
		try{
			val f = new File("input.txt")
		}catch{
			case ex: FileNotFundExcepiton =>{
				println("FileNotFundExcepiton")
			}
			case ex: IOException =>{
				println("IOException")
			}
		}
	}
}

18.Array、ArrayBuffer，谁是定长？谁是变长？

Array 定长
ArrayBuffer 变长

19.什么是隐式转换函数？什么场景下用？怎样定义？

//标记规则：只有标记为implicit的变量，函数或对象定义才能被编译器当做隐式操作目标。
implicit val i: Int = 1
//关键字：implicit

20.Scala面向对象,三大特性是什么？什么区别？

封装(属性私有，方法公有)，继承，多态(父类引用指向子类对象)

23.变长数组ArrayBuffer的系列问题

var c = new ArrayBuffer[Int]();
//1. 在尾部添加一个元素
	c+=2
//2. 在尾部添加多个元素
   c+=(3,4,5)
//3. 追加集合
	c++=Array(7,8,9)
//4. 指定位置添加元素
	c.insert(3,33)//在下标3的后面添加33
//5. 移除尾部n个元素
	c.trimEnd(n)
//6. 移除开头n个元素
	c.trimStart(n)
//7. 移除某个位置的元素
	c.remove(n)
//8. 移除从下标为n开始（包括n）的count个元素
	c.remove(n,count)
//9. ArrayBuffer 转 Array
	c.toArray
//10. Array 转 ArrayBuffer
	c.ArrayBuffer

模式匹配

def judgeGrade(grade:String): Unit = {
    grade match {
      case "A" => println("Excellent...")
      case "B" => println("Good....")
      case "C" => println("Just so so....")
      case _ => println("You need to work harder....")
    }
  }

  def judgeGrade2(name:String, grade:String): Unit = {
    grade match {
      case "A" => println("Excellent...")
      case "B" => println("Good....")
      case "C" => println("Just so so....")
      case _ if name == "dove" => println(name + ", you are a good boy, but ...")
      case _ => println("You need to work harder....")
    }
  }


  def greeting(array:Array[String]): Unit = {
    array match {
        // dove开头的且只有一个元素
      case Array("dove") => println("Hi: 奶总")
        // 2个任意的元素
      case Array(x,y) => println("Hello:" + x + "," + y)
        // xiaoweiba开头的任意多个元素
      case Array("xiaoweiba",_*) => println("Hello: zhangsan and other...")
      case _ => println("Hi: everybody....")
    }
  }

  def greeting(list: List[String]): Unit = {
    list match { // list = head + tail
      case "dove"::Nil => println("Hi: 奶总")
      case x::y::Nil => println("Hi:" + x + " , " + y)
      case "dove"::tail => println("Hi:奶总 and other friends...")
      case _ => println("Hi: everybody...")
    }
  }
  def matchType(obj:Any): Unit = {
    obj match {
      case x:Int => println("int")
      case s:String => println("string")
      case m:Map[_,_] => m.foreach(println)
      case _ => println("other type")
    }
  }

  def judgeIdentify(person: Person): Unit = {
    person match {
      case CTO(name, floor) =>println("cto")
      case Employee(name, floor) =>println("Employee")
      case _ => println("other")
    }
  }

  val inputs = Array(CheckTimeOutTask, HeartBeat(10000), SubmitTask("001","task001"))

  inputs(Random.nextInt(inputs.length)) match {
    case SubmitTask(id, name) => {
      println("SubmitTask: " + id + " , " + name)
    }
    case HeartBeat(time) => {
      println("HeartBeat:" + time)
    }
    case CheckTimeOutTask => {
      println("CheckTimeOutTask")
    }
  }

异常处理

  // IO常见处理步骤
  try {
    // 1） open file
    // 2)  use file
    val i = 1/0
  } catch {
    case e:ArithmeticException => println("除数不能为0...")
    case e:Exception => println(e.getMessage)
  } finally {
    // io file
    println("finally.....")  // 是肯定执行的，通常用于做资源的释放使用
  }

主构造器与附属构造器

//主构造器
//如果name不用val或var修饰，则在类外无法访问
class Person(val name:String,age:Int){

  //私有变量。只能在类中访问
  private[this] var sal:Int = _
  //附属构造器，全部this命名，并且必须调用主构造器或者其他附属构造器
  def this(name:String,age:Int){
    this(name,age)
    this.sal  = 10000
  }

/**
  * 子类构造方法触发之前要先触发其父类的构造方法
  *
  * 父类中已有的字段就不需要使用val/var修饰
  */
class Student(name: String, age: Int, var major: String)
  extends Person(name, age) {

  println("Student constructor enter...")
 
 //重写
  override val school = "peking"
  override def toString = "this is Student toString"

  println("Student constructor leave...")
}

可变集合与不可变集合

不可变 scala.collection.immutable
可变 scala.collection.mutable

List

Nil 是一个空List

//新建
 var a = List(1,2,3,4,5,6)
 //追加 
 a = 0 :: a //a: List[Int] = List(0, 1, 2, 3, 4, 5, 6)
 //拼接
 a = a:::List(7,8,9) //a: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9)
 //删除
 //a.remove(1)  //报错
 val b =  scala.collection.mutable.ListBuffer(1,2,3,4,5)
 b.remove(1)

Map

//新建
val map = Map[String,Int]()
//追加
// map += ('c'->3)::map 报错，默认不可变
val map2 = scala.collection.mutable.Map[String,Int]()
map2 += ("c"->1)

//遍历
  for((key,value) <- map2 ) {
    println(key + " : " + value)
  }

  for(key <- map2.keySet){
    println(key + " : " + map2.getOrElse(key, 0))
  }

  for(value <- map2.values) {
    println(value)
  }

  for((key,_) <- map2) {
    println(key + " : " + map2.getOrElse(key, 0))
  }

高级函数

• map

scala> val list = List(1,2,3,4,5)
list: List[Int] = List(1, 2, 3, 4, 5)

scala> list.map(x=>x+2)
res15: List[Int] = List(3, 4, 5, 6, 7)

scala> list.map(_+2)
res17: List[Int] = List(3, 4, 5, 6, 7)

scala> val list = List(List(1,2),List(2,3),List(3,4))
scala> list.map(x=>x.map(y=>y+2))
res29: List[List[Int]] = List(List(3, 4), List(4, 5), List(5, 6))

scala> list.map(_.map(_+2))
res25: List[List[Int]] = List(List(3, 4), List(4, 5), List(5, 6))

• flatMap

scala> val list = List(List(1,2),List(2,3),List(3,4))
//扁平化
scala> list.flatMap(x=>x.map(y=>y+2))
res27: List[Int] = List(3, 4, 4, 5, 5, 6)

• reduce

scala> val list = List(1,2,3,4,5,6)
list: List[Int] = List(1, 2, 3, 4, 5, 6)

scala> list.reduce((x,y)=>x+y)
res37: Int = 21

scala> list.reduce((x,y)=>{
     | println(x+","+y)
     | x+y
     | })
1,2
3,3
6,4
10,5
15,6
res39: Int = 21

scala> list.reduce(_+_)
res40: Int = 21

伴生类与伴生对象

/**
*
*
*/
object Person extends App {
  def apply: Person = {
    println("object apply....")
    new Person()
  }

  //调用object的apply方法
  Person.apply
  //调用class的apply方法
  new Person().apply
}


class Person {
  def apply: Person = {
    println("class apply.....")
    new Person()
  }
}