Scala初学习笔记

Scala是一门以Java虚拟机（JVM）为运行环境，并将面向对象和函数式编程的最佳特性结合在一起的 静态类型编程语言（静态语言需要提前编译的如：Java、c、c++等，动态语言如：js）。

1）Scala是一门多范式的编程语言，Scala支持面向对象和函数式编程。（多范式，就是多种编程方法的意思。有面向过程、面向对象、泛型、函数式四种程序设计方法。）

2）Scala源代码（.scala）会被编译成Java字节码（.class），然后运行于JVM之上，并可以调用现有的Java类库，实现两种语言的无缝对接。

main方法: 从外部可以直接调用执行的方法

def 方法名称(参数名称: 参数类型)：返回值类型={方法体}

Object: 关键字，声明一个单例对象（伴生对象）

Scala完全面向对象，故Scala去掉了Java中非面向对象的元素，如static关键字，void类型

1）static

Scala无static关键字，由object实现类似静态方法的功能（类名.方法名）。

2）void

对于无返回值的函数，Scala定义其返回值类型为Unit类

（ 1 ）声明变量时，类型可以省略，编译器自动推导，即类型推导

（ 2 ）类型确定后，就不能修改，说明 Scala 是强数据类型语言。

（ 3 ）变量声明时，必须要有初始值

（ 4 ）在声明 / 定义一个变量时，可以使用 var 或者 val 来修饰， var 修饰的变量可改变，

val 修饰的变量不可改。

需要接收用户输入的数据，就可以使用键盘输入语句来获取

StdIn.readLine()、StdIn.readShort()、StdIn.readDouble()

Java内置4个标准函数式接口
Supplier<T> =>T get() 提供者
Consumer<T>=>void accept(T t) 消费者
Function<T,R>=> R apply(T t) 函数
Predicate<T> => boolean

Scala
类型转换
var v:xxx=v.toxxx
控制台输入
val reader=new BufferedReader(new InputStreamReader(System.in))
String value=reader.readline()
//添加必要的验证
if(条件){
var v:xxx=value.toxxx
}

元组
var t1=("henry","peppa","sucy")
print(t1._1) 即可得henry

分支代替三元运算符
var v=if(条件) v1 else v2
var g=1
var g= if(g==0) 'f' else 'm'

值守卫 
_ 下划线表示一个变量的占位符，无须特殊处理
var g=1
var gen=g match {
case 1=> 'm'
case 0=> 'f'
case _=> 'u'
}print(gen)

if守卫
var score=55
var level=score match {
case x if(x>=90)=>'A'
case x if(x>=80)=>'B'
case x if(x>=70)=>'C'
case _=>'D'
}
 print(level)

模式守卫(至少包括一个分组)
    val rPhone="(1[3-9]\\d{9})".r
    val rPid="(\\d{17}[0-9X])".r
    var str="abc@bb.com.co"
    var t=str match{
      case rPhone(p)=>"phone"
      case rPid(p)=>"pid"
      case _=>"UNKNOWN"
    }
    println(t)
 

模式守卫(至少包括一个分组)
    val rPhone="(1[3-9]\\d{9})".r
    val rPid="(\\d{17}[0-9X])".r
    var str="abc@bb.com.co"
    var t=str match{
      case rPhone(p)=>"phone"
      case rPid(p)=>"pid"
      case _=>"UNKNOWN"
    }
    println(t)
 

val r2="^(.*?),(.*?)$".r
val r3="^(.*?);(.*?);(.*?)$".r
var str="beauty,money"
var t:Array[String]=str match {
case r2(a,b)=>Array(a,b)
case r3(a,b,c)=>Array(a,b,c)
case _=>Array()
}
t.foreach(print)

类型守卫
var a:AnyVal=10
var t =a match {
case _:Int=>"int"
case _:Double=>"double"
case _=>"Exception"
} println(t)

sorted对一个集合进行自然排序，通过传递隐式的Ordering，适合单集合的升降序 逆序返回		val xs=Seq(1,5,3,4,6,2) println(xs.sorted.reverse) 输出List(6, 5, 4, 3, 2, 1)
顺序返回		println(xs.sorted) 输出List(1, 2, 3, 4, 5, 6)
sortedBy 对一个属性或多个属性进行排序，通过它的类型，适合对单个或多个属性的排序，代码量比较少，推荐使用这种 逆序返回		println( xs.sortBy(d=>d).reverse) 输出List(6, 5, 4, 3, 2, 1)
顺序返回		println( xs.sortBy(d=>d)) 输出List(1, 2, 3, 4, 5, 6)
Sort with基于函数的排序，通过一个comparator函数，实现自定义排序的逻辑有，适合对单个或多个属性的排序，代码量比较少，推荐使用这种 逆序返回		println( xs.sortWith(_>_) ) 输出List(6, 5, 4, 3, 2, 1)
顺序返回		println( xs.sortWith(_<_)) 输出List(1, 2, 3, 4, 5, 6)
++		合并两个序列(序列为空，必须指定泛型) 若序列类型不同以左边序列类型为主； 若泛型类型不同，以两个序列共同的最小父类为结果类型；
chatAt	def charAt(index: Int): Char -【获取指定索引处的元素（只有Char类型元素才行）】	val a = Array('a','b','c','d') val c=a.charAt(3) print(c) 输出d
apply	def apply(i: Int): Int -【获取指定索引处的元素】	val a = Array(1,2,3,4,5) val c=a.apply(4) print(c) 输出5
aggregate	aggregate是柯里化方法（将原来接受两个参数的函数变成新的接受一个参数的函数的过程。新的函数返回一个以原有第二个参数为参数的函数）， aggregate 方法是一个聚合函数，接受多个输入，并按照一定的规则运算以后输出一个结果值
addString	def addString(b: StringBuilder): StringBuilder -【将数组中元素逐个添加到可变字符串序列b中】	val b=new StringBuilder() val a=Array(1,2,3) val c=a.addString(b)//即a的元素放入b中 println(c) println(b) 输出123  123
array	def array: Array[Int] -【复制数组】	val a = Array(1,2,3,4) val b=a.array print(b.apply(3)) 输出4
copytoArray	def copyToArray[B >: Int](xs: Array[B]): Unit -【将数组中内容逐个拷贝到新数组中】可以指定起始下标引入，选择引入几个元素	val a=Array(1,2,3,4) val b:Array[Int]=new Array(6) a.copyToArray(b) println(b.mkString(""))//输出123400 //a.copyToArray(b,2,2) //b从3位引入a的2个数字 //print(b.mkString(""))//输出001200
copytoBuffer	def copyToBuffer[B >: Int](dest: scala.collection.mutable.Buffer[B]): Unit -【将数组中的内容拷贝到Buffer中】	val a=Array(1,2,3,4) val b:ArrayBuffer[Int] = ArrayBuffer() a.copyToBuffer(b) print(b.mkString("")) 输出1234
canEqual	override def canEqual(that: Any): Boolean -【判断两个对象是否可以进行比较】基本上都可以比较	val a = Array(1,2,3,4) val b=Array('a','b','c') print(a.canEqual(b)) 输出true
clone	override def clone(): Array[Char] -【创建一个副本】 char和int都可以使用	val a = Array(1,2,3,4) val b=a.clone() print(b.apply(3)) 输出4
collect	def collect[B](pf: PartialFunction[A, B]): Array[B] -【通过执行一个并行计算（偏函数fun)得到一个新的数组对象】	val a = Array('a','b','c') val fun:PartialFunction[Char,Char]={ case 'a'=>'A' case 'b'=>'B' case x=>x} print(a.collect(fun).apply(1)) 输出B
collectFirst	def collectFirst[B](pf: PartialFunction[T, B]): Option[B] -【在序列中查找第一个符合偏函数定义的元素，并执行偏函数计算】	val a = Array(12, 'b', 'c') val fun: PartialFunction[Any, Int] = { case x:Int => x+10} print(a.collectFirst(fun).get) 输出22
corresponds	final override def corresponds[B](that: scala.collection.GenSeq[B])(p: (Int, B) => Boolean): Boolean -【判断两个序列长度以及对应位置元素是否全部符合判断条件】	检查 a 和 b、c，d长度是否相等，并且 a 中元素是否都小于 b、c 中对应位置的元素 val a=Array(1,2,3) val b=Array(7,8,9) val c=Array(1,2,4) val d=Array(7,8,9,4) print(a.corresponds(b)(_<_))//true print(a.corresponds(c)(_<_))//false print(a.corresponds(d)(_<_))//false
combinations	def combinations(n: Int): Iterator[Array[String]] -【根据n(几个字符为一组)，进行排列组合】	var a=Array('a','b','c','d') a.combinations(3).foreach( x=>{ x.foreach(print); println } ) 输出abc，abd，acd，bcd var a=Array('a','b','c','d') a.combinations(3).foreach( x=> println( x.mkString(","))) 输出 a,b,c a,b,d a,c,d b,c,d
foreach	遍历序列中的元素	val a = Array(1,2,3,4,5) a.foreach(x=>println(x*10)) 输出10,20,30,40,50 val a = Array(1,2,3,4,5) a.foreach(print) 输出12345
mkString	def mkString: String -【转换成字符串】 mkString(start, sep, end) 将序列中所有元素拼接成一个字符串，以 start 开头，以 sep 作为元素间的分隔符，以 end 结尾)	var a=Array('a','b','c','d') print(a.mkString("")) 输出abcd var a=Array('a','b','c','d') print(a.mkString("!")) 输出a!b!c!d var a=Array('a','b','c','d') print(a.mkString("!",";","?")) !a;b;c;d?
contains	override def contains[A1 >: Int](elem: A1): Boolean -【判断序列中是否包含指定对象】	var a=Array('a','b','c','d') val b=Array('a','b','c') print(a.contains('b')) 输出true var a=Array('a','b','c','d') val b=Array('a','b','c') print(a.contains(b)) 输出false
containsSlice	def containsSlice[B](that: scala.collection.GenSeq[B]): Boolean -【判断当前序列中是否包含另一个序列（数量和顺序相等）】	var a=Array(1,2,3,4) val b=Array(4,2,3,1) print(a.containsSlice(b)) 输出false var a=Array(1,2,3,4) val b=Array(1,2,3) print(a.containsSlice(b)) 输出true
count	def count(p: Int => Boolean): Int -统计符合条件的元素个数	val a=Array(1,2,3) print(a.count(_>2))//输出1，a中>2的数字个数 print(a.count(_>0))//输出3
diff	def diff[B >: Int](that: scala.collection.GenSeq[B]): List[Int] -【获取第一个数组不同于第二个数组的所有元素】	val a=Array(1,2,3) val b=Array(4,5,6) val c=Array(1,2,9) println(a.diff(b).mkString("")) //输出123 println(a.diff(c).mkString(""))//输出3
distinct	def distinct: List[Int] -【去除数组中的重复的元素，只保留一个并返回】	val a=Array(1,2,2,3) println(a.distinct.mkString("")) 输出123
drop	override def drop(n: Int): List[Int] -删除数组中前 n 个元素	val a=Array(1,2,2,3) println(a.drop(2).mkString("")) 输出23
dropRight	override def dropRight(n: Int): List[Int] -删除数组中尾部的 n 个元素	val a=Array(1,2,2,3) println(a.dropRight(3).mkString("") 输出1
dropWhile	final override def dropWhile(p: Int => Boolean): List[Int] -【从当前数组的第一个元素起，判断是否满足指定条件，直到碰到第一个不满足条件的元素结束（即使后面还有符合条件的元素），删除结束前的所有元素	val a=Array(1,2,2,3) val b=a.dropWhile(_>2) println(b.mkString(""))//输出1223 val c=a.dropWhile(_==1) println(c.mkString(""))//输出223 val d=a.dropWhile(_<=2) println(d.mkString(""))//输出3
endsWith	def endsWith[B](that: scala.collection.GenSeq[B]): Boolean -【判断是否以某个序列结尾】	val a=Array(1,2,2,3) val b=Array(2,3) val c=Array(2,4) print(a.endsWith(b))//ture print(a.endsWith(c))//false
exists	override def exists(p: Int => Boolean): Boolean -【判断当前数组是否包含符合条件的元素】	val a=Array(1,2,2,3) print(a.exists(_==1))//true print(a.exists(_>3))//false
filter	def filter(p: Int => Boolean): List[Int] 筛选数组中符合条件的元素	val a=Array(1,2,2,3) println(a.filter(_%2==1).mkString(""))//输出13 println(a.filter(_==2).mkString(""))//输出22
filterNot	与filter相反，将不满足条件的元素筛选出来	val a=Array(1,2,2,3) println(a.filterNot(_%2==1).mkString(""))//输出22 println(a.filterNot(_==2).mkString(""))//输出13
flatMap	def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): Array[B] -【对当前序列的每个元素进行操作，返回的结果放到新数组中】
flatten	def flatten[B](implicit asTraversable: Int => scala.collection.GenTraversableOnce[B]): List[B] -【将二维数组合并成一维数组】	print(a(1)(2))//输出6 print(a.flatten.mkString(""))//输出123456
fold	def fold[A1 >: Int](z: A1)(op: (A1, A1) => A1): A1 从左到右计算，对序列中的每个元素进行二元运算，和 aggregate 有类似的语义，但执行过程有所不同
foldLeft	override def foldLeft[B](z: B)(op: (B, Int) => B): B -【从左到右计算】
foldRight	override def foldRight[B](z: B)(op: (Int, B) => B): B -【从右到左计算】
find	override def find(p: Int => Boolean): Option[Int] -【查找第一个符合条件的元素】	val a=Array(1,2,2,3) println(a.find(_==2).get)//输出2
forall	override def forall(p: Int => Boolean): Boolean -【判断序列中的所有元素是否全部满足条件】	val a = Array(4,5,6) println(a.forall(_<7))//true println(a.forall(_==5))//false
groupBy	def groupBy[K](f: Int => K): scala.collection.immutable.Map[K,List[Int]] -【按条件进行分组，并将元素存放到map映射中】
grouped	def grouped(size: Int): Iterator[List[Int]] -【按指定个数的元素进行分组，并存到序列中】	val a = Array(1,2,3,4,5,6,7,8) a.grouped(3).foreach( x=>{ x.foreach(print); println}) 输出123  456  78

hasDefiniteSize	def hasDefiniteSize: Boolean -【检测数组是否存在有限的长度，对应Stream这样的流数据，返回false】	val a = Array(1,2,3,4,5,6,7,8) print(a.hasDefiniteSize)  //true print(a.toStream.hasDefiniteSize)  //false
toStream	将序列转换成 Stream 类型
head	override def head: Int -【获取数组的首个元素】	val a = Array(1,2,3,4,5,6,7,8) print(a.head) //1
headOption	def headOption: Option[Int] -【返回Option类型对象】	val o=ArrayBuffer() val a = Array(1,2,3,4,5,6,7,8) print(a.headOption.get)//1
indexOf	def indexOf(elem: T): Int -返回元素 elem 在序列中第一次出现的索引，也可以指定索引 （包括）from从左向右开始查找，找不到返回-1；并且指定索引可以超出元素索引的范围	val a = Array(1,2,3,4,5,6,7,8) print(a.indexOf(3))//2 print(a.indexOf(3,0))//2
indexOfSlice	def indexOfSlice[B >: A](that: GenSeq[B]): Int -【检测当前数组中是否包含另一个数组（that），并返回第一个匹配出现的元素的索引】	val a = Array(1,2,3,4,5,6,7,8) val b = Array(3,4,5) print(a.indexOfSlice(b))//2
indexWhere	def indexWhere(p: (T) ⇒ Boolean): Int -【返回当前数组中第一个满足 p 条件的元素的索引】	val a = Array(1, 2, 3, 4, 5, 6, 7, 8) print(a.indexWhere(_%2==0))//1 //从指定索引处开始，返回当前序列中第一个满足 p 条件的元素的索引 print(a.indexWhere(_>2,3))//3
indices	def indices: scala.collection.immutable.Range -【返回序列中每个元素的下标】	val a = Array(1, 2, 3, 4, 5, 6, 7, 8) print(a.indices.mkString(""))//01234567
init	def init: List[Int] -【返回原序列但不包含序列中最后一个元素】	val a = Array(1, 2, 3, 4, 5, 6, 7, 8) print(a.init.mkString(""))//1234567
inits	def inits: Iterator[List[Int]] -对集合中的元素进行 init 迭代操作，该操作的返回值中， 第一个值是当前序列的副本，最后一个值为空，每一步都进行 init 操作，上一步的结果作为下一步的操作对象	val a = Array(1, 2, 3, 4, 5, 6, 7, 8) a.inits.foreach(x=>{x.foreach(print);println}) 12345678 1234567 123456 12345 1234 123 12 1
intersect	def intersect[B >: Int](that: scala.collection.GenSeq[B]): List[Int] -【求两个数组的交集】	val a = Array(1, 2, 3, 4, 5, 6, 7, 8) val b = Array(0,3,5) println(a.intersect(b).mkString(""))//35
isDefinedAt	override def isDefinedAt(x: Int): Boolean -【判断序列中是否存在指定索引】	val a = Array(1, 2, 3, 4, 5, 6, 7, 8) println(a.isDefinedAt(3))//true println(a.isDefinedAt(10))//false
isEmpty	override def isEmpty: Boolean -【判断序列是否为空】	val a = Array(1, 2, 3, 4, 5, 6, 7, 8) println(a.isEmpty)//false val b = new ArrayBuffer() println(b.isEmpty)//true
isTraversableAgain	final def isTraversableAgain: Boolean -判断序列是否可以反复遍历，该方法是 GenTraversableOnce 中的方法，对于 Traversables 一般返回 true，对于 Iterators 返回 false，除非被复写	val a = Array(1, 2, 3, 4, 5, 6, 7, 8) println(a.isTraversableAgain)//true println(a.inits.isTraversableAgain)//false
iterator	override def iterator: Iterator[Int] -生成当前序列的迭代器	val a = Array(1, 2, 3, 4, 5, 6, 7, 8) a.iterator.foreach(println) 换行输出12345678
last	def last: T -【返回数组中最后一个元素】	val a = Array(1, 2, 3, 4, 5, 6, 7, 8) print(a.last)//8
lastIndexOf	def lastIndexOf(elem: T): Int -【返回数组中最后一个等于elem的元素索引】往左向右到指定索引遍历查找	val a = Array(1, 2, 3, 4, 5, 6, 7, 8) print(a.lastIndexOf(2))//1 //在指定索引end前，返回数组中最后一个等于elem的元素索引 print(a.lastIndexOf(4,4))//3