本文共 6936 字，大约阅读时间需要 23 分钟。

一.Scala概述

1.特性

面向对象特性

• 每个值都是对象
• 对象的数据类型和行为由类（Class）和特征（Trait，类似于interface）描述
• 利用特征实现混入式多重继承

函数式编程

• 每个函数都是一个值
• 支持高阶函数、柯里化(currying)、样例类（case class）及模式匹配……

Scala是静态类型语言

扩展性：隐式类、字符串插值

2.Scala变量与常量

变量

• 赋值后可以改变，生命周期中可以被多次赋值

var 变量名称:类型=xxx一般无需显示指定类型，Scala编译器会自动推断出类型

常量

• 赋值后不可变，类似于Java中的final变量

val 常量名称:类型=xxx

使用类型别名定义变量,相当于

• type关键字:type 类型别名=类型

Scala关键字列表

Scala数据类型

• Scala与Java有着相同的原始数据类型

数据类型	描述
Byte	8位有符号整数。数值区间-128 ~ 127
Short	16位有符号整数。数值区间-32768 ~ 32767
Int	32位有符号整数。数值区间 -2147483648 ~ 2147483647
Long	64位有符号整数。 -9223372036854775808 ~ 9223372036854775807
Float	32位IEEE 754 单精度浮点数
Double	64位IEEE 754 双精度浮点数
Char	16位无符号Unicode字符。区间值为U+0000 ~ U+FFFF
Boolean	true或false
String	等于java.lang.String

Scala数据类型层次结构

• Any：所有类型的超类（顶级类型）
• AnyVal：表示值类型的超类
• AnyRef：表示引用类型的超类，对应java.lang.Object
• Unit：表示无值，类似Java中的void
• Nothing：所有类型的子类
• Null：表示null或空引用 null是Null的唯一实例

字符串插值

s插值器：允许将变量引用、表达式直接插入字面字符中

val name="James"println(s"Hello,$name")	//Hello,Jamesprintln(s"1+1=${1+1}") 	//1+1=2

f插值器

val height=1.9dval name="James"println(f"$name%s is $height%2.2f meters tall")

raw插值器

s"a\nb"		//将输出换行符raw"a\nb"		//输出原始字符

二.Scala流程控制语句

1.if

• if语句

val x=10if(x>0){
       print("x大于0")}

• if…else语句

val x=10if(x>10){
       print("x大于10")}else{
       print("x小于等于10")}

val x=10if(x>10){
       print("x大于10")}else if(x==10){
       print("x等于10")}else{
   print("x小于10")}

• 条件语句返回值
  Scala任何表达式都有返回值

val x=10val y=if(x==10) x+1 else x	//单行表达式可以省略{}//y=?

• 代码块“{…}”也是表达式，返回值为最后一个表达式结果

val x=10val y={
      print("我是代码块")   x+1}//y=11

val x=10val y={
       x+1;print("我是代码块")}//多个表达式使用“;”分隔//y=?

2.Scala循环控制

2.1while循环

//Scala中可以不用在语句结束位置显示地使用分号(;)var num: Int = 0;while ( num < 100 ) {
       println( num );    num = num + 1;}

var num: Int = 0;do {
       println( num );      num = num + 5;} while ( num < 200 }

2.2for循环

//“i to j"或者"i until j"均表示创建一个区间Range to取得到二until取不到 即to是双闭区间,until是左闭右开val num:Int = 10;for ( i: Int <- 1 to num ) {
            println( i * 100 );}

for {
    i: Int <- 1 until 100 }{
       val y = 2*i;    println( y );}

2.3中断

import scala.util.control.Breaks._val num:Int = 10;for ( i: Int <- 1 to num by 2 ) {
       if(i>=5) break;  //省略了循环外的breakable()和Java中的break相同 如果想使用java中的continue必须在循环内使用breakable( ... break )    println( i * 100 );}

2.4for循环过滤

val num:Int = 10;for ( i: Int <- 1 to num; if i%2==0;if i>5 ) //多个条件时使用分号(;){
            println( i * 100 );}

2.5for循环返回值

• for 循环中的 yield 会把当前的元素记下来，保存在集合中，循环结束后将返回该集合。也称for推导式

//for循环使用yield将具有返回值val num:Int = 10;var retVal=for ( i: Int <- 1 to num; if i%2==0;if i>5 ) yield i;for(a<-retVal){
       println(a);}//输出6 8 10

练习1.需求说明使用Scala编程输出如图所示加法表

package com.sunyongobject practice01 {
     def main(args: Array[String]): Unit = {
       for (i:Int<- 0 to 6){
         println(s"$i+${6-i}=6")    }  }}

三.Scala数组,元组,集合

1.Scala数组

• 存储固定大小的元素
• 数组索引从0开始

//数组创建方式一var a1:Array[String] = new Array[String](3) //泛型使用方括号a1(0)="Jason" //数组元素访问使用圆括号a1(1)="Marie"a1(2)="Jimmy"//数组创建方式二var a2=Array("Jason","Marie","Jimmy") //调用Array的伴生对象中的apply()返回Array实例,相当于构造//数据创建方式三：区间数组var a3=Array.range(1,10,2)

2.Scala元组

• 可以包含不同类型的元素
• 最多支持22个元素 （Tuple1~Tuple22）
• 使用下划线“_"访问元素，“_1"表示第一个元素

//元组声明方式一var tp1 = ("Mike", "123 ABC street", 58)println(tp1._1)println(tp1._2)println(tp1._3)//迭代元组tp1.productIterator.foreach{
    i =>println("Value = " + i )}//元组声明方式二var tp2 = new Tuple3("Mike", "123 ABC street", 58)//元组声明方式三def mike = "Mike" -> 5//输出scala.Tuple2mike.getClass//将元组元素依次赋给三个变量val(name, address, age) = tp1println(name)println(address)println(age)

3.Scala集合

• Seq:序列，元素按顺序排列
• Set:集合，元素不重复
• Map:映射，键值对集合
  

不可变集合

• scala.collection.immutable，默认Scala选择不可变集合

• 1.Set：ListSet、HashSet、TreeSet

• 2.Map：ListMap、HashMap、TreeMap

• 3.Seq：Vector、String、Range、List、Stack、Stream、Queue

  
  可变集合：可以修改、添加或移除一个集合的元素

• scala.collection.mutable

  
  常用集合

名称	可变/不可变	示例
Buffer	mutable	val buffer = scala.collection.mutable.ArrayBuffer[Int](10, 20, 30); buffer+=(2,3)
Array	mutable	val arr=Array(1,2,3)
List	immutable	val lst=List(1,2,3)
Map	mutable	val stu= Map(“name” -> “Jason”, “age” -> “18”)
Set	mutable/immutable	val set=Set(1,2,3)
Vector	immutable	val v=Vector(1, 3, 5, 7, 11, 13)
Stack	mutable/immutable	val st=scala.collection.mutable.Stack(1,2,3) //堆栈，先进后出
Queue	mutable/immutable	val q=scala.collection.mutable.Queue(1,2,3) //队列，先进先出
BitSet	mutable/immutable	val bit=scala.collection.mutable.BitSet(3,2,0) //位集合
ListMap	immutable	val map = scala.collection.immutable.ListMap(1->“one”, 2->“two”)
HashSet	mutable	val set= scala.collection.mutable.HashSet(1,2,3)
HashMap	mutable	val stu= scala.collection.mutable.HashMap(“name” -> “Jason”, “age” -> “18”)

Scala List常用操作

var c = List[Char]('a', 'b', 'c')var x = 'x' +: c    // (x, a, b, c)var y = c :+ 'x'   // (a, b, c, x)import scala.collection.mutable._var lb = ListBuffer[Int](1, 2, 3, 4)lb += 100    //1, 2, 3, 4, 100lb += (21, 33)//    88 +=: lb   //88, 1, 2, 3, 4, 100, 21, 33List(77, 66) ++=: lb

var l = List[Int](2, 3, 4, 6, 8, 9, 11, 20)var x = l grouped 3   //等价l.grouped(3)x.next()    //(2, 3, 4)x.next()   //(6, 8, 9) var y = l sliding 2y.next()  // (2, 3)y.next()  // (3, 4)

var a1 = Array[Int](1, 2, 3, 4)var a2 = Array[Int](100, 200, 300, 400)var a = List.concat(a1, a2)//Array->Lista3=a1++a2  //Arrays->Arraya(3) = 333    //Errora3(3)=333    //OKvar b = Array(333, "333", '3', false )var c = List.concat(a, b)  val x = a.filter( _ %2 != 0 )val y = a.reverse var m = a.groupBy(t => t%2 == 0)var n = a.slice(2, 4)a.sorted   //1, 2, 3, 4, 100, 200, 300, 400a.sorted( Ordering.Int.reverse )a.sortWith( _ > _ )a.sortBy( x => x )   //升序a.sortBy( x => x*(-1) )   //降序

Scala Set常用操作

var s = Set("ab", "yz")s += "mn"    //mn, ab, yzs += "mn"    //??s -= "yz"       //mn, abvar t = Set("ab", "gh", "mn", "st", "yz" )t -- s       //gh, st, yz   t ++ s    //ab, gh, mn, st, yavar os = SortedSet(1, 99, 66, 54, 77 )os  //1, 54, 66, 77, 99os += 33os  //1, 33, 54, 66, 7

var s = Set("ab", "yz")var t = Set("ab", "gh", "mn", "st", "yz" )//求交集t & s       t intersect s//求并集t | st union s//求差集t &~ st diff s

Scala Map常用操作

var m = Map[String, Int]("a"->1, "b"->2, "c"->3, "d"->4, "e"->5, "f"->6, "g"->7, "h"->8, "i"->9)m("a")        //1m += ("j"->0)m += ("j"->0)   //??m += ("j"->11)   //??var n = m ++ Map[String, Int]("a"->3, "j"->99)    //??n -= ("g", "e")

4.Scala Stream & Vector

• Stream是List惰性版

val stream = (1 to 1000).toStreamstream     // Stream(1, ?)stream.head // 1stream.tail  // Stream(2, ?)stream(3)stream.tail  // Stream(2,3,4,?)

• Vector拥有连续的内存空间，利于随机存取（直接访问）

val v = Vector.empty :+ 2 :+ 2val v1 = v ++ Vector[Int](3)v.lengthv1.length

• 练习2：列表分组排序
• 需求说明:请将下列同学分为2组，依次每3人一组，组内按名排序“Jason，Vince，Dwan，Lynn，Stephon”

package com.sunyongimport scala.collection.mutableimport scala.collection.mutable.ListBuffer//需求说明:请将下列同学分为2组，依次每3人一组，组内按名排序“Jason，Vince，Dwan，Lynn，Stephon”object practice02 {
     def main(args: Array[String]): Unit = {
     var l = List[String]("Jason","Vince","Dwan","Lymn","Stephon")  var x = l.grouped(3) //三人一组   println(x.next().sorted) //输出 排序   println(x.next().sorted)  }}

转载地址：http://qcjxi.baihongyu.com/