大数据开发语言Scala——scala入门
Posted five小点心
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了大数据开发语言Scala——scala入门相关的知识，希望对你有一定的参考价值。
累了，基础配置不想写了，直接抄了→Scala的环境搭建
这里需要注意的是，创建新项目时，不要用默认的Class类，用Object，原因看→scala中的object为什么可以直接运行
一、Scala简介
1.1 图解Scala和Java的关系
1.2 关键字说明
package： 包，等同于java中的package
object：关键字，声明一个单例对象（伴生对象）
main方法：从外部可以直接调用执行的方法
def 方法名称 ( 参数名称 : 参数类型 ) : 返回值类型 = 方法体
Scala 完全面向对象，故scala去掉了Java中非面向对象的元素，如static关键字，void类型
1) static
scala无static关键字,由object实现类似静态方法的功能(类名.方法名)
class关键字和Java中的class关键字作用相同,用来定义一个类
2) void
对于无返回值的函数,scala定义其返回值类型为Unit类型
1.3 代码案例
package com.scala.chapter1
object Hello
def main(args: Array[String]): Unit =
println("hello scala")
System.out.println("hello scala")
1.4 Scala语言特点
Scala是一门以Java虚拟机 (JVM）为运行环境并将面向对象和函数式编程的最佳特性结合在一起的静态类型编程语言（静态语言需要提前编译的如: Java、C、C++等，动态语言如：JS）。
1）Scala是一门多范式的编程语言，Scala支持面向对象和函数式编程。 (多范式，就是多种编程方法的意思。有面向过程、面向对象、泛型、函数式四种程序设计方法。)
2）Scala源代码 (.scala) 会被编译成Java字节码 (.class)，然后运行于JVM之上，并可以调用现有的Java类库，实现两种语言的无缝对接。
3）Scala单作为一门语言来看，非常的简洁高效
4）Scala在设计时，马丁·奥德斯基是参考了Java的设计思想，可以说Scala是源于Java，同时马丁·奥德斯基也加入了自己的思想，将函数式编程语言的特点融合到JAVA中，因此，对于学习过Java的同学,只要在学习Scala的过程中，搞清楚Scala和Java相同点和不同点，就可以快速的掌握Scala这门语言。
二、变量和数据类型
Any： 所有类型的超类（顶级类型）
AnyVal： 值类型的超类
AnyRef： 引用类型的超类，对应java.lang.Object
Unit： 无值，类似java中的void
Nothing： 所有类型的子类
Null： 表示null或空引用
2.1 注释
Scala注释使用和Java完全一样。
注释是一个程序员必须要具有的良好编程习惯。将自己的思想通过注释先整理出来，再用代码去体现。
1）基本语法
（1）单行注释：//
（2）多行注释：/* */
（3）文档注释：/**
*
*/2）案例实操
object Test1
def main(args: Array[String]): Unit =
//单行注释
println("单行")
//多行
/*
println("多行")
*/
//文档注释
/**
* println("文档注释")
*/
3） 代码规范
（1）使用一次tab操作，实现缩进，默认整体向右边移动，用shift+tab整体向左移
（2）或者使用ctrl + alt + L来进行格式化
（3）运算符两边习惯性各加一个空格。比如：2 + 4 * 5
（4）一行最长不超过80个字符，超过的请使用换行展示，尽量保持格式优雅
2.2 变量和常量（重点）
常量：在程序执行的过程中，其值不会被改变的变量
1）基本语法
var 变量名 [: 变量类型] = 初始值 var i:Int = 10
val 常量名 [: 常量类型] = 初始值 val j:Int = 20
注意：能用常量的地方不用变量
2）案例实操
（1）声明变量时，类型可以省略，编译器自动推导，即类型推导
（2）类型确定后，就不能修改，说明Scala是强数据类型语言。
（3）变量声明时，必须要有初始值
（4）在声明/定义一个变量时，可以使用var或者val来修饰，var修饰的变量可改变，val修饰的变量不可改。
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类型。
（5）var修饰的对象引用可以改变，val修饰的对象则不可改变，但对象的状态（值）却是可以改变的。（比如：自定义对象、数组、集合等等）
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"
2.3 标识符的命名规范
Scala对各种变量、方法、函数等命名时使用的字符序列称为标识符。即：凡是自己可以起名字的地方都叫标识符。
1）命名规则
Scala中的标识符声明，基本和Java是一致的，但是细节上会有所变化，有以下三种规则：
（1）以字母或者下划线开头，后接字母、数字、下划线
（2）以操作符开头，且只包含操作符（+ - * / # !等）
（3）用反引号....包括的任意字符串，即使是Scala关键字（39个）也可以
• package, import, class, object, trait, extends, with, type, for
• private, protected, abstract, sealed, final, implicit, lazy, override
• try, catch, finally, throw
• if, else, match, case, do, while, for, return, yield
• def, val, var
• this, super
• new
• true, false, null2）案例实操
需求：判断hello、Hello12、1hello、h-b、x h、h_4、ab、Int、、+-/#!、+-/#!1、if、if，这些名字是否合法。
object TestName
def main(args: Array[String]): Unit =
//1.以字母或者下划线开头，后接字母、数字、下划线
var hello: String = ""
var hello2: String = " "
// var 1 hello:String = "" 数字不能开头
// var h - b: String = "" 不能用-
// var x h: String = "" 不能用空格
var h_4: String = ""
val _ab: String = ""
var Int: String = "" //ok 因为在Scala中Int是预定义的字符,不是关键字，但不推荐
var _: String = "" // ok 单独一个下划线不可以作为标识符，因为_被认为是一个方法
//2.以操作符开头，且只包含操作符（+ - * / # ! 等）
var +*-/#! : String = ""
// var +*-/#!1 : String = "" 以操作符开头必须都是操作符
//3.用反引号`...`包括的任意字符串，即使是Scala关键字（39）个也可以
// var if:String = "" 不用用关键字
var `if`: String = ""
2.4 字符串输出
1）基本语法
（1）字符串，通过+号连接
（2）printf用法：字符串，通过%传值。
（3）字符串模板（插值字符串）：通过$获取变量值
2）案例实操
object TestCharType
def main(args: Array[String]): Unit =
var name: String = "zhangsan"
var age: Int = 22
//1.字符串 通过 + 号连接
println(name + " " + age)
//2.printf 用法字符串，通过%传值
printf("name=%s age=%d\\n", name, age)
//3.字符串，通过$引用
//多行字符串，在Scala中，利用三个双引号包围多行字符串就可以实现。//输入的内容，带有空格、\\t之类，导致每一行的开始位置不能整洁对齐。
//应用scala的stripMargin方法，在scala中stripMargin默认是“|”作为连接符，//在多行换行的行头前面加一个“|”符号即可。
val s =
"""
| select
| name
|,
|age
|from user
|where name = "zhangsan"
""".stripMargin
println(s)
//如果需要对变量进行运算，那么可以加$
val s1 =
s"""
| select
| name
|,
|age
|from user
|where name="$name" and age=$age + 2
""".stripMargin
val s2 = s"name=$name"
println(s2)
2.5 键盘输入
在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取。
1）基本语法
StdIn.readLine()、StdIn.readShort()、StdIn.readDouble()
2）案例实操
需求：可以从控制台接收用户信息，【姓名，年龄，薪水】。
import scala.io.StdIn
object TestInput
def main(args: Array[String]): Unit =
// 输入姓名
println("input name:")
var name = StdIn.readLine()
// 输入年龄
println("input age:")
var age = StdIn.readShort()
// 输入薪水
println("input sal:")
var sal = StdIn.readDouble()
// 打印
println("name=" + name)
println("age=" + age)
println("sal=" + sal)
从文件中读取数据：
import scala.io.Source;
Source.fromFile("C:\\\\Users\\\\90513\\\\Desktop\\\\datas.csv").foreach(print)
2.6 数据类型（重点）
Java 数据类型
Java基本数据类型：char、byte、short、int、long、float、double、boolean
Java引用类型：（对象类型）
由于Java有基本类型，而且基本类型不是真正意义的对象，即使后面产生了基本类型的包装类，但是仍然存在基本数据类型，所以Java语言并不是真正意义上的面向对象
Java基本类型的包装类：Character、Byte、Short、Integer、Long、Float、Double、Boolean
注意：Java中基本类型和引用类型没有共同的祖先。
Scala 数据类型
2.7 整数类型（Byte、Short、Int、Long）
Scala的整数类型就是用于存放整数值的，比如12，30，3456等等。
1）整型分类
数据类型 | 描述 |
Byte [1] | 8位有符号补码整数。数值区间为 -128 到 127 |
Short [2] | 16位有符号补码整数。数值区间为 -32768 到 32767 |
Int [4] | 32位有符号补码整数。数值区间为 -2147483648 到 2147483647 |
Long [8] | 64位有符号补码整数。数值区间为 -9223372036854775808 到 9223372036854775807 = 2的(64-1)次方-1 |
2）案例实操
（1）Scala各整数类型有固定的表示范围和字段长度，不受具体操作的影响，以保证Scala程序的可移植性。
（2）Scala的整型，默认为Int型，声明Long型，须后加‘l’或‘L’
object TestDataType
def main(args: Array[String]): Unit =
// 正确
var n1: Byte = 127
var n2: Byte = -128
// 错误
// var n3:Byte = 128
// var n4:Byte = -129
// Scala的整型，默认为Int型，声明Long型，然后加”i“ 或者 ”L“
var n5 = 10
println(n5)
var n6 = 98989898989898989L
println(n6)
var n7 = 2.43434309898f
var n8 = 2.4343662343223
println(n7)
println(n8)
var God = new God()
God = null
//var n1 : Int = null //错误
//println("n1:" + n1)
class God
（3）Scala程序中变量常声明为Int型，除非不足以表示大数，才使用Long
2.8 浮点类型（Float、Double）
Scala的浮点类型可以表示一个小数，比如123.4f，7.8，0.12等等。
1）浮点型分类
数据类型 | 描述 |
Float [4] | 32 位, IEEE 754标准的单精度浮点数 |
Double [8] | 64 位 IEEE 754标准的双精度浮点数 |
2）案例实操
Scala的浮点型常量默认为Double型，声明Float型常量，须后加‘f’或‘F’。
object TestDataType
def main(args: Array[String]): Unit =
// 正确
var n1: Byte = 127
var n2: Byte = -128
// 错误
// var n3:Byte = 128
// var n4:Byte = -129
// Scala的整型，默认为Int型，声明Long型，然后加”i“ 或者 ”L“
var n5 = 10
println(n5)
var n6 = 98989898989898989L
println(n6)
var n7 = 2.43434309898f
var n8 = 2.4343662343223
println(n7)
println(n8)
var God = new God()
God = null
//var n1 : Int = null //错误
//println("n1:" + n1)
class God
2.9 字符类型（Char）
1）基本说明
字符类型可以表示单个字符，字符类型是Char。
2）案例实操
（1）字符常量是用单引号 ’ ’ 括起来的单个字符。
（2）\\t ：一个制表位，实现对齐的功能
（3）\\n ：换行符
（4）\\\\ ：表示\\
（5）" ：表示"
package com.atguigu.chapter1
object TestCharType2
def main(args: Array[String]): Unit =
var c1: Char = 'a'
println("c1=" + c1)
//注意：这里涉及自动类型提升，其实编译器可以自定判断是否超出范围
//不过idea提示报错
var c2: Char = 'a' + 1
println(c2)
// \\t ：一个制表位，实现对齐的功能
println("姓名\\t年龄")
// \\n ：换行符
println("西门庆\\n潘金莲")
//（4）\\\\ ：表示\\
println("c:\\\\天黑了\\\\饿狼来了")
//（5）\\" ：表示"
println("你过来：\\"看我一拳打死你\\"")
2.10 布尔类型：Boolean
1）基本说明
（1）布尔类型也叫Boolean类型，Booolean类型数据只允许取值true和false
（2）boolean类型占1个字节。
2）案例实操
object TestBooleanType
def main(args: Array[String]): Unit =
var isResult : Boolean = false
var isResult2 : Boolean = true
2.11 Unit类型、Null类型和Nothing类型（重点）
1）基本说明
数据类型 | 描述 |
Unit | 表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。 |
Null | null , Null 类型只有一个实例值null |
Nothing | Nothing类型在Scala的类层级最低端；它是任何其他类型的子类型。 当一个函数，我们确定没有正常的返回值（如抛出异常），可以用Nothing来指定返回类型，这样有一个好处，就是我们可以把返回的值（异常）赋给其它的函数或者变量（兼容性） 在Java中有时候有返回值，如int，但有些情况下会抛出异常。为了兼容多种可能性，就可以使用nothing类型。 |
2）案例实操
（1）Unit类型用来标识过程，也就是没有明确返回值的函数。
由此可见，Unit类似于Java里的void。Unit只有一个实例——( )，这个实例也没有实质意义
def m1():Unit=
println("m1被执行")
val a:Unit=m1()
println("a="+a)
// 输出：a=()（2）Null类只有一个实例对象，Null类似于Java中的null引用。Null可以赋值给任意引用类型（AnyRef），但是不能赋值给值类型（AnyVal）
object TestDataType
def main(args: Array[String]): Unit =
// 正确
var n1: Byte = 127
var n2: Byte = -128
// 错误
// var n3:Byte = 128
// var n4:Byte = -129
// Scala的整型，默认为Int型，声明Long型，然后加”i“ 或者 ”L“
var n5 = 10
println(n5)
var n6 = 98989898989898989L
println(n6)
var n7 = 2.43434309898f
var n8 = 2.4343662343223
println(n7)
println(n8)
// null可以赋值给任意引用类型（AnyRef），但是不能赋值给值类型（AnyVal）
var God = new God()
God = null
// var n1: Int = null //错误
// println("n1:" + n1)
class God
（3）Nothing，可以作为没有正常返回值的方法的返回类型，非常直观的告诉你这个方法不会正常返回，而且由于Nothing是其他任意类型的子类，他还能跟要求返回值的方法兼容。
object TestSpecialType
def test(): Nothing =
throw new Exception
test()
2.12 类型转换
2.12.1 数值类型自动转换
当Scala程序在进行赋值或者运算时，精度小的类型自动转换为精度大的数值类型，这个就是自动类型转换（隐式转换）。数据类型按精度（容量）大小排序为：
1）基本说明
（1）自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度大的那种数据类型，然后再进行计算。
（2）把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换。
（3）（byte，short）和char之间不会相互自动转换。
（4）byte，short，char他们三者可以计算，在计算时首先转换为int类型。
2）案例实操
object TestValueTransfer
def main(args: Array[String]): Unit =
//（1）自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度大的那种数值类型，然后再进行计算。
var n = 1 + 2.2222
println(n) //Double
//（2）把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换。
var n2: Double = 2.2222
// var n3: Int = n2 //报错
//（3）（byte，short）和char之间不会相互自动转换。
var n4: Byte = 44
// var c1 : Char = n4 //报错
var n5: Int = n4
//（4）byte，short，char他们三者可以计算，在计算时首先转换为int类型。
var n6: Byte = 66
var c2: Char = 22
// var n : Short = n6 + c2 //报错，结果是Int类型
// var n7 : Short = 10 + 20 //报错，byte，short，char他们三者可以计算，在计算时首先转换为int类型。
注意：Scala还提供了非常强大的隐式转换机制（隐式函数，隐式类等），我们放在高级部分专门用一个章节来讲解。
2.12.2 强制类型转换
1）基本说明
自动类型转换的逆过程，将精度大的数值类型转换为精度小的数值类型。使用时要加上强制转函数，但可能造成精度降低或溢出，格外要注意。
2）案例实操
（1）将数据由高精度转换为低精度，就需要使用到强制转换
（2）强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级
object TestForceTransfer
def main(args: Array[String]): Unit =
//（1）将数据由高精度转换为低精度，就需要使用到强制转换
var n1: Int = 2.5.toInt // 这个存在精度损失
//（2）强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级
var r1: Int = 10 * 3.5.toInt + 6 * 1.5.toInt // 10 *3 + 6*1 = 36
var r2: Int = (10 * 3.5 + 6 * 1.5).toInt // 44.0.toInt = 44
println("r1=" + r1 + " r2=" + r2)
2.12.3 数值类型和String类型间转换
1）基本说明
在程序开发中，我们经常需要将基本数值类型转成String类型。或者将String类型转成基本数值类型。
2）案例实操
（1）基本类型转String类型（语法：将基本类型的值+“” 即可）
（2）String类型转基本数值类型（语法：s1.toInt、s1.toFloat、s1.toDouble、s1.toByte、s1.toLong、s1.toShort）
object TestStringTransfer
def main(args: Array[String]): Unit =
//（1）基本类型转String类型（语法：将基本类型的值+"" 即可）
var str1: String = true + "你kin"
println(str1)
var str2: String = 4.444 + "拜拜"
println(str2)
var str3: String = 4444 + ""
println(str3)
//（2）String类型转基本数值类型（语法：调用相关API）
var s1: String = "11"
var n1: Byte = s1.toByte
var n2: Short = s1.toShort
var n3: Int = s1.toInt
var n4: Long = s1.toLong
println(s1)
println(n1)
println(n2)
println(n3)
println(n4)
（3）注意事项
在将String类型转成基本数值类型时，要确保String类型能够转成有效的数据，比如我们可以把"123"，转成一个整数，但是不能把"hello"转成一个整数。
var n5:Int = “12.6”.toInt会出现NumberFormatException异常。
2.13 字符串String
Scala中本身没有String数据类型，字符串本质上是Java String。和Java String 一样，String是一个不可变对象，该对象不可修改。
三、运算符
Scala运算符的使用和Java运算符的使用基本相同，只有个别细节上不同。
3.1 算术运算符
1）基本语法
运算符 | 运算 | 范例 | 结果 |
+ | 正号 | +3 | 3 |
- | 负号 | b=4; -b | -4 |
+ | 加 | 5+5 | 10 |
- | 减 | 6-4 | 2 |
* | 乘 | 3*4 | 12 |
/ | 除 | 5/5 | 1 |
% | 取模(取余) | 7%5 | 2 |
+ | 字符串相加 | “He”+”llo” | “Hello” |
（1）对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。
（2）对一个数取模a%b，和Java的取模规则一样。
2）案例实操
object TestArithmetic
def main(args: Array[String]): Unit =
// 1）对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。
var r1: Int = 10 / 3
println(r1) //3
var r2: Double = 10 / 3
println(r2) //3.0
var r3: Double = 10.0 / 3
println(r3) //3.3333333333333335
println(r3.formatted("%.2f")) //3.33 含义：保留小数点2位，使用四舍五入
//（2）对一个数取模a%b，和Java的取模规则一样。
var r4 = 10 % 3
println(r4) //1
3.2 关系运算符（比较运算符）
1）基本语法
运算符 | 运算 | 范例 | 结果 |
== | 相等于 | 4==3 | false |
!= | 不等于 | 4！=3 | true |
< | 小于 | 4<3 | false |
> | 大于 | 4>3 | true |
<= | 小于等于 | 4<=3 | false |
>= | 大于等于 | 4>=3 | true |
2）案例实操
（1）需求1：
object TestRelation
def main(args: Array[String]): Unit =
// 测试：>、>=、<=、<、==、!=
var a: Int = 2
var b: Int = 1
println(a > b) // true
println(a >= b) // true
println(a < b) // false
println(a <= b) // false
println("a==b" + (a == b)) // false
println(a != b) // true
（2）需求2：Java和Scala中关于==的区别
Java：==比较两个变量本身的值，即两个对象在内存中的首地址；equals比较字符串中所包含的内容是否相同。
public class TestRelation2
public static void main(String[] args)
String s1 = "hhhh";
String s2 = new String("hhhh");
System.out.println(s1 == s2); // false
System.out.println(s1.equals(s2)); // true
Scala：==更加类似于Java中的equals，参照jd工具
object TestRelationScala
def main(args: Array[String]): Unit =
val s1 = "aaa"
val s2 = new String("aaa")
println(s1 == s2) // true
println(s1.eq(s2)) // false
3.3 逻辑运算符
1）基本语法
用于连接多个条件（一般来讲就是关系表达式），最终的结果也是一个Boolean值。
假定：变量A为true，B为false
运算符 | 描述 | 实例 |
&& | 逻辑与 | (A && B) 运算结果为 false |
|| | 逻辑或 | (A || B) 运算结果为 true |
! | 逻辑非 | !(A && B) 运算结果为 true |
2）案例实操
object TestLogic
def main(args: Array[String]): Unit =
// 测试：&&、||、！
var a = true
var b = false
println("a&&b=" + (a && b)) // a&&b=false
println("a || b =" + (a || b)) // a || b =true
println("!(a&&b)" + (!(a && b))) // !(a&&b)true
3.4 赋值运算符
1）基本语法
赋值运算符就是将某个运算后的值，赋给指定的变量。
运算符 | 描述 | 实例 |
= | 简单的赋值运算符，将一个表达式的值赋给一个左值 | C = A + B 将 A + B 表达式结果赋值给 C |
+= | 相加后再赋值 | C += A 等于 C = C + A |
-= | 相减后再赋值 | C -= A 等于 C = C - A |
*= | 相乘后再赋值 | C *= A 等于 C = C * A |
/= | 相除后再赋值 | C /= A 等于 C = C / A |
%= | 求余后再赋值 | C %= A 等于 C = C % A |
<<= | 左移后赋值 | C <<= 2等于 C = C << 2 |
>>= | 右移后赋值 | C >>= 2 等于 C = C >> 2 |
| 课程详情请戳原文 以上是关于大数据开发语言Scala——scala入门的主要内容，如果未能解决你的问题，请参考以下文章 |