注： --------scala 中的任何数据都是对象
--------Scala 可以对数据类型进行自动推导，所以定义变量时可省去数据类型
==> 数据类型
--> 数值类型
--- Byte 8位
--- Short 16 位
--- Int 32 位
--- long 64位
--> 字符和字符串类型
--- Char
--- String
--> Unit 类型 相当于 Java 的 void
--> Nothing 类型 般表示运行过程中出现了 Exception
==> 定义变量
--> 格式： var | val 变量名：类型 = 内容
--> var 定义值可变的变量
计算
安全
数据库
网络和加速
企业服务
var a = "hello" // var a:String = "hello"
var b = 12345 // var b: Int = 12345--> val 定义值不可变的常量
val a = "word"==> 函数
--> 格式： def 函数名（变量名：类型 | 变量名：=> 类型）: 函数返回值类型 = {}
--> 函数参数：
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
--- 代名参数 :
def func2(str: String="My name", name: String="Marry", age: Int=18): String = {
str + " is " + name + ", I'm " + age + "啦！"
}
func2(name="Tom")
func2()--- 可变参数 : 求多个数字的和
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{……} 捕获和处理异常
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， 表示在函数执行过程中产生异常
def func1() = throw new IllegalArgumentException("Some Error Happened")--> if else 语句，如果在一个分支中产生了异常，则另一个分支的返回值，将作为if else 返回值的类型
val x = 10
if(x >= 0){
scala.math.sqrt(x)
}else{
throw new IllegalArgumentException("The value should be not")
}==> 数组
--> 定长数组：使用关键字 Array
val a = new Array[Int](10)
val str = new Array[String](5)
val demo_list = Array("Tom", "Marry", "Mike")--> 变长数组：使用关键字 ArrayBuffer
val list1 = ArrayBuffer[Int]()
// 向数组中插入元素
list1 += 1
list1 += 5
// 向数组中插入多个元素
list1 += (20, 55, 47)
// 去掉最后三个值
list1.trimEnd(3)
// 将 ArrayBuffer 转换为 Array
list1.toArray--> 遍历数组
// 创建数组
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) --> 数组常用操作
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 组成的集合
--> 使用 -> 符号创建
val demoMap = Map("Tom" -> 11, "Marry" -> 44)--> 不可变 Map
val testMap = scala.collection.immutable.Map("Tom" -> 20, "Marry" -> 18)--> 可变 Map
val testMap = scala.collection.mutable.Map("Tom" -> 20, "Marry" -> 18)
val testMap1 = scala.collection.mutable.Map(("Tom", 20),("Marry", 18))--> 映射操作
// 获取映射中的值，如果不存在，会抛出 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 名称+个数 = （元素，元素）
val tu1 = (1, 2, 3)
val tu2 = new Tuple2("hello", "world") --> 访问元组中的元素
tu1._1 //点后面跟的是第几个元素
1 --> 遍历元组,使用foreach 遍历元组，注意，元组遍历前首先需要生成对应的迭代器，不能直接使用for 或者 foreach 进行遍历
tu1.productIterator.foreach(println)亿速云「云服务器」，即开即用、新一代英特尔至强铂金CPU、三副本存储NVMe SSD云盘，价格低至29元/月。点击查看>>
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。
