注: --------scala 中的任何数据都是对象
--------Scala 可以对数据类型进行自动推导,所以定义变量时可省去数据类型
==> 数据类型
--> 数值类型
--- Byte 8位
--- Short 16 位
--- Int 32 位
--- long 64位
--> 字符和字符串类型
--- Char
--- String
--> Unit 类型 相当于 Java 的 void
--> Nothing 类型 般表示运行过程中出现了 Exception
==> 定义变量
--> 格式: var | val 变量名:类型 = 内容
--> var 定义值可变的变量
1
2
|
var
a
=
"hello"
// var a:String = "hello"
var
b
=
12345
// var b: Int = 12345
|
--> val 定义值不可变的常量
1
|
val
a
=
"word"
|
==> 函数
--> 格式: def 函数名(变量名:类型 | 变量名:=> 类型): 函数返回值类型 = {}
--> 函数参数:
--- call by value : def demo(x:Int, y: Int): Int = x + x 对函数的实参求值
demo(3+4, 8)
计算过程:
7 + (3+4)
7 + 7
14
--- call by name : def demo(x: => Int, y: => Int): Int = x + x 函数的实参每次在函数体内部被调用的时候都会求值
demo(3+4, 8)
计算过程:
7 + 7
14
--- 默认参数: def func1(name: String = "Tom"): String = "Hello" + name
--- 代名参数 :
1
2
3
4
5
6
|
def
func
2
(str
:
String
=
"My name"
, name
:
String
=
"Marry"
, age
:
Int
=
18
)
:
String
=
{
str +
" is "
+ name +
", I'm "
+ age +
"啦!"
}
func
2
(name
=
"Tom"
)
func
2
()
|
--- 可变参数 : 求多个数字的和
1
2
3
4
5
6
7
8
|
def
sum(args
:
Int*)
=
{
var
result
=
0
for
(arg <- args)
result +
=
arg
result
}
sum(
1
,
2
,
3
)
|
==> 懒值(lazy): 如果一个变量是 lazy , 他的初始化会被推迟,直到第一次使用它的时候才会执行
--> 正常的变量定义后会直接赋给变量,如:
var a = "hello"
定义变量后会返回: a : String = "hello"
--> 使用 lazy 定义变量时,不会执行,只有在第一次执行的时候才会执行赋值操作,如:
lazy var a = "hello"
定义变量后返回: a: String = <lazy>
只有使用变量时,才会进行赋值操作:
a
String = "hello"
==> 异常: 异常的处理机制是什么? 向上处理
-->采用 try{ …… }catch{ …… }finally{……} 捕获和处理异常
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
try
{
val
words
=
scala.io.Source.fromFile(
"d:\\demo\\a.txt"
).mkString
}
catch
{
case
ex
:
java.io.FileNotFoundException
=
> {
println(
"File Not Found!!!"
)
}
case
ex
:
IllegalArgumentException
=
> {
println(
"Illegal Argument Exception!!!"
)
}
case
_:
Exception
=
> {
println(
"othe Exception"
)
}
}
finally
{
println(
"finally block"
)
}
|
--> 如果一个函数的返回类型是Nothing, 表示在函数执行过程中产生异常
1
|
def
func
1
()
=
throw
new
IllegalArgumentException(
"Some Error Happened"
)
|
--> if else 语句,如果在一个分支中产生了异常,则另一个分支的返回值,将作为if else 返回值的类型
1
2
3
4
5
6
|
val
x
=
10
if
(x >
=
0
){
scala.math.sqrt(x)
}
else
{
throw
new
IllegalArgumentException(
"The value should be not"
)
}
|
==> 数组
--> 定长数组:使用关键字 Array
1
2
3
|
val
a
=
new
Array[Int](
10
)
val
str
=
new
Array[String](
5
)
val
demo
_
list
=
Array(
"Tom"
,
"Marry"
,
"Mike"
)
|
--> 变长数组:使用关键字 ArrayBuffer
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
val
list
1
=
ArrayBuffer[Int]()
// 向数组中插入元素
list
1
+
=
1
list
1
+
=
5
// 向数组中插入多个元素
list
1
+
=
(
20
,
55
,
47
)
// 去掉最后三个值
list
1
.trimEnd(
3
)
// 将 ArrayBuffer 转换为 Array
list
1
.toArray
|
--> 遍历数组
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
// 创建数组
var
names
=
Array(
"Tom"
,
"Marry"
,
"Linda"
)
// 使用 for 循环遍历
for
(name <- names)
println(name)
// 使用 foreach 遍历
names.foreach(println)
// 对数组进行转换,生成一个新的数组
val
newnames
=
for
{
name <- names
new
=
name.toUpperCase
}yeild(
new
)
|
--> 数组常用操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
import
scala.collection.mutable.ArrayBuffer
val
demoArray
=
Array(
6
,
8
,
4
,,
5
,
2
,
6
,
5
,
4
)
// 最大值
demoArray.max
// 最小值
demoArray.min
// 求和
demoArray.sum
// 定义一个变长数组
demoArrayBuffer
=
ArrayBuffer(
5
,
3
,
5
,
7
,
8
,
7
,
9
,
5
,
74
)
// 降序排序
demoArrayBuffer.sortWith(
_
>
_
)
// 升序排序
demoArrayBuffer.sortWith(
_
<
_
)
|
==> 映射: 一个由 key, value 组成的集合
--> 使用 -> 符号创建
1
|
val
demoMap
=
Map(
"Tom"
->
11
,
"Marry"
->
44
)
|
--> 不可变 Map
1
|
val
testMap
=
scala.collection.immutable.Map(
"Tom"
->
20
,
"Marry"
->
18
)
|
--> 可变 Map
1
2
|
val
testMap
=
scala.collection.mutable.Map(
"Tom"
->
20
,
"Marry"
->
18
)
val
testMap
1
=
scala.collection.mutable.Map((
"Tom"
,
20
),(
"Marry"
,
18
))
|
--> 映射操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
// 获取映射中的值,如果不存在,会抛出 Exception
testMap(
"Tom"
)
// 可通过 Map.constains 事先判断数据是否存在,然后再取值
if
(testMap.contains(
"Tom"
)){
testMap(
"Tom"
)
}
else
{
-
1
}
// 简写
testMap.getOrElse(
"Tom"
, -
1
)
// 更新值
testMap(
"Tom"
)
=
25
// 添加新元素
testMap +
=
"lily"
->
18
// 移除元素
testMap -
=
"Tom"
// 迭代,使用 for,或者 foreach
for
(m <- testMap)println(m)
testMap.foreach(println)
|
==> 元组: 不同类型的值的聚集
--> 创建元组: val 名称+个数 = (元素,元素)
1
2
|
val
tu
1
=
(
1
,
2
,
3
)
val
tu
2
=
new
Tuple
2
(
"hello"
,
"world"
)
|
--> 访问元组中的元素
1
2
|
tu
1
.
_
1
//点后面跟的是第几个元素
1
|
--> 遍历元组,使用foreach 遍历元组,注意,元组遍历前首先需要生成对应的迭代器,不能直接使用for 或者 foreach 进行遍历
1
|
tu
1
.productIterator.foreach(println)
|