【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