spark基础-scala
作者：互联网
scala特点
面向对象的，函数式编程的，静态类型的，可扩展的，可以交互操作的
idea中下载安装scala插件
打开idea-->plugins-->搜索scala-->点击installed安装
创建scala程序
进入New Project:
选着对应的jdk和scala-sdk进行创建：
创建成功后可以看到一下目录：
我们在src文件中进行代码的编写。
scala基础语法
1.声明值和变量
使用var声明的变量，值是可变的。
使用val声明的变量，也叫常量，值是不可变的。
var myVar:String = "Hello" val age:Int = 10
注意：
（1）scala中的变量在声明是必须进行初始化。
（2）声明变量时，我们可以不给出变量的类型，以内在初始化的时候，scala的类型推断机制能够更具变量初始化的值自动推算出来。
var myVar = "Hello" val age = 10
（3）使用关键字var或val声明变量时，后面紧跟的变量名称不能和scala中的保留字重名，而且变量名可以以字母或下划线开头，且变量名是严格区分大小写的。
2.数据类型
AnyVal：表示值类型，值类型描述的数据是一个不为空的值，而不是一个对象。它预定义了9种类型，其中，Unit是一种不代表任何意义的值类型，其作用于void类似。
AnyRef：表示应用的类型，可以认为，除值外，所有类型都继承自AnyRef。
Nothing：所有类型的子类型，也称为底部类型。它常见的用途是发出终止信号，例如抛出异常、程序退出或无限循环。
Null：所有应用类型的额子类型，它主要用途是与其他JVM语言操作，几乎不在scala代码中使用。
3.算术和操作符重载
scala中算术操作符（+、-、*、/、%）的作用和java是一样的，位操作符（&、|、>>、<<）也是一样的。特别强调，scala的这些操作符其实是方法。
val a = 1 val b = 2 a+b a.+(b)
scala没有提供操作符++和--。如果我们想实现递增或者递减的效果，可以使用+=1或-=1这种方式。
4.控制结构语句
在scala中，控制结构语句包括条件分支语句和循环语句。
条件分支语句：
//if...
if（布尔表达式）{
结果为ture，执行的语句
}
//if...else...
if（布尔表达式）{
结果为ture，执行的语句
}else{
结果为false，执行的语句
}
if...else if ..else..
if（布尔表达式1）{
布尔表达式1为ture，执行的语句
}else if(布尔表达式2){
布尔表达式2为ture，执行的语句
}else if(布尔表达式3){
布尔表达式3为ture，执行的语句
}else{
以上结果都为false，执行的语句
}
//嵌套
if（布尔表达式1）{
布尔表达式1为ture，执行的语句
if(布尔表达式2){
布尔表达式2为ture，执行的语句
}
}else if(布尔表达式3){
布尔表达式3为ture，执行的语句
else if(布尔表达式4){
布尔表达式4为ture，执行的语句
}
}else{
以上都为false，执行语句
}
循环语句：
scala中的for循环语句和java中的for循环语句在语法上有较大的区别。
for循环语句的语句格式如下：
for (变量<-表达式/数组/集合){
循环语句；
}
从0循环到9，每循环一次则将该值打印输出进行操作演示，在scala语法中，我们可以只用“0 to 9”表示，范围包含9，代码如下：
for （i <- 0 to 9）{
print(i+" ")
}
scala在for循环语句中可以铜鼓使用if判断语句过滤一些元素，多个过滤条件用分好分隔开。如，输入0-9范围中大于5的偶数，代码如下：
for (i <- 0 to 9; if i%2==0; if i>5){
print(i+" ")
}
通过打印输出奇数来演示while循环的使用。假设有一个变量x=1,判断是否小于10，如果是则打印输出，然后在进行+2运算。代码如下：
var x = 1while(x < 10){ print(x+" ") x += 2}
do...while循环语句的语法格式如下：
do {
循环语句；
}while(布尔表达式)
do...while循环语句与while循环语句的主要区别是，do...while语句的循环语句至少执行一次，代码如下：
x = 10
do{
print(x+" ")
x += 1
}while (x < 20)
5.方法和函数
scala的方法是类的一部分，而函数是一个对象可以赋值给一个变量。scala中可以使用def语句和val语句定义函数，而定义方法只能使用def语句。
方法：
scala方法的定义格式如下：
def functionName([参数列表]):[return type]={
function body
return [expr]
}
下面，定义一个方法add,实现两个数相加就和，代码如下：
def add(a: Int, b: Int): Int={
var sum:Int = 0
sum = a + b
return sum
}
scala方法调用的格式如下：
//没有使用实例的对象调用格式 functionName(参数列表) //方法使用实例的对象来调用，我们可以使用类似java的格式（使用“.”号） [instance.]functionName(参数列表)
下面，在类Test中，定义一个方法addInt，实现两个整数相加求和。在这里，我们通过“类名。方法名（参数列表）”来进行调用，代码如下：
:paste //进入多行输入模式
object Test{
def addInt(a: Int, b: Int): Int={
var sum: Int = 0
sum = a + b
retrun sum
}
}
ctrl+D //退出多行输入模式
Test.addInt(4,5)
val addInt = (a: Int, b: Int) => a + b
（1）方法转换成函数：
方法转换成函数格式如下：
val f1 = m _
方法名m后紧跟一个空格和一个下划线，是为了告知编译器将方法m转换成函数，而不是要调用这个方法。下面，定义一个方法m，实现将方法m转换成函数，代码如下：
def m(x: Int, y: Int): Int = x + y //方法 val f = m _ //函数
注意：
scala方法的返回值类型可以不写，编译器可以自动推断出来，但是对于递归方法来说，必须要指定返回类型。
scala数据结构
scala提供了许多数据结构，如常见的数组、元组、集合等。
1.数组
数组（Array）主要用来存储数据类型相同的元素
1.1 数组定义与使用
scala中的数组分为定长数组和变长数组，这两种数组的定义方式如下：
new Array[T] (数组长度) //定长数组 ArrayBuffer[T]() //变长数组
注意：定义变长数组时，则需要导包import scala.collection.mutable.ArrayBuffer
下面，我们通过例子来演示scala数组简单使用，具体代码如下：
文件ArrayDemo.scala:
import scala.colletion.mutable.ArrayBuffer
object ArrayDemo{
def main(array: Array[String]) {
//import scala.collection.mutable.ArrayBuffer
object ArrayDemo {
def main(args: Array[String]): Unit = {
// 定义定长数组：定义长度为8的定长数组,数组中的每个元素都初始化为0
val arr1 = new Array[Int](8)
//打印定长数组，内容就是数组的hashcode值
println(arr1)
//定义边长数组（数组缓冲），需要导入包
val ab = ArrayBuffer[Int]()
//向变长数组中追加元素
ab += 1
//打印变长数组
println(ab)
//向变长数组中追加多个元素
ab += (2,3,4,5)
println(ab)
//追加一个定长数组
ab ++= Array(6,7)
println(ab)
//追加一个变长数组(数组缓冲)
ab ++= ArrayBuffer(8,9)
println(ab)
//在变长数组的某个位置插入元素
ab.insert(0,-1,0) //在0索引位置插入-1和0
println(ab)
//删除数组的某个元素
ab.remove(0)
println(ab)
}
}
1.2 数组的遍历
scala中，如果要获取数组中的每一个元素，则需要将数组进行遍历操作
文件ArrayTraversal.scala:
object ArrayTraversal {
def main(args: Array[String]): Unit = {
//定义定长数组
//val array = new Array[Int](8) //第一种方式
val myArr = Array(1.9, 2.9, 3.4, 3.5) //第二种方式
//打印输出数组中所有元素
for (x <- myArr){
print(x+" ")
}
//打印换行
println()
//计算数组中所有元素的和
var total = 0.0
for (i <- 0 to (myArr.length - 1)){
total += myArr(i)
}
println("总和为："+total)
//查找数组中的最大元素
var max = myArr(0)
for (i <- 1 to (myArr.length - 1)){
if (myArr(i) > max){
max = myArr(i)
}
}
println("最大值：" + max)
}
}
1.3 数组的转换
数组转换就是通过yield关键字将原始的数组进行转换，会产生一个新的数组，然而原始的数组保持不变。定义一个数组，实现将偶数取出乘以10后生成一个新的数组，代码如下：
文件ArrayYieldTest.scala:
object ArrayYieldTest {
def main(args: Array[String]): Unit = {
//定义一个数组
val arr = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)
val newArr = for (e <- arr; if e % 2 ==0) yield e * 10
println(newArr.toBuffer) //将定长数组转为变长数组输出
}
}
2. 元组
scala的元组是对多个不同类型对象的一种简单封装，它将不同的值用小括号括起来，并用逗号作分隔，即表示元组。
2.1 创建元组
创建元组语法如下：
val tuple = (元素，元素...)
创建一个包含String类型，Double类型以及int类型的元组，代码如下：
val tuple = ("itcast",3.14,65535)
2.2 获取元组中的值
在scala中，获取元组宋的值是通过下划线加脚标来获取，元组中的元素脚标是从1开始的。
tuple._1 //获取第一个值 tuple._2 //获取第二个值
3.2 拉链操作
在scala元组中，可以通过使用“zip”命令将多个值绑定在一起。如，定义两个数组，分别是scores和names，将这两个数组捆绑在一起，代码如下：
val scores = Array(88,95,80)
val names = Array("zhangsan ","lisi","wangwu")
names.zip(scores)
3.集合
scala中，集合有三大类：List、Set以及Map
scala集合分为可变（mutable）和不可变（immutable）的集合。
3.1 List
在scala中，List列表和数组类似，列表的所有元素都具有相同类型。这里的list默认是不可变列表，如果要定义可变列表，需要导入“impport scala.collection.mutabe.ListBuffer”包。
定义不同类型列表list，代码如下：
val = fruit:List[String] = List("apples","oranges","pears") //字符串
val nums:List[Int] = List(1, 2, 3, 4) //整型
val empty:List[Nothing] = List() //空
val dim:List[List[Int]] = List(List(1,0,0),
List(0,1,0),
List(0,0,1))
在scala中，可以使用"Nil"和"::"操作符来定义列表。
val fruit = "apples"::("oranges"::("pears"::Nil)) //字符串
val nums = 1::(2::(3::(4::Nil))) //整型
val empty = Nil
val dim = (1::(0::(0::Nil))) ::
(0::(1::(0::Nil))) ::
(0::(0::(1::Nil))) :: Nil
scala也提供了很多操作List的方法：
| 方法名称 | 相关说明 |
|---|---|
| head | 获取列表第一个元素 |
| tail | 返回除第一个之外的所有元素组成的列表 |
| isEmpty | 若列表为空，则返回ture,否则返回false |
| take | 获取列表前n个元素 |
| contains | 判断是否包含指定元素 |
定义一个fruit列表，使用常见的方法对雷暴fruit进行相关的操作，代码如下：
文件ListTest.scala：
object ListTest {
def main(args: Array[String]): Unit = {
//定义List集合
// val fruit2:List[String] = List("apples","oranges","pears")
val fruit = "apples"::("oranges"::("pears"::Nil))
val nums = Nil //空List集合
println("Head of fruit:" + fruit.head)
println("Tial of fruit:" + fruit.tail)
println("Check if fruit is empty:" + fruit.isEmpty)
println("Check if fruit is nums:" + nums.isEmpty)
println("Tack of fruit:" + fruit.take(2))
println("Contains of fruit:" + fruit.contains("apples"))
}
}
3.2.Set
在scala中，Set是没有重复对象的集合，所有元素都是唯一的。默认情况下，scala使用不可变Set集合，若想使用可变的Set集合，则需要引入scala.collection.mutable.Set包。
定义Set集合的语法格式如下：
val set:Set[Int] = Set(1,2,3,4,5)
scala提供了很多操作Set集合的方法。接下来，列举一些操作Set集合的常见方法。
| 方法名称 | 相关说明 |
|---|---|
| head | 获取Set集合第一个元素 |
| tail | 返回除第一个之外的所有元素组成的Set集合 |
| isEmpty | 若Set集合为空，则返回ture,否则返回false |
| take | 获取Set集合前n个元素 |
| contains | 判断Set集合是否包含指定元素 |
定义一个Set集合site，使用常见的方法对集合site进行相关的操作，代码如下：
文件SetTest.scala：
object SetTest {
def main(args: Array[String]): Unit = {
//定义set集合
val site = Set("Itcast","Google","Baidu")
val nums:Set[Int] = Set()
println("第一个网站是："+site.head)
println("最后一个网站是："+site.tail)
println("查看集合site是否为空："+site.isEmpty)
println("查看集合nums是否为空："+nums.isEmpty)
println("查看site的前两个网站："+site.take(2))
println("查看集合中是否包含网站Itcast:"+site.contains("Itcast"))
}
}
3.3 Map
在scala中，Map是一种可迭代的键值对（key/value）结构，并且键是唯一的。若需要使用可变的Map集合，则需要引入import scala.collection.mutable.Map类。
定义Map集合的语法格式如下：
var A:Map[Char,Int] = Map(键 -> 值，键 ->值...) //Map键值对，键为Char,值为Int
scala也提供很多操作Map集合的方法，接下来，列举一些操作Map集合的常见方法：
| 方法名称 | 相关说明 |
|---|---|
| () | 根据某个键查找对应的值，类似于java中的get（） |
| contains() | 检查Map中是否包含某个指定的键 |
| getOrElse() | 判断是否包含键，若包含返回对应的值，否则返回其他的 |
| keys | 返回Map所有的键（key） |
| values | 返回Map所有的值（value） |
| isEmpty | 若Map为空时，返回ture |
定义一个Map集合colors，使用Map常见的方法对集合colors进行先关操作，代码如下：
文件MapTest.scala：
object MapTest {
def main(args: Array[String]): Unit = {
//定义Map集合
val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF", "peru" -> "#CD853F")
val peruColo = if (colors.contains("peru")) colors("peru") else 0
val azureColo = colors.getOrElse("azure", 0)
print("获取colors中键为red的值：" + colors("red"))
println("获取colors中所有的键：" + colors.keys)
println("获取colors中所有的值：" + colors.values)
println("检测colors是否为空：" + colors.isEmpty)
println("判断colors中是否包含键peru,包括含则返回对应的值，否则返回0：" + peruColo)
println("判断colors中是否包含键azure,包括含则返回对应的值，否则返回0：" + azureColo)
}
}
scala面向对象的特征
scala是一种面向对象的语言
1. 类与对象
无论是在scala中还是java中，类都是对象的抽象，二对象都是类的具体实例：
创建类的语法格式如下：
class 类名[参数列表]
类创建好之后，若是想要访问类中的方法和字段，就需要创建一个对象。
创建对象的语法格式如下：
类名 对象名称 = new 类名();
创建一个Point类，并在类中定义两个字段x和y以及一个没有返回值的move方法，使用Point类的实例对象来访问类中的方法和字段，代码如下：
文件ClassTest.scala：
//定义类
class Point(xc:Int,yc:Int){
var x:Int = xc
var y:Int = yc
def move(dx:Int, dy:Int): Unit = {
x = x + dx
y = y + dy
println("x的坐标点："+ x)
println("y的坐标点："+ y)
}
}
object ClassTest {
def main(args: Array[String]): Unit = {
//定义类对象
val pt = new Point(10, 20)
//移动一个新的位置
pt.move(10,10)
}
}
2. 继承
scala和java类似，只允许继承一个父类。不同的是，java只能继承父类中非私有的属性和方法。而scala可以继承父类中的所有属性和方法。
在scala子类继承父类的时候，有几点需要注意：
-
如果子类要重写一个父类中的非抽象方法，则必须使用override关键字，否则会出现语法错误。
-
如果紫烈要重写父类中的抽象方法时，则不需要使用override关键字。
创建一个Pt类和一个Location类，并且Location类继承Pt类，演示子类Location重写父类Pt中的字段，代码如下：
文件ExtendsTest.scala：
//定义父类Point类
class Pt(val xc:Int, val yc:Int){
var x:Int = xc
var y:Int = yc
def move(dx:Int, dy:Int): Unit = {
x = x + dx
y = y + dy
println("x的坐标点：" + x)
println("y的坐标点：" + y)
}
}
//定义子类:Location,继承Point类
class Location(override val xc:Int, override val yc:Int, val zc:Int) extends Pt(xc, yc) {
var z:Int = zc
def move(dx:Int, dy:Int, dz:Int):Unit = {
x = x + dx
y = y + dy
z = z + dz
println("x的坐标点：" + x)
println("y的坐标点：" + y)
println("z的坐标点：" + z)
}
}
object ExtendsTest {
def main(args: Array[String]): Unit = {
//创建一个子类对象:Location
val loc = new Location(10, 20, 15)
//移动到一个新的位置
loc.move(10,10,5)
}
}
3. 单例对象和伴生对象
在scala中，没有静态方法或静态字段，所以不能用类名直接访问类中的方法和字段，而是创建类的实例对象去访问类中的方法和字段。但是，scala中提供了object这个关键字用来实现单例模式，使用关键字object创建的对象为单例对象。
创建单例对象的语法格式如下：
object objextName
创建一个单例对象SingletonObject，代码如下：
文件Singleton.scala：
//创建单例对象
object SingletonObject{
def hello(): Unit = {
println("Hello,This is Singleton Object")
}
}
object Singleton {
def main(args: Array[String]): Unit = {
SingletonObject.hello()
}
}
在scala中，在一个源文件中有一个类和一个单例对象，若单例对象名与类名相同，则把这个单例对象称作伴生对象（companion object）；这个类则被称为是单例对象的伴生类（companion class）。类和半身对象之间可以互相访问私有的方法和字段。
定义一个伴生对象Dog，演示操作类中的私有方法和字段。代码如下：
文件Dog.scala：
//创建类
//伴生类
class Dog{
val id = 666
private var name = "二哈"
def printName(): Unit ={
//在Dog类中可以访问伴生对象Dog的私有字段
println(Dog.CONSTANT + name)
}
}
//伴生对象
object Dog {
//伴生对象中添加私有字段
private var CONSTANT = "汪汪汪..."
def main(args: Array[String]): Unit = {
val dog = new Dog
dog.name = "二哈 666"
dog.printName()
}
}
4. 特质
在scala中，Trait（特质）的功能类似于java中的接口，scala中的Trait可以被类和对象（Objects）使用关键字extends来继承。
创建特质的语法格式如下：
trait traitName
创建一个特质Anima，演示类继承特质并访问特质中方法的操作。代码如下：
文件People.scala：
//定义特质
trait Animal{
//定义一个抽象方法（没有实现的方法）
def speak()
def listen(): Unit ={
}
def run(): Unit ={
println("I am running")
}
}
//定义类，继承特质
class People extends Animal{
override def speak(): Unit = {
println("I am speaking English")
}
}
object People {
def main(args: Array[String]): Unit = {
val people = new People
people.speak()
people.listen()
people.run()
}
}
scala的模式匹配与样例类
scala提供了强大的模式匹配机制，最常见的模式匹配就是match语句，主要应用从多个分支中进行选择的场景。
1. 模式匹配
scala中的模式匹配是由match case组成的，它类似于java中的switch case，即对一个值进行条件判断，针对不同的条件，进行不同的处理。
表达式 match {
case 模式1 => 语句1
case 模式2 => 语句2
case 模式3 => 语句3
}
定义一个方法matchTest()，方法的参数是一个整数字段，而方法的调用则是对参数进行模式匹配，若参数匹配的是1，则打印输出"one"；若参数匹配的是2.则打印输出”two“，若参数匹配的是_，则打印输出"many"，代码如下：
文件PatternMatch.scala：
object PatternMatch {
def main(args: Array[String]): Unit = {
println(matchTest(1))
}
def matchTest(x:Int):String = x match {
case 1 => "one"
case 2 => "two"
case _ => "many"
}
}
2. 样例类
在scala中，使用case关键字来定义的类被称为样例类。样例类时一种特殊的类，经过优化可以被用于模式匹配。我们使用case定义样例类Person，并将该样例类应用到模式匹配中，代码如下：
文件CaseClass.scala：
object CaseClass {
//定义样例类
case class Person(name:String, age:Int)
def main(args: Array[String]): Unit = {
//创建样例类对象
val alice = new Person("Alice", 25)
val bob = new Person("Bob", 32)
val charlie = new Person("charlie", 32)
// val tom = Person("tom", 25)
//使用样例类来进行模式匹配
for (person <- List(alice, bob, charlie)){
person match {
case Person("Alice", 25) => println("Hi Alice")
case Person("Bob", 32) => println("Hi Bob")
case Person(name, age) => println("Name:" + name + "\t" + "age:" + age)
}
}
}
}
标签：val,scala,Int,基础,数组,println,spark,def 来源： https://www.cnblogs.com/LackyQueen/p/16449909.html