【scala基础知识】
大数据开发技术笔记
spark
大数据：spark：spark--它是新一代的内存级大数据的计算框架，spark它是大数据的重要内容。
spark它是用scala语言来开发的，所以我们如果要掌握好spark，就得学好scala这门语言。
多范式
什么是多范式：就是多种编程方法。那么目前来说，有哪些编程方法呢？四种：面向对象（java，C++），面向过程（功能）：C，泛型，函数式编程方法。
动态类型的编程语言
那么动态类型的编程语言有哪些？（python，JavaScript，php解释型语言）
scala
1.1概念
scala（scalable language）
-
它是一个可伸缩性的语言。
-
它是一门多范式的编程语言。
-
它是一门类似于java的语言。（因为它是以java虚拟机（JVM）为运行环境的。那么它是将面向对象和函数式两种编程方法结合在一起的语言。）
-
它是一个静态类型的语言。
1.2 Scala SDK安装：
直接下一步。注意：不要放在默认安装目录下（因为默认目录中有空格），也不要有中文，以及非法的字符。装好了之后，打开cmd命令，输入scala -version，如果显示了当前安装版本，则说明安装好了。
做个练习：在scala编译器里面，打印：hello，你好，欢迎大家来学习scala语言。
Idea的安装步骤：
装完了之后先不打开。打开idea安装的bin目录，把破解文件放进去，简单说，就是把这个jar文件放到idea的启动项中。
然后
从本地目录导入scala插件。
然后点击restart重启一下idea。
如果忘记添加插件了，可以进去之后在files，setting里面添加，找到plugins。然后添加步骤同上面一样。
1.3 Scala语言的编译
-
Scala语言怎么编译：scala的源代码(.scala)回被编译成java字节码(.class),然后运行在java虚拟机上。
-
Scala可以调用现有的java类库，可以实现两种语言间的无缝对接。
1.4 Scala语言的特点
\1. 它是兼容性的。可访问java类库，例如我们操作mysql，redis，activemq，freemarker。
\2. Scala语言它是高级的。可以让我们得程序变得很清晰，看起来更加优雅。
\3. Scala它是精简的，一行代码可以抵上很多行的java代码，所以它的开发速度很快。
\4. 它是静态类型的。它拥有非常先进的静态类型系统。比如：类型推断，还有模式匹配等。
\5. Scala可以开发大数据应用程序。如：spark，flink。。。
1.5 输出函数
Scala中，它的输出函数是什么比如我们要打印：hello scala。
Java：System.out.println();
Scala：print(“hello scala”) //print/println 不换行和换行。
语句结束后，最后的 “ ; ” 可加可不加。
1.6 变量和常量
常量：在程序执行的过程中，其值不会被改变的变量，回收性较好，一次性利用回收
变量：其值可改变，可重新赋值，回收性较差
<1>回顾：Java变量和常量语法
-
变量类型 变量名称 = 初始值
eg: int a = 10
-
final常量类型 常量名称 = 初始值
eg: final int b = 20
<2> var变量
- Val：它是一个只读变量。它定义变量的时候，咱们必须初始化，因为后面不能改变它
var 变量名 [: 变量类型] = 初始值
eg: var i:Int = 10
var i:String = “acbdd
<3> val 常量
- Var：它是一个可变变量，我们可以通过重新分配的方式来更改其变量值，也就是说用var定义的变量可以被重新赋值。
val 常量名 [: 常量类型] = 初始值
eg: val j:Int = 20
// 注意：能用常量的地方不用变量
<4>案例实操
（1）声明变量时，类型可以省略，编译器自动推导，即类型推导
（2）类型确定后，就不能修改，说明Scala是强数据类型语言。
（3）变量声明时，必须要有初始值
（4）在声明/定义一个变量时，可以使用var或者val来修饰，var修饰的变量可改变，val修饰的变量不可改。
package com.atguigu.chapter2
object TestValueTransfer {
def main(args: Array[String]): Unit = {
var n = 1 + 2.2222
println(n) //Double
var n2: Double = 2.2222
// var n3: Int = n2 //报错
var n4 : Byte = 44
// var c1 : Char = n4 //报错
var n5 : Int = n4
var n6 : Byte = 66
var c2 : Char = 22
// var n : Short = n6 + c2 //报错，结果是Int类型
// var n7 : Short = 10 + 20 //报错，byte，short，char他们三者可以计算，在计算时首先转换为int类型。
}
}
————————————————————————————————————————————————————————————————————————————————
版权声明：本文为CSDN博主「工藤-新二」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_39346903/article/details/113562823
（5）var修饰的对象引用可以改变，val修饰的对象则不可改变，但对象的状态（值）却是可以改变的。（比如：自定义对象、数组、集合等等）
package com.atguigu.chapter1
object TestVar {
def main(args: Array[String]): Unit = {
var age = 22
age = 29
// age = "hh" //报错
var n1 = 1 //可变
n1 = 2
val n2 = 2 //不可变
//n2 = 3
//p1 是var修饰的，p1的属性可以变，p1本身也可以变
var p1 = new Person()
p1.name = "varp1"
p1 = null
val p2 = new Person()
p2.name = "valp2"
// p2 = null //报错
}
class Person {
var name: String = "who"
}
}
————————————————————————————————————————————————————————————————————————————————
版权声明：本文为CSDN博主「工藤-新二」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_39346903/article/details/113562823
1.7 类型转换
-
定义：简单来说就是一种类型转换成另一种类型。
-
当scala程序进行运算的时候，咱们范围小的数据类型值会自动转换为范围大的数据类型值，然后在进行计算。
-
类型转换分为：值类型转换和引用类型转换。
package Demon object test01 { def main(args: Array[String]): Unit = { val a=1 val b=1.1 println(a+b) } } 输出结果：2.1 Process finished with exit code 0例如：1 + 1.1 = 2.1，系统会自动把它转换为Double类型，就像这种涉及到“四舍五入”的操作时，他要把一个小数转为整数去计算， 这就是scala中的类型转换。
1.7.1值类型转换
值类型转换：它有分为两种：自动类型转换，强制类型转换。
7.1.1自动类型转换
-
定义：范围小的数据类型值会自动转换为范围大的数据类型值。
7.1.2强制类型转换
-
定义：范围大的数据类型值通过一定的格式，可以将其转换为范围小的数据类型值，这个就叫强制类型转换。
-
格式：
val/var 变量名：数据类型 = 数据具体的值.toXxx
举例： val a:Double=5.56 val b:Int=a.toInt println(b) 打印结果：5
#####
1.7.2 值类型数据和String类型之间的相互转换
-
值类型数据转换为String类型的数据
-
格式1：
通过和空字符串拼接的方式来实现类型转换
val/var 变量名:String = 值类型数据 + ""
举例： val a：int=10 val b:String=a+"" println(b) 打印结果：10
-
格式2：
va/var 变量名:String = 值类型数据.toString
scala> val a=10 a: Int = 10 scala> val b:String=a.toString b: String = 10
1.7.0 引用类型转换
1.8键盘录入
| 语言 | 键盘录入 | 接受类型 |
|---|---|---|
| python | input | |
| Java | scanner | |
| c语言 | scanf | |
| Scala | StdIn.readInt() | 接收整型数据 |
| StdIn.readLine() | 接收字符串类型数据 |
//我们录入之前需要导包：import scala.io.StdIn
scala> import scala.io.StdIn import scala.io.StdIn scala> val name ="请输入姓名" name: String = 请输入姓名 scala> val age ="请输入年龄" age: String = 请输入年龄 scala> val nameq=StdIn.readLine() nameq: String = 邱慧娴 scala> val ageq=StdIn.readInt() ageq: Int = 19
1.9字符串
1.9.1使用双引号：""
*格式：val/var 变量名 = " 字符串 "
eg:有个同学的名字叫做"oo",请打印出她的名字和长度。
val name:String="oo" println(name+(name.length)) ----------------- 结果：oo2
1.9.2 使用差值表达式
-
好处：使用插值表达式，有效避免大量字符串的拼接。
格式：val/var 变量名 = s"${变量/表达式}字符串"
注意：在定义字符串前添加“s”，在字符串中。使用“${}”来印象变量或者编写表达式。
eg：请定义若干个变量，分别保存"oo",18,"girl"，定义一个字符串，分别来保存这些信息。打印输出：name=邱慧娴，age=19，sex=girl.
val name="邱慧娴"
val age=19
val sex="girl"
val str=s"name=${name},age=${age},sex=${sex}"
println(str)
----------------
结果：name=邱慧娴,age=19,sex=girl
1.9.3使用三引号定义
-
如果有大段的文本需要保存，就可以使用三引号来定义字符串
格式：var/val 变量名 = """....字符串..."""
eg：我们要保存一段sql语句。
val sql = """ |select |* |from | user |where | name = "oo" """ println(sql) ----------------------------------------- 结果： |select |* |from | user |where | name = "oo" Process finished with exit code 0
扩展内容：比如说，咱们在企业开发中，有时候会编写非常复杂繁琐的sql语句，这些语句可能会成百上千，或者上万行。如果这些语句加载到JVM中，他会有很大的内存开销，我们如何去解决这种问题呢？ 当有一些变量保存的数据很大很多时，而这些数据又不需要立马加载到JVM上，也就是说等我们需要用到的时候再让它打印出来。 这时，我们就可以用“惰性赋值”去提高效率。它同java里“懒汉式”类似。 lazy val sql = """...语句...""" (这里不能用var)
2.0标识zhi符
-
咱们实际开发中，会编写大量的代码，代码中有变量，方法等等。那么我们如何命名呢？
标识符就是用来给变量，类，方法命名
2.0.1命名规则
-
必须由大小写字母，下划线_,数字，美元符号$，这四部分任意组合而成
-
不能以数字开头
-
不能和scala中的关键字重名
-
最好做到见名知意
2.0.2命名规范
-
变量或者方法：从第二个单词开始，每个单词的首字母大写，其余字母小 写。（小驼峰命名）
eg: zhangSanAge,student_Country,getSum.....
-
类或者特质：每个单词的首字母大写，其余字母小写。（大坨峰命名法）
eg: Person，People,StudentDemo.....
-
包：全部小写，一般用于公司域名反写，多级包之间用.隔开。
eg: com.baidu.... com.sougou.....
2.1数据类型
| 类型 | |
|---|---|
| Byte | 8位带符号整数 |
| Int | 32位带符号整数 |
| short | 16位带符号整数 |
| Long | 64位带符号整数 |
| Char | 16位无符号字符 |
| Double | 64位双精度浮点数 |
| Float | 32位单精度浮点数 |
| Boolean | true和false |
scala中，类型与java的区别在哪里？
-
scala中，所有的类型都要“大写字母”开头。
-
scala中定义变量可以不写类型，让编译器自己去推断
-
scala中默认的整型是：Int，默认的浮点型是：Double
2.2 运算符
2.2.1定义
用来拼接变量或者常量的符号叫运算符，而通过运算符连接起来的式子叫做表达式。实际开发中，我们会经常用到它
例如 10+3 就是一个表达式，而“+”号就是一个运算符
注意：在scala中，运算符不仅仅是运算符他还是一种函数
2.2.2运算符的分类
<1>算数运算符
-
定义：是指用来进行算数操作的符号
-
常用运算符：
算数运算符 功能 + 1，普通的加法操作 2，表示正数 3拼接字符串 - 1，表示负数 2，普通的减法操作 * 表示获取两个数据的乘积 / 表示获取两个数据的商。 10/3=3 % 表示获取两个数据的余数（取模）10%3=1 注意：
-
JAVA中“++”，“--”，表示自增或者自减。scala中是没有这两个运算符的。
-
整数相除的结果，还是整数。如果想获取小数值，则必须有浮点型数据参与。
例如：10/3.0=3.3333（无限循环）
-
关于+号拼接字符串，任意类型的数据和字符串进行拼接后，得到的结果都将是一个新的字符串。
-
关于%操作。假如求a%b的值，它的底层原理就是：a-a/b*b
-
<2>赋值运算符
-
定义：用来进行赋值操作的符号
例如：把一个常量值，或者变量值甚至一段代码的执行结果赋值给变量
-
分类：基本赋值运算符：=，val a =3 扩展赋值运算符： += -= *= /= %=
//注意：1.赋值运算符的左边必须是变量，不能是常量， 例如 3=5，这种写法是错误的
<3>关系运算符
-
用来笔记操作的符号。例如数据是否相等，是否不等，数据1大还是数据2大等等操作
= < <= == !=
注意：1关系表达式不管是简单还是复杂，它的结果一定是Boolean的值，即true或false。2一定不要把 == 写成 =
关系运算符延伸：
上面的运算符用法是和java一样的，那么有哪些地方不一样呢?
-
比较数据值：scala：==，！= java：equals()方法
-
比较引用值（地址值）： scala： eq()方法 java：==，！=
eg：有一个字符串"abc"，再创建第二个字符串，第二个字符串为第一个字符串后面拼接一个空字符+"" 然后使用比较这两个字符串是否相等，再看看他们的引用值是否相等。
val str="abc" val str1=str+"" println(str==str1) println(str.eq(str1)) -------------------------------- 结果：true false Process finished with exit code 0
<4>逻辑运算符
定义：就是用来进行逻辑操作的符号。可以简单的理解为：组合判断。
-
逻辑与：&& 要求所有的条件都满足，简单记忆为：一假则假
-
逻辑或：|| 要求只用满足一个条件，简单记忆为：一真则真
-
逻辑非： ！ 用来取反操作的，即之前是true，取反之后是false。
注意：逻辑表达式不管简单还是复杂，它的结果一定是Boolean的值，即true或false
<5>位运算符
1.什么是进制
通俗来讲，逢几进一就是几进制。例如逢二进一是二进制，逢十进一是十进制
常用的进制
| 进制 | 定义 | 举例 |
|---|---|---|
| 二进制 | 数据以 0b（大小写都可）开头，由数字0和1组成 | 0b1000 1001,0b 0010 0001。。。 |
| 八进制 | 数据以0开头，由数字0~7组成 | 054,011。。。 |
| 十进制 | 直接写数据即可，没有特殊的开头，由数字0~9组成 | 10,20,345。。。 |
| 十六进制 | 数据它是以0x（大小写都可）开头，由数字0~9，字母A~F（大小写都可）组成 | 0x123F，0x66ABC。。。 |
注意：关于二进制的数据，最前边的那一位叫符号位。0表示正数，1表示负数。其他位叫：数值位。（例如：0b1001 1001 它是负数，0b0010 1010它是正数。）
2.什么是8421码
-
定义：就是用来描述二进制和十进制数据之间的关系的，他可以帮助我们快速的进行计算
-
8421码对应的关系如下：
二进制位：0 0 0 0 0 0 0 0
十进制位：128 64 32 16 8 4 2 1
-
计算规则：二进制从右往左，每多一位，对应的十进制数据X2
-
二进制和十进制相互的小技巧：
例如：二进制转十进制：先获取二进制对应的十进制数据，然后累加即可。
eg：0b0000 0101 对应的十进制是多少？
1+0+4=5 12^0+02^1+1*2^2=5
十进制转二进制：先把十进制数据拆解，看看哪些数字相加等于它， 然后标记成二进制即可。 eg：10 对应的二进制是？
0b0000 1010 还有可以除二取余。
3.整数的原码，反码，补码计算规则
1、原码
原码就是符号位加上真值的绝对值，即用第一位表示符号，其余位表示值。比如如果是8位二进制：
[+1]原 = 0000 0001
[-1]原 = 1000 0001
第一位是符号位. 因为第一位是符号位, 所以8位二进制数的取值范围就是：[1111 1111 , 0111 1111]
即[-127 , 127]
2、反码
反码的表示方法是：正数的反码是其本身。负数的反码是在其原码的基础上, 符号位不变，其余各个位取反。
[+1] = [00000001]原 = [00000001]反
[-1] = [10000001]原 = [11111110]反
3.补码
补码的表示方法是：正数的补码就是其本身。负数的补码是在其原码的基础上，符号位不变，其余各位取反，最后+1。(即在反码的基础上+1)。
[+1] = [00000001]原 = [00000001]反 = [00000001]补
[-1] = [10000001]原 = [11111110]反 = [11111111]补
所谓的原反补码，其实就是二进制数据。把十进制数据转换成二进制数据，该二进制数据就是原码。 注意：在计算机底层存储中，操作和运算数据，都是采用“二进制的补码形式”来实现的。 正数：正数的原反补码都是一样的，不需要进行特殊计算。 负数：反码等于原码“除符号位”按位取反 。 补码等于反码加1