本文介绍Scala编程语言的基础知识，包括Scala的特性、安装配置、数据类型、变量与常量、函数定义与使用、条件判断与循环控制、异常处理、集合操作等内容。
Scala编程语言（看成：Java的升级版） API:http://www.scala-lang.org/files/archive/api/2.11.8/#package
第一章：Scala语言基础
1、简介Scala：是一种多范式的编程语言
（*）面向对象
（*）函数式编程：Scala的最大特点
（*）基于JVM
2、安装和配置、运行环境
（*）前提：先安装JDK
（*）安装Scala：下载 http://www.scala-lang.org/download/
注意：版本跟Spark的Scala版本一致
scala-2.11.8.zip
（*）设置变量 ---> 跟Java完全一样
(*) SCALA_HOME
(*) 把 %SCALA_HOME%/bin ====> PATH路径
（*）Scala的运行环境（开发工具）
（1）命令行：REPL
进入: scala
退出：:quit
(*) paste 模式: 相当于vi编辑器
进入： :paste
退出: ctrl+D
（2）IDEA
(*) 默认：没有Scala的环境
(*) 需要安装插件：SBT（需要联网，有点慢）
（3）Scala IDE：基于Eclipse
3、数据的类型:基本数据类型
注意：（*）在Scala中，任何数据都是对象
举例：1 是一个对象，就有方法（函数）
scala> 1.toString
res0: String = 1 ====> 定义一个新的变量 res0；类型：String
（*）在定义变量的时候，可以不指定类型
Scala会自动进行类型的推导
以下两句话等价
val a:Int = 10
val b = 10
（1）数值类型: Byte、Short、Int Long Float Double
复习：Byte：8位的有符号数字 -128 ~ 127
Short: 16的有符号数字 -32768 ~ 32767
Int 32位
Long 64位
（2）字符串：字符和字符串 Char String
（*）在Scala中，对字符串有一个特殊操作：插值操作 ---> 前面有一个s
val s1="Hello World"
在下面的字符串中引用上面的s1
s"My name is ${s1}"
（3）Unit类型: 相当于Java中void
举例：val f = () 相当于我们定义了一个函数，并且把该函数的值付给一个变量f来保存
（4）Nothing类型: 一般来说，表示在执行的过程中产生了Exception
举例：定义函数 def
def myfunction = throw new Exception("Some Error....")
4、变量和常量
（*）val和var定义
（*） val 常量
var 变量
5、函数（重要）：头等公民
（1）内置函数
举例：求最大值 max函数
max(10,20)
（2）自定义函数: 关键字def
举例： 求和
def sum(x:Int,y:Int):Int = x + y
也等价于下面的语句
def sum(x:Int,y:Int):Int = {
x+y
}
注意：返回值不写return关键字，因为Scala中，函数的最后一句话就是函数的返回值
复杂一点的例子：求数的阶乘（递归）//定义函数求数的阶乘
def myFactor(x:Int):Int = {
if(x <= 1)
1
else
x * myFactor(x-1)
}
//调用
myFactor(5) 6、条件判断: 在Scala中，if...else 是一个表达式，就有表达式的值
循环: for、while、do..while
还可以使用foreach进行迭代
//循环 for
//定义一个集合
var list = List("Mary","Tom","Mike")
println("*****第一种写法*****")
for(s <- list) println(s)
println("*****第二种写法*****")
//打印长度大于3的
for{
s <- list
if(s.length > 3)
}println(s)
println("*****第三种写法*****")
for(s<-list if s.length <= 3) println(s)
//在for循环中，还可以使用关键字: yield 来产生一个新的集合
//把人名改成大写，并生产一个新的List
println("*****第四种写法*****")
var newList = for{
s <- list
s1 = s.toUpperCase
}yield(s1)
//使用while 和 do while循环
var list = List("Mary","Tom","Mike")
println("*********** while 循环***********")
var i = 0
while(i < list.length){
println(list(i)) //这里是小括号
i += 1
}
println("*********** do while 循环***********")
7、函数的参数： 函数参数值的求值策略（call by value、 call by name）
（1）函数参数值的求值策略、
call by value：对函数的实参求值，仅求一次
举例：使用 :
def test1(x:Int,y:Int):Int = x + x
调用: test1(3+4,8)
call by name：函数的实参每次在函数体内部被调用到的时候 都会求值
举例：使用 : =>
def test2(x: => Int,y: => Int):Int = x + x
调用: test2(3+4,8)
注意：执行的过程是不一样的
稍微复杂一点的例子：
x是call by value，y是call by name(用到的时候才去算)
def bar(x:Int,y: => Int):Int = 1
定义一个死循环
def loop():Int = loop
调用：输出是什么？
bar(1,loop)
bar(loop,1)
（2）函数的参数
（*）默认参数
def func1(name:String="Tom"):String = "Hello " + name
调用
func1()
（*）代名参数
def func2(str:String="Good Morning ", name:String="Tom",age:Int=20):String
=
str + name + " and the age of " + name + " is " + age
调用
func2()
func2(age=25)
（*）可变参数: 求多个数字的和
scala> def sum(args:Int*) = {
| var result = 0
| for(arg <- args) result += arg
| result
| }
sum: (args: Int*)Int
scala> sum(1,2,3)
res5: Int = 6
scala> sum(1,2,3,4,5,6,7)
res6: Int = 28
8、懒值（lazy值）：如果一个变量是lazy，他的初始化会被推迟，直到第一次使用他的时候
举例：
scala> val x:Int =10
x: Int = 10
scala> val y:Int = x + 10
y: Int = 20
scala> lazy val z:Int = x + 10
z: Int = <lazy>
scala> z
res7: Int = 20
复杂一点的例子：读一个文件（存在的、不存在的）
scala> val words = scala.io.Source.fromFile("d:\\temp\\a.txt").mkString
words: String = Hello Scala,I love Scala
scala> lazy val words1 = scala.io.Source.fromFile("d:\\temp\\a.txt").mkString
words1: String = <lazy>
scala> words1
res8: String = Hello Scala,I love Scala
scala> lazy val words2 = scala.io.Source.fromFile("d:\\temp\\b.txt").mkString
words2: String = <lazy>
9、异常Exception：类似Java
也是使用throw 抛出异常
问题：Java（Scala）异常处理机制是什么？---> 向上处理机制
//使用try catch finally 捕获异常
try{
val words = scala.io.Source.fromFile("d:\\temp\\a.txt").mkString
}catch {
case ex:java.io.FileNotFoundException => {
println("File Not Found")
}
case IllegalArgumentException => {
println("Illegal Argument Exception")
}
case _:Exception => {
println("Other Exception")
}
}finally{
println("Finally Block")
}
10、数组、映射、元组 ---> 数据的集合
（*）数组
二维数组：通过数组的数组来实现
（*）映射：就是一个<key,value>的Map集合
（*）元组: Tuple
（*）是不同类型的值的集合
val a1 = (1,2,3,"Hello") ===> 类型：Tuple4[Int, Int, Int, String]
val a2 = new Tuple4(1,2,3,"Hello")
使用 _下划线来引用元组中的元素
a2._1
a2._2
a2._3
a2._4
遍历元组: 首先需要得到元组的迭代器
a2.productIterator.foreach(println)
import scala.collection.mutable.ArrayBuffer
//Scala数组
//类型一：定长数组 Array
val a = new Array[Int](10)
val b = new Array[String](3)
var c = Array("Tom","Mary","Mike")
//类型二：变长数组 ArrayBuffer
val d = new ArrayBuffer[Int]()
//往变长数组中添加元素
d += 1
d += 2
d += 3
d += 4
//一次添加多个元素
d += (10,20,30)
d.trimEnd(2) //去掉尾部的两个元素
//把ArrayBuffer --> Array
d.toArray
//遍历数组
//foreach 没有返回值；map有一个返回值
d.foreach(println)
d.map(println)
//常见的数组的操作
val myArray = Array(1,100,10,24,5,57)
//最大、最小、求和
myArray.max
myArray.min
myArray.sum
//排序: 以下两个排序是一样
myArray.sortWith(_ > _)
//完整一点
myArray.sortWith((a,b)=>{
if(a > b)
true
else
false
})
//映射：就是一个<key,value>的Map集合
//类型一：不可变映射Map
val scores=Map("Tom"->80,"Mary"->90,"Mike"->85)
//类型二：可变映射Map
val chinese = scala.collection.mutable.Map("Tom"->80,"Mary"->90,"Mike"->85)
//1、获取值
chinese("Mary")
//2、判断某个key是否存在
if(chinese.contains("Mary")){
chinese("Mary")
}else{
-1
}
//可以简写
chinese.getOrElse("Mary",-1)
//3、更新Map中的值，必须是可变的映射
chinese("Mary") = 100
//4、添加新的元素
chinese += "Bob" -> 88
//5、删除元素
chinese -= "Bob"
for(s <- chinese) println(s)
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
