注: --------scala 中的任何数据都是对象

        --------Scala 可以对数据类型进行自动推导,所以定义变量时可省去数据类型

==> 数据类型

        --> 数值类型

            --- Byte        8位

            --- Short        16 位

            --- Int            32 位

            --- long            64位

        --> 字符和字符串类型

            --- Char        

            --- String

        --> Unit 类型   相当于 Java 的 void


        --> Nothing 类型    般表示运行过程中出现了 Exception 


==> 定义变量

        --> 格式: var | val   变量名:类型 = 内容

        --> var 定义值可变的变量

1
2
var  =  "hello"         // var a:String = "hello"
var  =  12345             // var b: Int = 12345

        --> val 定义值不可变的常量

1
val  =  "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  =  10
if (x > =  0 ){
     scala.math.sqrt(x)
} else {
     throw  new  IllegalArgumentException( "The value should be not" )
}


==> 数组

        --> 定长数组:使用关键字 Array

1
2
3
val  =  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)