Scala从入门到入土(从入门到放弃)

1 Scala介绍

Scala是一门 综合了 面向对象的 函数式编程的 基于JVm的 语言

特点:
1 语法简洁
2 开发速度快 , 运行速度快
3 兼容 Java 可以访问Java类库
4 很多大数据框架的源码或编程接口都支持Scala
5 使用广泛 国际认可

2 Scala运行环境

运行环境: JDK 8 或者11(长期支持)
ScalaSDK 2.12.11 稳定(或者2.12.12)

3 Scala 基础语法

3.1 声明变量 语法详解

1 Scala语句最后不要加分号
2 Scala中类型可以可以省略,因为Scala编译器 支持类型判断
3 val修饰的修饰的变量不能重新赋值 (类似于Java中的final)
4 var可以重新赋值
5 开发中 常用val
6 可以使用type给类型起别名
7 可以使用lazy修饰变量,延迟变量的初始化

测试: type 给类型起别名 可以用数字吗??? (针对6)
答: 不可以

3.2 数据类型

Any 父类( 类似Java中的 Object )
值类型 Scala中的值类型都是大写开头
Byte
Short
Int
Long
Double
Float
Boolean
Char

String: 定义方式1: " "
定义方式2: “”" 这里面可以写SQL “”"
定义方式3: 字符串拼接可以使用插值表达式
定义方式4: 插值表达式 加 “”" “”"

3.3 操作符

语法详解
Scala中的+ - * / %等操作符的作用与Java一样，
位操作符 & | ^ >> <<也一样。
注意：
1.Scala中的操作符实际上是方法
2.Scala中没有++、–操作符，需要通过+=、-=来实现同样的效果
3.+ - * / %是方法，那么就可以进行操作符重载，完成特殊的运算
(也就是自己在类中定义+ - * / %方法表示特殊的运算)

3.4 块表达式

定义变量时可以使用 {} 包含一系列表达式，其中{}块的最后一个表达式的值就是整个块表达式的值。

3.5条件表达式 :

cala条件表达式的语法和Java一样，只是更加简洁，且Scala中if else表达式是有返回值的

注意：
Scala中没有三元表达式,如果if或者else返回的类型不一样，就返回Any类型,对于没有返回值的，使用Unit，写做()，相当于java中的void

3.6循环表达式:

在scala中，可以使用for循环和while循环，但一般推荐使用for表达式，因为for表达式语法更简洁

● 简单for循环：

for (变量 <- 表达式/数组/集合) {循环体}
for(i <- 1 to 10) println(i) 

● 嵌套for循环

	for (变量1 <- 表达式/数组/集合; 变量2 <- 表达式/数组/集合) {循环体}
	for(i <- 1 to 9; j <- 1 to 9){
	      if(i >= j ) print(s"${j} * ${i} = ${j*i}")
	      if(j == 9) println()
	    }

● 守卫
for表达式中，可以添加if判断语句，这个if判断就称之为守卫。我们可以使用守卫让for表达式更简洁。

	for(i <- 表达式/数组/集合 if 表达式) {循环体}
	for(i <- 1 to 10 if i % 3 == 0) println(i)

● for推导式
在for循环体中，可以使用yield表达式构建出一个集合，我们把使用yield的for表达式称之为推导式,即可以使用for推导式生成一个新的集合（一组数据）

	//该for表达式会构建出一个集合
	val l = for(i <- 1 to 10) yield i * 10

● 注意：
while语句本身没有值，即整个while语句的结果是Unit类型的()

	var n = 1;
	val result = while(n <= 10){
	  n += 1
	}
	println(result) //()
	println(n)  //10

3.7 break和continue

Scala中没有break和continue 关键字来退出循环,如果需要使用break/continue，可以使用scala.util.control.Breaks对象的breakable和break方法。

Scala中的方法和Java中的方法一样,都是用来封装某些功能的,他可以接收参数,并在方法体中进行一些处理操作,最后还可以返回处理的结果

定义格式:

 def 方法名(参数名1: 参数类型1, 参数名2: 参数类型2) : 返回类型 = {方法体}

语法细节:
1.方法的返回值类型和return可以不写，编译器可以自动推断出来
2.对于递归方法，必须指定返回类型
3.如果方法没有返回值，返回Unit类型(类似于void，也可以不写)
4.返回值类型有多种情况则返回Any
5.带有默认值参数的方法，调用时，可以给定新值，也可以使用默认值
6.可以通过参数名来指定传递给哪一个参数，
这样传递参数时就可以不按照顺序传递
7.方法没有参数，调用时可以省略()，如果定义时()省略，调用时则必须省略
8.可变参使用 变量名:类型* （类似Java的…）

函数的本质是: 对象
(函数就和方法都是用来封装一些操作的)

●完整语法:

val函数名称:(参数类型)=>函数返回值类型=(参数名称:参数类型)=>{函数体}

●简写语法:

val函数名称=(参数名称:参数类型)=>{函数体}//如果只有一行{}可以省略

●符号解释

=  表示将右边的函数赋给左边的变量
=> 左面表示输入参数名称和类型，右边表示函数的实现和返回值类型

证明Scala中的函数本质也是对象

●注意:
严格的来说，函数与方法是不同的东西。定义方式上也有很多的区别,但是在Scala中，函数本身是对象，方法可以通过下划线_转换为函数。

集合分类
分类方式

一: 按照集合数据结构分类

Seq序列
Set
Map

二: 按照可变不可变进行分类

不可变集合  scala.collection.immutable (默认)
    开发时建议Scala优先采用不可变集合 默认即为不可变
可变集合  scala.collection.

数组 Array

●不可变/定长数组：
 	val/var 变量名= new Array[T](数组长度)
	val/var 变量名 = Array(元素1, 元素2, 元素3...)

●可变/变长数组：
	//需要导入import scala.collection.mutable.ArrayBuffer包
	val/var 变量名 = ArrayBuffer[T]() 
	val/var 变量名 = ArrayBuffer(元素1, 元素2, 元素3...)

●不可变列表(默认) 	
import scala.collection.immutable._

创建方式1.使用List(元素1, 元素2, 元素3, ...)来创建一个不可变列表
    val/var 变量名 = List(元素1, 元素2, 元素3...)

创建方式2.使用::方法创建一个不可变列表
    val/var 变量名 = 元素1 :: 元素2 :: Nil
注意:
	使用::拼接方式来创建列表，必须在最后添加一个Nil

●可变列表 		
import scala.collection.mutable._
创建方式1.使用ListBuffer[元素类型]()创建空的可变列表
    val/var 变量名 = ListBuffer[Int]()

创建方式2.使用ListBuffer(元素1, 元素2, 元素3...)创建可变列表
    val/var 变量名 = ListBuffer(元素1，元素2，元素3...)

●Set说明
	Set代表一个没有重复元素的无序集合；
	即无法加入重复元素且不保证插入顺序的。

●不可变Set(默认) 		
	import scala.collection.immutable._
	
	1.创建一个空的不可变集，语法格式：
	    val/var 变量名 = Set[类型]()
	    
	2.给定元素来创建一个不可变集，语法格式：
	    val/var 变量名 = Set(元素1, 元素2, 元素3...)

●可变Set 		
	import scala.collection.mutable._
	格式相同，导包不同
	
	注意:在main方法里导包是导包下面的集合是可变的
		在首行导包是main方法中的全部 set都是可变的
	val/var 变量名 = Set[类型]()

Tuple 元组

1．语法详解
元组也是可以理解为一个容器，可以用来存放各种相同或不同类型的数据。
例如：姓名，年龄，性别，出生年月。
元组的元素是不可变的。

●创建元组
方式一:使用括号来定义元组

	val/var 元组 = (元素1, 元素2, 元素3....)

方式二:使用箭头来定义元组（元组只有两个元素）

	al/var 元组 = 元素1->元素2 //对偶/二元组是最简单的元组(k,v)

注意:如果定义二元组使用方式一/二都可以 但是如果是三元组,则需要注意只能用方式2

●获取元组中的值

	使用下划线加脚标 ，例如 tuple._1  tuple._2  tuple._3

注意：元组中的元素脚标是从1开始的

●将对偶(二元组)组成的数组转换成映射(映射就相当于Java中的Map)

将对偶/二元组的集合转换成映射： 调用其toMap 方法

●遍历
可以调用元组的productIterator方法获取迭代器对象进行遍历

2．拉链操作：

使用zip将多个值绑定在一起，如果两个数组的元素个数不一致，拉链操作后生成的数组的长度为较小的那个数组的元素个数, 使用zipAll将多个值绑定在一起，缺少的用默认的元素填充

Map Map是多个二元组
在Scala中，把哈希表这种数据结构叫做映射。类比Java的map集合

●不可变Map

import scala.collection.immutable.Map
	格式一：  使用箭头     
  	val/var map = Map(键->值, 键->值, 键->值...)	  	// 推荐，可读性更好
  	
	 格式二：利用元组
 	 val/var map = Map((键, 值), (键, 值), (键, 值), (键, 值)...)

●可变Map

import scala.collection.mutable.Map
//与 不可变Map 格式相同，导包不同

map(键)
map.getOrElse(键,默认值)

map(键)=值

Queue

队列数据存取符合先进先出的策略,有 scala.collection.mutable.Queue 和 scala.collection.immutable.Queue ,一般来说我们在开发中队列通常使用可变队列

●常见操作

			+= //追加
			enqueue //入队
			dequeue //出队

	package cn.itcast.collection
  /**
    * Author caowei
    * Date 2019/7/3 20:16
    * Desc 
    */
  object QueueDemo {
    def main(args: Array[String]): Unit = {
      //队列的创建
      import scala.collection.mutable.Queue
      val q1 = new Queue[Int]
      println(q1) //Queue()
      //队列元素的追加
      q1 += 1;
      println(q1)//Queue(1)
      //向队列中追加List
      q1 ++= List(2, 3, 4)
      println(q1)//Queue(1, 2, 3, 4)
      //按照进入队列的顺序删除元素
      q1.dequeue()
      println(q1)//Queue(2, 3, 4)
      //塞入数据
      q1.enqueue(9, 8, 7)
      println(q1)//Queue(2, 3, 4, 9, 8, 7)
      //返回队列的第一个元素
      println(q1.head)//2
      //返回队列最后一个元素
      println(q1.last)//7
      //返回除了第一个以外的元素
      println(q1.tail)//Queue(3, 4, 9, 8, 7)
    }
  }

今日分享这么多, 仅代表个人理解 , 有借鉴部分 有任何疑问或者侵权问题 欢迎咨询 QQ 2211572344 交流探讨