scala基础学习

1. )

Scala概述

1.函数式编程语言，同时具有面向对象的特点

将复杂的问题的解决方法差分为若干个函数进行处理。
相对于面向对象编程，更加的抽象，好处是：代码更加简洁

​ 更多的采用常量而不是变量来解决问题，在线程并发时， 可以减少甚至杜绝 ，多线程并发安全问题，特别***适合于应用在处理高并发场景， 分布式场景下的问题***

2.Scala基本语法

常量和变量 - 优先使用常量

和java中的概念相同
			变量：可以在程序执行过程中进行修改
			常量：一旦被赋值就不能再进行更改了

1.变量声明
var str1:String = "abc";
var str2 = "def";
str2 = "xyz";

2.常量声明
val str3:String = "abc";
val str4 = "def";
//str4 = "xyz";//报错

数据类型

scala中的数据类型分为基本数据类型 和 复杂数据类型
基本数据类型共有9种
​ Byte Short Int Long Float Double Char Boolean String
三引号：比起双引号，省去了转义的过程（String内容）

富包装器

scala还提供了它们的富包装器类型，这9种基本数据类型可以在必要时自动的转换为其对应的富包装器类型，使用更多的属性和方法，这个过程就是自动的封箱拆箱的过程。

scala.runtime.RichByte	scala.runtime.RichShort	scala.runtime.RichInt
scala.runtime.RichLong	scala.runtime.RichChar	scala.runtime.RichString
scala.runtime.RichFloat	scala.runtime.RichDouble	scala.runtime.RichBoolean

操作符

scala中没有真正意义上的操作符，操作符即方法，方法即操作符

a. 操作符即方法

val num1 = 3 + 2;
val num2 = 3.+(2);	//num1 == num2
println(num1)
println(num2)
val num3 = 3 * 2;
val num4 = 3.*(2);
println(num3)
println(num4)			//num3 == num4

b. 方法即操作符

val str1 = "abcdefg";
val c1 = str1.charAt(2);
val c2 = str1 charAt 2;			//c1 ==  c2
println(c1)
println(c2)					
 
val str2 = "abcdefghijklmn"
val r1 = str2.substring(2, 5);
val r2 = str2 substring (2,5)	//r1 == r2
println(r1)
println(r2)
 
val str3 = "abcdefg";
val r3 = str3.toUpperCase();
val r4 = str3 toUpperCase;		//r3 == r4
println(r3)
println(r4)

c. scala中操作符(函数)的优先级

优先级
\ * / %
​ ±
​ :
​ =!
​ <>
​ &
​ ^
​
​ 所有字母
​ 所有赋值操作符

d. 特殊运算符 冒号 的用法

scala中以 冒号结尾的方法 是一种特殊的函数，不同于普通的函数 由左操作数调用传入右操作数，这种方法 是 右操作数调用传入左操作数。

a +: b ==> b.:+(a)

e. 操作符类型

i. 中缀操作符
			中缀操作符 指操作符在两个操作数之间。
			3.+(2) --> 3 + 2

ii. 后缀操作符
			后缀操作符 指 操作符在唯一的操作数之后
			str1 toUpperCase --> str1.toUpperCase();

iii. 前缀操作符
			前缀操作符 指 操作符在唯一的操作数之前 
			前缀操作符只有四种 + - ! ~
			前缀操作符特殊的地方在于，转换为方法时，不能直接转,而要转换为 unary_符号 形式
					    val n1 = -3; -->  val n1 = 3.unary_-
					    val n2 = +5; -->  val n2 = 5.unary_+

3.内建控制结构

函数编程风格

在函数式编程中，要求函数式一个封底、独立、稳定的，执行代码块

if判断

scala中的if可以带有返回值

val num = 99;
val r1 = if(num<10){
   "哈哈"
}else if(num<100){
    "呵呵"
}else{
    "嘻嘻"
}
println(r1)   //呵呵

while do…while 循环

 var i = 0;
var sum = 0;
while(i <= 10){
  sum += i;
  i += 1;
}
print(sum)

推荐 使用递归 来实现循环。
​

def mx(i:Int,sum:Int):Int = {
        if(i>10) return sum;
        else mx(i+1,sum + i);
}
var r = mx(0,0)
println(r)			//55

for循环

i. 增强for

val l1 = List(1,3,5,7,9);
for(n <- l1){    
	println(n)}

ii. 普通for

for(i <- 1 to 10){
	println("abc"+i)} 

iii. 过滤for

案例：遍历0到100的偶数 过滤出其中大于30小于80的数
for(i <- 0 to 100; if i % 2==0;if i>30;if i<80){  
	  println(i)}

iv. 嵌套for

//案例：实现九九乘法表
for(i <- 1 to 9){
  for(j <- 1 to i){
    print(j +" * "+ i +" = "+i*j +" ");
  }
  println()
}
 
for(i <- 1 to 9; j <- 1 to i){
        print(j +" * "+ i +" = "+i*j +" ");}

流间变量定义

//九九乘法表
for(i <- 1 to 9; j <- 1 to i;val str = "\r\n"){
        print(j +" * "+ i +" = "+i*j + str)
}
for(i <- 1 to 9; j <- 1 to i;val str = if (i==j) "\r\n" else " "){
        print(j +" * "+ i +" = "+i*j + str)
}

yield关键字创建新集合
for循环默认的返回值类型是Unit,即不能带回返回值
​ 但是可以通过yield关键字将每次循环的的最后一个表达式的值组成集合返回

try…catch…finally捕获异常
scala中继承了java的异常机制 提供了 程序中产生意外情况时 处理的机制
抛出异常的过程和java中基本一致通过throw关键字进行

 throw xxxException()

try{
  val i = 1/0;
}catch{
  case t: NullPointerException => println("空指针异常！") 
  case t: IOException => println("IO异常！")
  case t: RuntimeException => println("其他运行时异常！")
  case t: Throwable  => println("其他异常或错误！")
}finally{
  println("无论如何都执行 finally")
}

//Console
无论如何都执行 finally
其他运行时异常

match匹配

continue和break
scala中没有continue和break

//案例：将0到100的奇数进行累加  但如果累加值超过了50，则不再进行累加，求最后的累加的值
var x = 0;
var sum = 0;
var  flag = true;
while(x < 100 && flag){
        if(sum>50){
                flag = false;scala
        }
        if(x % 2==0){
        //偶数
        }else{
                sum += x;
        }
        x += 1;
}
print(sum)    //64

递归实现

def mx(i:Int,sum:Int):Int={
  if(sum>50 || i >100) sum;
  else if(i % 2 ==0) mx(i+1,sum)
  else mx(i+1,sum+i)
}
val r = mx(0,0)
println(r)				//64

访问范围问题

val str = "abc";
if(3>2){
        val str = "xyz";
        println(str)    	//xyz
}
println(str)				//abc