注： --------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)