spark 期末复习_spark期末复习

Scala

object HelloWorld {
def main(args: Array[String]): Unit = {

    var res = for (i <- 1 to 10 if i % 2 == 0) yield { //生成器，变量每一次都会被初始化

      breakable{
        if(i>=8) break
        println(i)
      }
         i
    }

  print(res)
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

数据结构：

数组：

Array：可变，元素相同类型

var arr =new Array[Int](5)
var arr2 = Array("GigData","Spark")
1
2

元组：

可以包含不同的类型。

var tuple =("BigData",1,0.1)
1

scala> tuple._1
res0: String = BigData
1
2
3

List:

相同类型的不可变序列，scala.collection.immutable包

var strList = List("Hadoop","BigData","Spark")
1

val mutableList =ListBuffer(10,20,30)
  mutableList +=40 //在尾部添加40
  println(mutableList)
 mutableList.insert(0,5)
  println(mutableList)
  mutableList.remove(0)
  println(mutableList)
1
2
3
4
5
6
7

ListBuffer(10, 20, 30, 40)
ListBuffer(5, 10, 20, 30, 40)
ListBuffer(10, 20, 30, 40)

Range

不可变，带索引的一个等差序列

val v =new Range(1,10,2)//第一个是起始，第二个是终止，第三个是步长
  for( i <- v){
    println(i)
  }
}
1
2
3
4
5

集合：

Set：不重复元素的容器

var myset =Set("Hadoop","Spark")
myset+="Scala"
1
2

映射Map

var myMap = Map("1" -> "laowang", "2" -> "zhanghua")
    myMap("3") = "wahaha"
    myMap +="4"->"hehe"
println(myMap)
1
2
3
4

Map(2 -> zhanghua, 1 -> laowang, 4 -> hehe, 3 -> wahaha)

迭代器

  val iter =Iterator("Hadoop","Spark","Scala")
    while (iter.hasNext){
      println(iter.next())
    }
    
1
2
3
4
5

可见性

默认设为公有。有类似getter和setter的方法，是value和value_=

def value = privateValue
def value_=(newValue : Int) {
if(newValue > 0) privateValue =newValue 
}

myCounter.value_=(3)
1
2
3
4
5
6

方法的定义方式

• 不能用val或var来定义，所有的方法都是不可变的。无参方法可以省略括号，但是调用 时也要省略括号。如果方法只有一个参数，可以省略‘.’
• 如果返回的结果类型可以从最后的表达式中推导出，方法定义中可以省略结果类型。如果方法体只有一条语句，还可以省略大括号。

构造器

主构造器：所以位于类方法之外的语句都将在构造过程中被执行。可以向定义方法参数一样，在类名之后用圆括号列出主构造器的参数列表。

class Counter(name:String){

}
1
2
3

辅助构造器：：使用this来定义，this的返回类型是Unit。每个辅助构造器的第一个表达式必须是调用一个此前已经定义的辅助构造器或主构造器，调用的形式为this(参数列表) ，这意味着每一个辅助构造器最终都会调用主构造器。

class Counter(name:String){
private  var password =''
private var username =name
def this(password:String){
this()//调用主构造器
this.password =password
}
}
1
2
3
4
5
6
7
8

与方法中的参数不同，主构造器中的参数可以使用val或var，scala内部将自动为这些参数创建私有字段
如果没使用var和val的话，构造器参数在构造器退出后将被丢弃

对象

单例对象

用object来定义单例对象，单例对象的性质类似于java中的静态成员。
单例对象分两种：

• 伴生对象：当单例对象和它的同名类一起出现的时候
• 孤立对象：没有同名类

伴生对象和它的伴生类必须在同一个文件中，他们之间可以相互访问对方的私有成员。

apply方法

当用括号给实例或单例对象传参时，对应的实例或单例对象会在找符合传入参数的apply方法，并调用该apply方法。

object TestClass{

def apply(name:String) =new TestClass(name)
}
class TestClass(name:String){
var username =name

}
obiect MainClass{
def main(args:Array[String]){
val testclass = TestClass("laowang")
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13

unapply方法

apply的反向操作

继承

抽象类：如果一个类包含没有实现的成员，则必须要abstract进行修饰，定义为抽象类。
继承：只能支持单一继承，使用extends表示继承关系。

• 重载父类的抽象成员：重载父类的抽象成员时，override是可选的，而重载父类的非抽象成员时，override是必选的。
• 只能重载val类型的字段，而不能重载var类型的字段。因为var类型本身就是可变的，所以，可以直接修改它的值，无需重载。