Spark-【坚实地基】Scala入门详解

一、变量

//变量的声明
//var变量、val常量
val x:String = "11234" //声明数据类型
var x = xxx  //自动判断数据类型

二、基础技能

1.字符串S插值器

val name = "Bob"
println(s"Hello,${name}")
//输出结果：Hello,Bob

其他插值器：

2.三元运算符

三元运算符统一用if…else

val x = 30;
val y = if(x==20) x else 20+x
print(y)
//输出：50

3.循环控制

① while循环

语法与java语法相差无几

var num:Int =0;
while(num=100){
	println(num);
	num=num+1
}
var num:Int =0;
do{
println(num);
	num=num+1
}
while(num=100)

② for循环

普通循环

注：to是前后包含，until是前包含后不包含

var num:Int = 20;
for(i<-1 to num){
	println(i);
}
for(i<-1 until num){
	print(i);
}

增强型for循环

var num:Int =20;
for(i<- num){
	println(i)
}

③ 循环控制

1) break

import scala.util.control.Breaks._
var num:Int = 10;
for(i<- 1 to 10){
	if(i==6){
		break;
	}
println(i);
}

2) 使用代码块breakable{…}实现“continue”

import scala.util.control.Breaks._
for(i<- 1 to 10){
	breakable{
		if(i==6){
			break;
		}
	println(i);
	}
}

3) yield返回值

说明：for循环中的yield会把当前的元素记下来，保存在集合中，循环结束后将返回该集合rVal

var num = 10;
var rVal = for(i<-1 to num;if i%2==0;if i>5) yield i;
for(a<-rVal){
	println(a);
}
//输出：6 8 10

4) 下划线含义

1. 作为“通配符”，类似Java中的*。

import scala.util.control.Breaks._;

2. :_*作为一个整体，告诉编译器你希望将某个参数当作参数序列处理

三、方法定义

最后一句话代表返回值（return）,unit为无返回值
方法名 形参 返回值类型

def abc(x:Int):Int = {
x+2
}
//方法调用
abc(10)

//注：map关键字，map可以将集合y中的元素一个个拿出，再放回去
y:Array[Int] = Array(1, 2, 3)
//正常使用，y元素作为传参
y.map(x=>x+2)  /   y map(x=>x+2)
res34: Array[Int] = Array(3, 4, 5)

//y元素作为传参
y.map(abc)     /   y map abc
res34: Array[Int] = Array(3, 4, 5)

//下划线的意义 _:临时代表从y中拿出的元素，只能用一次！
y.map(_+2)

四、Scala偏函数

在Scala中,偏函数是具有类型PartialFunction[T,V]的一种函数。T是其接受的函数类型，V是其返回的结果类型。
偏函数的特点：

1. 只接受和处理其参数定义域的一个子集，而对于这个自己之外的参数则跑输运行时异常。
2. 与Case的语句的特点非常契合，因为我们在使用case语句时，常常是匹配一组具体的模式，最后用“_”来代表剩余的模式。如若一组case语句没有涵盖所有的情况，那么这组case语句就可以被看做是一个偏函数

代码示例

val signal:PartialFunction[Int,Int] = {
	case x if x>=1 => 1
	case x if x<=1 =>-1
}

五、List的基本介绍和创建

基本介绍

• Scala的List与java中的List不一样，其List可以直接存放数据，是一个object,默认情况下Scala的List是不可变的，List属于序列Seq
• val List = scala.collection.immutable.List
• object List extends SeqFactory[List]

① 创建List

object ListDemo01 {
  def main(args: Array[String]): Unit = {
    //1.在默认情况下List是scala.collection.immutable.List,是不可变的
    //2. 在scala中,List就是不可变的,如需要使用可变的List,则使用ListBuffer
    //3. List在package object 中做了声明,可直接使用
    val list01 = List(1,2,3,4)
    println(list01)
    val list02 = Nil //空集合
    println(list02)
  }
}

输出：

上面案例总结：

1. List默认为不可变的集合
2. List在scala包对象声明，因此不需要引入其他包也可以使用
3. 如果希望得到一个空裂变，可以使用Nil对象

List的追加注意事项

注意事项：向List中增加元素，会返回一个新的列表/集合对象。注意：Scala中List元素的追加和Java不一样

object ListDemo01 {
  def main(args: Array[String]): Unit = {
    //1.在默认情况下List是scala.collection.immutable.List,是不可变的
    //2. 在scala中,List就是不可变的,如需要使用可变的List,则使用ListBuffer
    //3. List在package object 中做了声明,可直接使用
    val list01 = List(1,2,3,4)
    println(list01)
    val list02 = Nil //空集合
    println(list02)
    val list03 = list01:+"a"
    println(list03)
  }
}

输出：

注 ：::（两个）的使用
说明：

• 符号::表示向集合中新建集合添加元素
• 运算时，集合对象一定要放置在最右边
• 运算规则，从右向左
• :::(三个冒号)运算符是将集合中的每一个元素加到空集合中，左右只能接集合

val list03 = List(1,2,3,4,"a")
    println(list03)
    //说明
    //1. List()
    //2. List(List(1,2,3,4,"a"))
    //3. List(6,List(1,2,3,4,"a"))
    //4. List(5,6,List(1,2,3,4,"a"))
    //5. List(4,5,6,List(1,2,3,4,"a"))
    val list04 = 4 :: 5 :: 6 ::list03 :: Nil
    println("list04: "+ list04)
    //说明
    //1. List()
    //2. List(1,2,3,4,"a")
    //3. List(6,1,2,3,4,"a")
    //4. List(5,6,1,2,3,4,"a")
    //5. List(4,5,6,1,2,3,4,"a")
    val list05 = 4 :: 5 :: 6 :: list03 ::: Nil
    println("list05: "+ list05)

输出：

列表ListBuffer

特点：ListBuffer是可变的List集合，可以添加，删除元素，ListBuffer属于序列
list的增删查操作实例：

object ListBufferdemo01 {
  def main(args: Array[String]): Unit = {
    //创建
    val lst0 = ListBuffer[Int](1,2,3)
    //如何访问
    println("lst0(2)="+lst0(2))
    for (item <- lst0){
      println("item= " + item)
    }

    //动态的追加元素,lst1本身变化
    val lst1 = new ListBuffer[Int] //空ListBuffer
    lst1+=4
    println("lst1="+lst1)
    lst1.append(0,12,6)
    println("lst1="+lst1)
    //追加其他集合元素
    lst0 ++= lst1
    println("lst0="+lst0)
    val lst2 = lst0 ++ lst1
    println("lst2: "+lst2)
    //其他追加
    val lst3 = lst0 :+ 5
    println("lst3:" + lst3)
    //List的删除
    println("======删除========")
    println("lst1="+lst1)
    lst1.remove(1) //表示把下标为1的元素删除
    println("lst1="+lst1)
  }

}

输出：