#编译运行scala程序，需要：     JDK(jvm)      Scala编译器(scala SDK) 

#安装JDK 1.8 64位, 并配置环境变量. 

#安装Scala SDK   windows : scala-2.12.1.msi  Linux : scala-2.11.12.tar.gz   安装后，测试安装是否成功： scala -version 

#先下载idealU  #然后下载Idealu支持Scala的插件  具体步骤占时略 

//scala 运行在Jvm上这点和Java一样。 Scala多范式编程语言。 //scala支持面向对象和函数编程。 //scala刚出来的时候是个小语种。但随着它的出现Spark，Kafka等基于Scala大数据框架的兴起，Scala就火了呀。 //scala优点是它的表达。 

//开发大数据应用（Spark, Flink）  ///表达能力强，一行相当java多行  //兼容java,可访问庞大的Java类库。例如Mysql， redies, freemrker activemq 等 

//java代码繁琐， Scala代码相对简单. (三行Scala值34行Java. 夸张地说！  ///批量操作，scala一行map差不多够了，但是Java便于循环处理  

java如何编译程序？.执行的?

[外链图片存储失败，源站可能有防盗链机制，建议保存图片直接上传(img-kG0zE3s7-1658546372321)(scala.assets/image-20211027213633410.png)]

scala如何编译和执行程序？

[外链图片存储失败，源站可能有防盗链机制，建议保存图片直接上传(img-IHPPUNlx-1658546372323)(scala.assets/image-20211027213836372.png)]

// java编译器和scala编译器不通用.  // scala也有自己的类库, scala也可以使用java类库哦.  // scala 

交互式

[外链图片存储失败，源站可能有防盗链机制，建议保存图片直接上传(img-grLBWoIS-1658546372323)(scala.assets/image-20210830133231577.png)]

文件式

//HelloWorld.scala 代码如下：  object HelloWorld { 
            /* 这是我的第一个 Scala 程序 * 输出以下程序Hello World!' */    def main(args: Array[String]) { 
               println("Hello, world!") // 输出 Hello World    } } 

[外链图片存储失败，源站可能有防盗链机制，建议保存图片直接上传(img-2dgHhZh3-1658546372324)(scala.assets/image-20210830133434401.png)]

#1. 区分大小写 - Scala大小写敏感，这意味着标志Hello 和 hello在Scala会有不同的含义。  #2. 类名 - 大写所有类名的第一个字母。如果需要用几个单词来形成一个类的名称，每个单词的第一个字母应该大写。  示例：class MyFirstScalaClass  #3. 方法名称 - 所有方法名称的第一个字母都是小写的。若用于构成方法的单词名称，则每个单词的第一个字母应大写。  示例：def myMethodName()  #4. 程序文件名 - 程序文件的名称应与对象名称完全匹配（不需要新版本，但建议保留此习惯）。保存文件时，应保存使用的对象名称（记住Scala区分大小写)并添加".scala"扩展文件名称。 (如果文件名与对象名不匹配，程序将无法编译)。  示例: 假设"HelloWorld"/span>是对象的名称。那么该文件应保存为'HelloWorld.scala" #5. def main(args: Array[String]) - Scala程序从main()方法开始处理，这是每一个Scala程序的强制程序入口部分。 

// 1.scala中var声明变量，val声明常量
	val定义的变量不可以重新赋值，但是var定义的可以.
// 2.Scala 可以使用类型推断。
	val name = "占山"

//当一些变量保存的数据较大时候，但是不需要马上加载到JVM内存中，可以使用惰性赋值来提高效率
	当用到这个变量的时候，才会加载到JVM中

//语法：
	lazy val/var 变量名 = 表达式

例如有个复杂的Sql语言，我们希望只有用到SQL语句的时候才加载他.。 如果不使用lazy，就直接加载到内存了。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EEWagGoH-1658546372324)(scala.assets/image-20211028100331149.png)]

//scala中有着与java相同的数据类型。 如下说说与之不同的地方：
	scala中所有的类型都使用大写字母开头。
	整形使用Int，而不是Integer
	scala 申请变量的时候可以不写类型，让scala编译器自己推断去吧。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tpEVg3jR-1658546372325)(scala.assets/image-20210830135413572.png)]

//Scala的数据类型也是“单根继承”体系， 都是继承Any这个类型

//AnyVal 是所有“值类型”的父类。
//AnyRef 是所有“引用类型”的父类

//Unit 表示“空类型”
	他只有一个实例() 。它类似于java中的void, 但是scala比java更加的面向对象。

//Null 所有“引用类型”的子类。
	也就是Nul类型可以赋值给所有“引用类型”

//Nothing 所有类型的子类。 
	Nothing 表示方法抛出异常的时候，返回的子类。。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qauj3vwv-1658546372325)(scala.assets/image-20211028104338861.png)]

Null 类型是不可以赋值给 AnyVal 下面的类型的， 只可以赋值给AnyRef下的类型。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tJBvySMO-1658546372326)(scala.assets/image-20211028110559816.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aCzNU0pw-1658546372326)(scala.assets/image-20211028103114605.png)]

//if 的使用,语法和java一样。在此不多bb。 下面主要说和java不一样的地方：
	Scala中if是有返回值的。
	Scala中没有三元表达式，可以使用if表达式代替 三元表达式

例：当sex 是 “male”就返回1 ， 否则就返回0

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2gq23e7w-1658546372327)(scala.assets/image-20211028113904773.png)]

//scala中使用{} 表示块表达式
	和if表示式一样，块表达式也是有值的。值就是最后一个表达式的值。

// 块表达式是很牛逼的一个东西。这玩意用的好，代码就精巧。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-O0yxjpK9-1658546372327)(scala.assets/image-20211028115157383.png)]

遍历循环1到9

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PStir5sz-1658546372328)(scala.assets/image-20211028150220215.png)]

在scala中，数字也是一个对象，也可以调用 .to方法。

//scala中 x.to(y) 相当于 python 中 range(x, y+1)

// 1.to(10) 也可以写成 1 to 10

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3CUMIEne-1658546372328)(scala.assets/image-20211028150629317.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8AR7aK0Q-1658546372329)(scala.assets/image-20211028152304039.png)]

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

语法：

for(i <- 表达式/数组/集合 if 表达式) { 
        
    // 表达式
}

//表示，当if后面这个表达式式True的时候，才能进入下面的操作。

例：用for表达式打印1-10之间内 能整除3的数字

for(i <- 1.to(10) if(i%3==0)){ 
        
    println(i)
}

等价于：

for(i <- 1.to(10)){ 
        
    if(i%3==0){ 
        
    	println(i)
    }
}

// 可以使用for推导式　生成一个心的集合（一组数据）
// 我们把 使用yield的for表达式称之为“推导式”

例：生成10， 20， 30， … 100

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YDlFwySD-1658546372329)(scala.assets/image-20211028154508520.png)]

跟python的 v = [ i*10 for i in range(11)] 有点像哦。

略。

略。

* 在scala中，类似Java和C++的break/continue关键字被移除了
* 如果一定要使用break/continue，就需要使用scala.util.control包的Break类的breable和break方法。

* 导入Breaks包 import scala.util.control.Breaks._
* 使用breakable将for表达式包起来
* for表达式中需要退出循环的地方，添加`break()`方法调用

例：

// 导入scala.util.control包下的Break
import scala.util.control.Breaks._

breakable{ 
        
    for(i <- 1 to 100) { 
        
        if(i >= 50) break()
        else println(i)
    }
}

//continue的实现与break类似，但有一点不同：
	实现break是用breakable{ 
        }将整个for表达式包起来，
	而实现continue是用breakable{ 
        }将for表达式的循环体包含起来就可以了

例：打印1-100的数字，使用for表达式来遍历，如果数字能整除10，不打印

// 导入scala.util.control包下的Break 
import scala.util.control.Breaks._

for(i <- 1 to 100 ) { 
        
    breakable{ 
        
        if(i % 10 == 0) break()
        else println(i)
    }
}

Scala 有方法与函数，二者在语义上的区别很小。Scala 方法是类的一部分，而函数是一个对象可以赋值给一个变量。换句话来说在类中定义的函数即是方法。

Scala 中的方法跟 Java 的类似,语法不一样，方法是组成类的一部分.

Scala 中的函数则是一个完整的对象，Scala 中的函数其实就是继承了 Trait 的类的对象。

Scala 中使用 val 语句可以定义函数，def 语句定义方法。

注意：有些翻译上函数(function)与方法(method)是没有区别的。

语法

def methodName (参数名:参数类型, 参数名:参数类型) : [return type] = { 
        
    // 方法体：一系列的代码
}


/* * 参数列表的参数类型不能省略 * 返回值类型可以省略，由scala编译器自动推断 * 返回值可以不写return，默认就是{}块表达式的值 */

例：定义一个方法，实现两个整形数值相加，返回相加后的结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6MqCqlpd-1658546399390)(scala.assets/image-20211028161335519.png)]

标准写法：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bB9fBOOr-1658546399391)(scala.assets/image-20211028162119791.png)]

//scala定义方法可以省略返回值，由scala自动推断返回值类型。这样方法定义后更加简洁。 
//定义递归方法，不能省略返回值类型
//return 什么时候都可以不写，看你心情。

例：定义递归方法（求阶乘）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-R2mn2JxF-1658546399392)(scala.assets/image-20211028162618915.png)]

scala中的方法参数，使用比较灵活。它支持以下几种类型的参数：
    - 默认参数 （和py一样）
    - 带名参数 （和py一样）
    - 变长参数 （ * ）

1.默认参数：在定义方法时可以给参数定义一个默认值。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AXUIZ0qW-1658546399392)(scala.assets/image-20211028163213593.png)]

2.带名参数：在调用方法时，可以指定参数的名称来进行调用。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CecpdFQc-1658546399393)(scala.assets/image-20211028163303876.png)]

3.边长参数：如果方法的参数是不固定的，可以定义一个方法的参数是变长参数。

语法格式：

def 方法名(参数名:参数类型*):返回值类型 = { 
        
    方法体
}

//在参数类型后面加一个`*`号，表示参数可以是0个或者多个

**例子：**定义一个计算若干个值相加的方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5rmKjRe2-1658546399394)(scala.assets/image-20211028164018151.png)]

输出：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-j12uuZkv-1658546399394)(scala.assets/image-20211028164038011.png)]

疑问：不定长参数的类型式什么？猜想是数组。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2SNdvULt-1658546399395)(scala.assets/image-20211028164145483.png)]

输出：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YWdxewcX-1658546399395)(scala.assets/image-20211028164204031.png)]

答疑：是WrappendArray() ? 还是Seq[Int] ?

//在scala中，有以下几种方法调用方式，
  后缀调用法		
  中缀调用法		
  花括号调用法
  无括号调用法

//在后续编写spark、flink程序时，我们会使用到这些方法调用方式。

1.后缀调用法

语法： 对象名.方法名(参数)

例：

Math.abs(-1)
1.to(10)

2.中缀调用法

语法： 对象名 方法名 参数 ； 如果有多个参数，使用括号括起来

例：

Math abs -1
1 to 10	 

3.花括号调用法

//方法只有一个参数，才能使用花括号调用法
Math.abs{ 
        -10}

//{}表示块表达式，快表达式的返回值就是最后一个表达式（之前说过，别忘了）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-x5lavozL-1658546399396)(scala.assets/image-20211029113909816.png)]

4.无符号调用法

//如果方法没有参数，可以省略方法名后面的括号

def m3()=println("hello")
m3

5.操作符也是方法

在scala中:
	所有的操作符都是方法
	操作符是一个方法名字是符号的方法.

1 + 1 这个表达式实际上也是一个方法调用哦。scala的特别之处，嘻嘻。

//下面不写不知道，一写么的吓一跳。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-70lgbz2i-1658546399396)(scala.assets/image-20211029113709782.png)]

// scala支持函数是编程， 这个在编程Spark/flink程序中会大量使用，真特么重要。

/* 函数是一个 对象(变量） 类似于方法，函数也有输入参数和返回值 函数定义不需要使用def 定义 无需指定返回值类型 */

语法

val 函数变量名 = (参数名:参数类型, 参数名:参数类型....) => 函数体


猜想：
等价于python中  函数命=lambda 参数1，参数2 ... ：函数体   (如：x = lambda x: x+1)

例：定义两个数值相加的函数

scala> val add = (x:Int, y:Int) => x + y
add: (Int, Int) => Int = <function2>

scala> add(1,2)
res3: Int = 3

/* 方法是隶属于类或者对象的，在运行时，它是加载到JVM的方法区中 可以将函数对象赋值给一个变量，在运行时，它是加载到JVM的堆内存中 函数是一个对象，继承自FunctionN，函数对象有apply，curried，toString，tupled这些方法。方法则没有 */

**例：**方法无法赋值给变量，函数可以

既：
val 变量 = 函数名 ;   是正确的
	此时 这个变量就是个函数。
val 变量 = 方法名 ;	 是错误的




scala> val add1 = (x:Int, y:Int) => x+y
add1: (Int, Int) => Int = $$Lambda$1092/256869439@7b5833ee

scala> add1
res14: (Int, Int) => Int = $$Lambda$1092/256869439@7b5833ee

scala> add1(1,1)
res15: Int = 2

scala> val a1 = add1
a1: (Int, Int) => Int = $$Lambda$1092/256869439@7b5833ee

scala> a1(2,2)
res16: Int = 4


// --------------------------------------------------------------------

scala> def add2(x:Int, y:Int) = x+y
add2: (x: Int, y: Int)Int


scala> add2(1,1)
res18: Int = 2

scala> val a2 = add2
<console>:12: error: missing argument list for method add2
Unapplied methods are only converted to functions when a function type is expected.
You can make this conversion explicit by writing `add2 _` or `add2(_,_)` instead of `add2`.
       val a2 = add2
                ^

// 有时候需要将方法转换为函数，作为变量传递，就需要将方法转换为函数

语法：

val 变量 = 方法名 _

**例：**将方法转化为函数，赋值给变量

scala> def add(x:Int,y:Int)=x+y
add: (x: Int, y: Int)Int

scala> val a = add _
a: (Int, Int) => Int = <function2>

//定义字符串方式
	val S:String = "aaa"			//使用双引号
	val S:String = """aaaa"""		//使用三引号
	val S:String = s"${ 
          name}你好"	   //使用插值表达式
		//以s开头； name是个变量或者表达式

你可以在 Scala 中使用：

补充：

S.head
S.drop(n)		
S.dropRight(n)	删除后面n个字符

str.length()

//判断str2在str1中的位置
str1.indexOf(str2)
返回-1说明 不存在

val str3 = str1.concat(str2)
或者
val str3 = str1 + str2

str1.replaceAll("字符串1","字符串2")	//将str1中 字符串1替换成字符串2

//列表是scala中最重要的、也是最常用的数据结构。List具备以下性质：
    - 可以保存重复的值
    - 有先后顺序
//有两种列表，一种是不可变列表、另一种是可变列表

//不可变列表就是列表的元素、长度都是不可变的。
//实际上元素，长度都是可以变的。 其实是可以改变的，例如：updated(), drop()， 
	准确的说“不可变列表  只是长度不可以增加”

//使用`List(元素1, 元素2, 元素3, ...)`来创建一个不可变列表:
val/var 变量名 = List(元素1, 元素2, 元素3...)
	//例如 ： var L = List(2,4,9,5,3,6,1,7,8)


//使用`Nil`创建一个不可变的空列表:
val/var 变量名 = Nil


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

**例：**创建一个不可变列表，存放以下几个元素（1,2,3,4）

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

**例：**使用Nil创建一个不可变的空列表

scala> val a = Nil
a: scala.collection.immutable.Nil.type = List()

**例：**使用::方法创建列表，包含-2、-1两个元素

scala> val a = -2 :: -1 :: Nil
a: List[Int] = List(-2, -1)

将L(2) 替换成100

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iJSCMo2i-1658546399397)(scala.assets/image-20211027170608831.png)]

删除前5个数据 L(5)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8yKEQt1C-1658546399398)(scala.assets/image-20211027170859736.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ne3EDIS6-1658546399398)(scala.assets/image-20211027171140054.png)]

//可变列表就是列表的元素、长度都是可变的。
//要使用可变列表，先要导入
	import scala.collection.mutable.ListBuffer
	//可变集合都在`mutable`包中
	//不可变集合都在`immutable`包中（默认导入）

//使用ListBuffer[元素类型]()创建空的可变列表，语法结构：
	val/var 变量名 = ListBuffer[Int]()

//使用ListBuffer(元素1, 元素2, 元素3...)创建可变列表，语法结构:
	val/var 变量名 = ListBuffer(元素1，元素2，元素3...)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8ScPkGe9-1658546399399)(scala.assets/image-20211029175647356.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qVAMuAAp-1658546399399)(scala.assets/image-20211029175846690.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sUPqjn17-1658546399399)(scala.assets/image-20211029175938568.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MXbURv9O-1658546399400)(scala.assets/image-20211029180022146.png)]

从左边起，删除第一个 特定元素

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IQVH3g5A-1658546399408)(scala.assets/image-20211029180057127.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-V3pe10Oa-1658546399409)(scala.assets/image-20211029180143001.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cCqK1zEY-1658546399409)(scala.assets/image-20211029180230402.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-S6Q1ophd-1658546