【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

你可能感兴趣的:(scala,spark,intellij-idea)