大数据处理技术基础语法练习（scala，RDD）

eclipse实现

import scala.collection.mutable.ListBuffer

object test {
def main(args: Array[String]): Unit = {
print1()
print2()
print3()
println(print4(1,4))
print5()
print6()
print7()
print8()
print9()
//练习10
val p=new Point(1,2)
p.move(10, 20)
val location = new Location(1,2,3)
location.move(10,20)
//练习11
val cat =new Cat()
cat.showName(“test”)
cat.eat(“test”)
}

练习1：val、var 变量分配的区别

//练习1：val、var 变量分配的区别
//定义一个方法，方法内容如下：使用val、var定义一些变量并分配

def print1():Unit={
val str1=“hello”
//str1=“world” //val初始化后就不能再被赋值
println(str1)
var str2=“hi”
println(str2)
str2=“world” //var定义变量后可以重新赋值
println(str2)
}

练习2：Range的操作

 //练习2：Range的操作
 //定义一个方法，方法内容如下：Range的定义、类型转成List。

def print2(): Unit = {
println(1 to 10)
println((1 to 10).toList)
println((1 until 10).toList)
println((1 to 10 by 3).toList)
println((10 to 1 by -3).toList)
println((1L to 10L by 2).toList)
println((1.1f to 10.3f by 3.1f).toList)
println((1.1 to 10.3 by 3.1).toList)
println((‘a’ to ‘z’ by 3).toList)
}

练习3：位运算符

//练习3：位运算符
//定义一个方法，方法内容如下：位运算符（& | ^)的基本操作和方法调用方式

def print3(): Unit = {
var a=1
println(a.&(1))
println(a.&(0))
println(a.|(1))
println(a.|(0))
println(a.^(1))
println(a.^(0))
}

练习4：定义一个sum方法或者函数,返回指定区间的值的和

//练习4：定义一个sum方法或者函数,返回指定区间的值的和
//例如，区间[1,4]的和为1+2+3+4=10

def print4(a:Int,b:Int):Int={
var sum:Int = 0
var c=b
while(c>=a){
sum=sum+c
c=c-1
}
sum
}

练习5：List类型的使用

//练习5：List类型的使用

def print5():Unit={

//要求1: 定义不可变的List
//试用如下方法 :: 、 :::、concat、filter、map、append

val site1:List[String]=List(“baidu”,“google”)
val site2= “Baidu”:😦“google”:😦“bing”::Nil))
val site3:List[String]=“hello”::“hi”::Nil
val num1:List[Int]=List(1,2,3)
val num2:List[Int]=4::5::6::Nil
val site123=site1:::site2:::site3
val site12=List.concat(site1,site2)
val num=num1:::num2
println(site1)
println(site2)
println(site3)
println(num1)
println(num2)
println(site123)
println(site12)
println(num.filter(x=>x%2==0))
println(num.map(x=>x*2))
//num1.append(66) //定长List不能使用append

//要求2：定义可变的List
//试用如下方法 :: 、 :::、concat、filter、map、append

val lst0 = ListBuffer[Int](1, 2, 3)
lst0 +=4
lst0.append(5)
println(lst0)
val lst1 = ListBufferInt
//val lst1=1::2::lst0 //可变List不能使用::
//val lst01=lst0:::lst1 //可变List不能使用:::
val lst01=List.concat(lst0,lst1)
println(lst01)
println(lst0.filter(x=>x%2==0))
println(lst0.map(x=>x*3))
println(lst0.append(6))
}

练习6：Set类型的使用

//练习6：Set类型的使用
//要求1：Set的唯一性检验

def print6(): Unit = {
val set=Set(1,2,2,3,4)
println(set)
}

练习7：Tuple元组 的使用

//练习7：Tuple元组的使用

def print7(): Unit = {

//要求1: 对元组进行定义和赋值

val t=(1,3.14,“ha”)
val t1=new Tuple3(1,2,“aa”)

//要求2：元组的取值访问（通过下标、迭代器）

println(t._1)
println(t1._2)
var iterator = t.productIterator
while(iterator.hasNext){
val ele = iterator.next()
println(“ele:”+ ele)
}
}

练习8：使用迭代器访问map

//练习8：使用迭代器访问map
//要求1：通过迭代器访问map的key、value

def print8(): Unit ={
val map1=Map(“a”->1,“b”->2,“c”->3)
val iterator =map1.iterator
while(iterator.hasNext){
val ele=iterator.next()
println(“key:”+ele._1+";value:"+ele._2)
}
}

练习9：groupBy的使用

//练习9：groupBy的使用

def print9(): Unit = {

//要求1：List[Int]进行分组

val num:List[Int]=List(1,2,3,4,5,6)
println(num.groupBy(x=>x%2==0))

 //要求2：对List[String]根据首字母进行分组

val list1:List[String]=List(“apple”,“cup”,“table”,“take”,“coffee”,“coffer”)
println(list1.groupBy(x=>x.charAt(0)))
}

练习10：普通类的继承关系实验

//练习10：普通类的继承关系实验
//要求1: 普通父类定义

class Point(xc: Int, yc: Int) {
var x: Int = xc
var y: Int = yc

def move(dx: Int, dy: Int) {
x = x + dx
y = y + dy
println ("x : " + x);
println ("y : " + y);
}
}

 //要求2：子类定义，子类对父类方法的override

class Location(val xc: Int, val yc: Int,
val zc :Int) extends Point(xc, yc){
var z: Int = zc

override def move(dx: Int, dy: Int) {
x = x + dx + 100
y = y + dy + 100
println ("x location : " + x);
println ("y location : " + y);
}

def move(dx: Int, dy: Int, dz: Int) {
x = x + dx
y = y + dy
z = z + dz
println ("x : " + x);
println ("y : " + y);
println ("z : " + z);
}
}

练习11：抽象类的继承关系实验

//练习11：抽象类的继承关系实验
//要求1: 抽象类型的父类定义
//要求2：子类定义，子类对父类方法的override

abstract class Animal {
def showName(str:String)={println(“animal”)}
def eat(food:String)
}
class Cat extends Animal {
override def showName(str:String)={println(“cat”)}
def eat(food:String) = {println(“fish”)}
}
}

练习12：RDD的创建

def print12(): Unit = {

//要求1: 通过数组、列表创建 

val array=Array(1,2,3)
val conf=new SparkConf().setAppName(“print12”).setMaster(“local”)
val sc=new SparkContext(conf)
val rdd1=sc.parallelize(array)
println(rdd1.collect().mkString(", “))
val list=List(1,2,3,4,5)
val rdd2=sc.parallelize(list)
println(rdd2.collect().mkString(”, "))

//要求2: 通过文件创建

val testFile = sc.textFile("/home/aa.txt")
}

练习13：练习常用的RDD转换操作算子方法

def print13(): Unit = {
val conf=new SparkConf().setAppName(“print13”).setMaster(“local”)
val sc=new SparkContext(conf)

//要求1: 窄依赖操作（map、filter、flatMap等）

val x = sc.parallelize(Array(“b”, “a”, “c”))
val y = x.map(z => (z,1))
println(x.collect().mkString(", “))
println(y.collect().mkString(”, “))
val x1 = sc.parallelize(Array(1,2,3))
val y1 = x1.filter(n => n>2)
println(x1.collect().mkString(”, “))
println(y1.collect().mkString(”, “))
val y2 = x1.flatMap(n => Array(n, n*100, 42))
println(y2.collect().mkString(”, "))

//要求2: 宽依赖操作（groupby、distinct、coalesce等）

val x3 = sc.parallelize(Array(1,2,3,4,5,3,2,4))
val y3 = x3.distinct()
println(x3.collect().mkString(", “))
println(y3.collect().mkString(”, “))
val x4 = sc.parallelize(Array(“John”, “Fred”, “Anna”, “James”))
val y4 = x4.groupBy(w => w.charAt(0))
println(y4.collect().mkString(”, "))
val x5 = sc.parallelize(Array(1, 2, 3, 4, 5), 3)
val y5 = x5.coalesce(2)
val xOut = x5.glom().collect()
val yOut = y5.glom().collect()
}

练习14：行动（Action）操作算子方法

//要求1: 练习 reduce, saveAsTextFile方法

def print14(): Unit = {
val conf=new SparkConf().setAppName(“print14”).setMaster(“local”)
val sc=new SparkContext(conf)
val x = sc.parallelize(Array(1,2,3,4))
val y = x.reduce((a,b) => a+b)
println(x.collect.mkString(","))
println(y)
x.saveAsTextFile("/home/out.txt")
val out = sc.textFile("/home/out.txt")
print(out.collect())
}

练习15：RDD的分区操作、分区个数查看

def print15(): Unit = {
val conf=new SparkConf().setAppName(“print15”).setMaster(“local”)
val sc=new SparkContext(conf)

//要求1：使用 textFile、parallelize 完成RDD分区操作   

val rdd1 = sc.parallelize(Array(1,2,3),5)
println(rdd1.partitions.size)
val rdd2 = sc.textFile(“home/aa.txt”,2)
println(rdd2.partitions.size)

//要求2: 使用 repartition 完成RDD分区操作

val rdd3 = rdd1.repartition(3)
println(rdd3.partitions.size)
}

练习16：定义一个方法实现手机号码段数量统计

要求说明：
1、数据格式：完整手机号
15012345678
15X45670981
15012345689
15915001234
17612341500
2、数据存放到文件里。
3、读取文件
4、判断每一行数据的手机号是否是正确的（使用正则去判断是否是11位的有效数字）
对于错误的手机号要打印。
5、方法的入参是一个整型类型的参数，代表手机号前三位（例如 150），按照匹配完整手机号前三位的正则规则，将符合条件的数据以List[Long]类型进行返回。
import java.io._
import scala.io.Source
import scala.util.matching.Regex
import scala.collection.mutable.ListBuffer
object test16 {
def main(args: Array[String]): Unit = {
Input()
check(150)
}

//将数据存放到文件里

def Input(): Unit={
val nums=new PrintWriter(new File("/home/phone.txt"))
nums.println(“15012345678”)
nums.println(“15X45670981”)
nums.println(“15012345689”)
nums.println(“15915001234”)
nums.println(“17612341500”)
nums.close()
}

//读取文件并判断每一行的数据是否正确以及是否符合要求

def check(num:Int){
val phone=for(line<-Source.fromFile("/home/phone.txt").getLines)yield line
val phonelist:List[String]=phone.toList
for(line<-phonelist){
if(!(line.matches("\d{11}")))
println(“The wrong number : “+line)}
println(“The first three number is “+num+” :”)
for(line<-phonelist){
if(line.matches(num+”\d{8}”)){
println(line.toLong)}
}
}
}

Spark 案例练习

任务1: 开发一个Spark的单词计数程序

//要求1: 在IDE里开发和运行。
//要求2: 通过spark提交jar，并运行。

import org.apache.spark.SparkContext
import org.apache.spark.SparkContext._
import org.apache.spark.SparkConf

object WordCount {
def main(args: Array[String]) {
val inputFile = “/home/dataset/helloSpark.txt”
val conf = new SparkConf().setAppName(“WordCount”).setMaster(“local[2]”)
val sc = new SparkContext(conf)
val textFile = sc.textFile(inputFile)
val wordCount = textFile.flatMap(line => line.split(" ")).map(word => (word, 1)).reduceByKey((a, b) => a + b)
wordCount.foreach(println)
}
}

任务2：找出单科成绩为100的学生ID

//数据文件在QQ群的群文件中。

import org.apache.spark.SparkContext
import org.apache.spark.SparkConf

object stu{
def main(args: Array[String]): Unit = {
result()
}
def result(): Unit={
val conf=new SparkConf().setAppName(“result”).setMaster(“local”)
val sc=new SparkContext(conf)
val lines=sc.textFile("/root/student/student.txt")
val math=sc.textFile("/root/student/result_math.txt")
val m_math = math.map{x=> val line=x.split(" “);(line(0),line(1),line(2).toInt)}
val bigdata = sc.textFile(”/root/student/result_bigdata.txt")
val m_bigdata = bigdata.map{x=>val line=x.split(" ");(line(0),line(1),line(2).toInt)}
val student_100 = m_math.filter(_.3 == 100).union(m_bigdata.filter(.3 == 100))
val result = student_100.map(._1).distinct
val resultArray = result.collect
println(resultArray)

}

}

scala实现

课堂练习1：val、var 变量分配的区别

val、var定义一些变量并分配
要求1: 将操作结果进行截图，并上传到gitee中
要求2：编写readme.md

val str1="hello"
str1="world"
var str2="hi"
str2="world"
str1
str2
var num1=123456
str1+str2
str1+num1

课堂练习2：Range的操作

Range的定义、类型转成List。
要求1: 将操作结果进行截图，并上传到gitee中
要求2：编写readme.md

1 to 10
1 until 10
1 to 10 by 3
1 until 10 by 3
10 to 1  by -3 
1L to 10L by 2
1.1f to 10.3f by 3.1f
1.1 to 10.3 by 3.1
‘a’ to ‘z’ by 3
(1 to 10).toList
(‘a’ to ‘z’).toList

课堂练习3：位运算符

位运算符（& | ^)的基本操作和方法调用方式。
要求1: 将操作结果进行截图，并上传到gitee中
要求2：编写readme.md

val a=1
a.&(1)
a.&(0)
a.|(1)
a.|(0)
a.^(1)
a.^(0)

课堂练习4：固定长度的数组练习

固定长度数组定义、常用方法。
要求1: 将操作结果进行截图，并上传到gitee中
要求2：编写readme.md

val intArr = new Array[Int](5)
val intArr1 = Array(1,2,3,4,5)
intArr1.length
intArr1.head
intArr1.tail
intArr1.isEmpty`在这里插入代码片`
intArr.isEmpty
intArr1.contains(3)
intArr1.contains(9)

课堂练习5：变长长度的数组练习

变长数组定义、常用方法。
要求1: 将操作结果进行截图，并上传到gitee中
要求2：编写readme.md

import scala.collection.mutable.ArrayBuffer
val buf = new ArrayBuffer[Int]()
buf += 11
buf += 16
buf += 21
buf
buf.length
buf.head
buf.tail
buf.isEmpty
buf.contains(16)
buf(1)
buf.trimEnd(1)
buf
buf.insert(0,12,15,18)
buf
buf.remove(4)
buf
buf.toArray

课堂练习1：定义一个sum函数,返回指定区间的值的和

例如，区间[1,4]的和为1+2+3+4=10
要求1: 将操作结果进行截图，并上传到gitee中
要求2：编写readme.md

val sum =(a:Int,b:Int)=>{
var sum:Int=0
var b1=b
while(b1>a){
sum=sum+b1
b1=b1-1
}
sum
}
sum(1,4)

课堂练习2：分别定义一个方法、一个函数并调用

要求1: 将操作结果进行截图，并上传到gitee中
要求2：编写readme.md

val max =(a:Int,b:Int)=>{
if(a>b)
a
else
b
}
def min(a:Int,b:Int):Int={
if(a>b)
b
else
a
}
max(1,3)
min(1,3)

课堂练习1：List类型的使用

要求1: 定义不可变的List
试用如下方法 :: 、 :::、concat、filter、map、append。
要求2：定义可变的List
试用如下方法 :: 、 :::、concat、filter、map、append。

val site1:List[String]=List("baidu","google")
val site2= "Baidu"::("google"::("bing"::Nil))
val site3:List[String]="hello"::"hi"::Nil
val num1:List[Int]=List(1,2,3)
val num2:List[Int]=4::5::6::Nil
val site123=site1:::site2:::site3
val site12=List.concat(site1,site2)
val num=num1:::num2
num.filter(x=>x%2==0)
num.map(x=>x*2)
num.append(10)
import scala.collection.mutable.ListBuffer
val lst0 = ListBuffer[Int](1, 2, 3)
lst0 +=4
lst0.append(5)
println(lst0)
val lst1=new ListBuffer[Int]
val lst1=1::2::lst0
val lst1 = ListBuffer[Int](7,8,9)
val lst01=lst0:::lst1
val lst01=List.concat(lst0,lst1)
lst0.filter(x=>x%2==0)
lst0.map(x=>x*3)
lst0.append(20)
println(lst0)

课堂练习2：Set类型的使用

要求1: Set的两种类型（可变、不可变)的定义
要求2：Set唯一性的试验
要求3：Set的增加、删除

val set0=Set(1,2,3)
val set1=Set(1,2,3,3,3)
import scala.collection.mutable.Set
val set2=Set(1,2,3)
set2.add(4)
set2.remove(1)
set2+=5
set2-=4
val set3=set1++set2
val set4=set1.++(set2)
val set5=set1.&(set2)
val set6=set1.intersect(set2)
set2.max
set2.min

课堂练习3：Tuple元组 的使用

要求1: 对元组进行定义和赋值
要求2：元组的取值访问（通过下标、迭代器）

val t1=(1,3.14,"ha")
val t2= new Tuple4(1,2,3.3,"hello")
t1._1
t1._3
val iterator =t2.productIterator
while(iterator.hasNext){
	val ele=iterator.next()
	println("ele:"+ele)}

课堂练习4：使用迭代器访问map

val map1=Map("a"->1,"b"->2,"c"->3)
val iterator =map1.iterator
while(iterator.hasNext){
	val ele=iterator.next()
	println("key:"+ele._1+";value:"+ele._2)}

课堂练习5：groupBy的使用

要求1：对List[Int]进行分组
要求2：对List[String]根据首字母进行分组

val num:List[Int]=List(1,2,3,4,5,6,7,8,9)
num.groupBy(x=>x%2==0)
val list1:List[String]=List("apple","cup","table","take","coffee","coffer")
list1.groupBy(x=>x.charAt(0))

课堂练习1：普通类的继承关系实验

要求1: 普通父类定义
要求2：子类定义，子类对父类方法的override

class Point(xc: Int, yc: Int) {
   var x: Int = xc
   var y: Int = yc

   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
      println ("x : " + x);
      println ("y : " + y);
   }
}
class Location(val xc: Int, val yc: Int,
   val zc :Int) extends Point(xc, yc){
   var z: Int = zc

   override def move(dx: Int, dy: Int) {
      x = x + dx + 100
      y = y + dy + 100
      println ("x location  : " + x);
      println ("y location : " + y);
   }
   
   def move(dx: Int, dy: Int, dz: Int) {
      x = x + dx
      y = y + dy
      z = z + dz
      println ("x   : " + x);
      println ("y   : " + y);
      println ("z   : " + z);
   }
}
val location = new Location(1,2,3)
location.move(10,20)

课堂练习2：抽象类的继承关系实验

要求1: 抽象类型的父类定义
要求2：子类定义，子类对父类方法的override

abstract class Animal {
    def showName(str:String)={println("animal")}
    def eat(food:String)
}
class Cat extends Animal {
    override def showName(str:String)={println("cat")}
    def eat(food:String) = {println("fish")}
}
val cat =new Cat()
cat.showName("test")
cat.eat("test")

课堂练习1：RDD的创建

任务1: 通过数组、列表创建

val array = Array(1,2,3,4,5)
val rdd = sc.parallelize(array)
val list = List(1,2,3,4,5)
val rdd = sc.parallelize(list)

任务2: 通过文件创建

val text=sc.textFile("file:///d:/wendang/hello.txt")

课堂练习2：练习常用的RDD转换操作算子方法

任务1: 窄依赖操作（map、filter、flatMap等）

val x = sc.parallelize(Array("b", "a", "c"))
val y = x.map(z => (z,1))
println(x.collect().mkString(", "))
println(y.collect().mkString(", ")) 
val x = sc.parallelize(Array(1,2,3))
val y = x.filter(n => n>2)
println(x.collect().mkString(", "))
println(y.collect().mkString(", ")) 
val x = sc.parallelize(Array(1,2,3))
val y = x.flatMap(n => Array(n, n*100, 42))
println(x.collect().mkString(", "))
println(y.collect().mkString(", ")) 

任务2: 宽依赖操作（groupby、distinct、coalesce等）

val x = sc.parallelize(Array(1,2,3,4,5,3,2,4))
val y = x.distinct()
println(x.collect().mkString(", ")) 
println(y.collect().mkString(", ")) 
val x = sc.parallelize(Array("John", "Fred", "Anna", "James"))
val y = x.groupBy(w => w.charAt(0))
println(y.collect().mkString(", "))
val x = sc.parallelize(Array(1, 2, 3, 4, 5), 3)
val y = x.coalesce(2)
val xOut = x.glom().collect()
val yOut = y.glom().collect()

课堂练习1：行动（Action）操作算子方法

任务1: reduce

val x = sc.parallelize(Array(1,2,3,4))
val y = x.reduce((a,b) => a+b)
println(x.collect.mkString(", "))
println(y)

任务2: saveAsTextFile

val x = sc.parallelize(Array(1,2,3))
x.saveAsTextFile("file:///d:/output.txt")
var y = sc.textFile("file:///d:/output.txt")
print(y.collect().mkString(","))

课堂练习2：RDD的分区操作、分区个数查看

任务1: textFile、parallelize

val rdd1=sc.parallelize(Array(1,2,3),5)
val rdd2=sc.textFile("file:///d:/wendang/hello.txt",2)
rdd1.partitions.size
rdd2.partitions.size

任务2: repartition

val rdd3=rdd1.repartition(3)
rdd3.partitions.size

课堂练习1：通过IDE开发一个Spark的单词计数程序

任务1: 一个Spark的单词计数程序（object）
要求1: 在IDE里运行。
要求2：上传操作截图

package wordcount

import org.apache.spark.SparkContext
import org.apache.spark.SparkContext._
import org.apache.spark.SparkConf;
import org.apache.spark.rdd.RDD.rddToPairRDDFunctions

object WordCount {
  def main(args: Array[String]): Unit = {
    val inputFile = "file:///D:/words.txt"   
    val conf = new SparkConf().setAppName("WordCount").setMaster("local[2]")    
    val sc = new SparkContext(conf)    
    val textFile = sc.textFile(inputFile)    
    val wordCount = textFile.flatMap(line => line.split(" ")).map(word => (word, 1)).reduceByKey((a, b) => a + b)    
    wordCount.foreach(println)

  }
}

课堂练习2：通过提交jar包方式执行Spark程序

要求1: 在本机的spark里提交jar，并运行。
要求2：上传操作截图

spark-submit --class "wordcount.WordCount" C:\Users\admin\eclipse-workspace\spark-wordcount\target\spark-wordcount-0.0.1-SNAPSHOT.jar

课后作业1：定义方法识别手机号段

用数组分别存储各种类型的手机号段,并且用该方法查询手机号段为133的手机号码类型
要求1: 将操作结果进行截图，并上传到gitee中
要求2：编写readme.md

val yidong=Array(112,122,121,132,123,145,167,156,143,178,187)
val liantong=Array(1121,1212,1321,1432,1423,1545,1567,1756,1743,1768,1587)
val dianxin=Array(191,133,162,183,193,185,172,196,199,166,188,155,177)
def identify(x:Int)={
    if(yidong.contains(x)){
    println("yidong")
    }else if(liantong.contains(x)){
    println("liantong")
    }else if(dianxin.contains(x)){
    println("dianxin")
    }else{
    println("Sorry ,I don't know!")
    }
    }
 identify(133)

课后作业2：统计某个地区的手机号段数量值的和

详细数据参见 第三章课件 第14页
要求1: 将操作结果进行截图，并上传到gitee中
要求2：编写readme.md

 def count(area:String){
     var arr=Array("115036,1477799,guangdong,guangzhou,yidong,020,510000",
     "115038,1477801,guangdong,dongguan,yidong,0769,511700",
     "115033,1477796,guangdong,guangzhou,yidong,020,510000",
     "115032,1477795,guangdong,guangzhou,yidong,020,510000")
     var sum=0
     for(a<-arr;if a.contains(area)){
     sum+=1}
     println(sum)
     }
count("guangzhou")

课后作业： 定义一个方法实现手机号码段数量统计

1、数据格式：完整手机号
15012345678
15X45670981
15012345689
15915001234
17612341500
2、数据存放到文件里。
3、读取文件
4、判断每一行数据的手机号是否是正确的（使用正则去判断是否是11位的有效数字）
对于错误的手机号要打印。
5、方法的入参是一个整型类型的参数，代表手机号前三位（例如 150），按照匹配完整手机号前三位的正则规则，将符合条件的数据以List[Long]类型进行返回。

import java.io._
val nums= new PrintWriter(new File("d:\\phone.txt"))
nums.println("15012345678")
nums.println("15X45670981")
nums.println("15012345689")
nums.println("15915001234")
nums.println("17612341500")
nums.close
import scala.util.matching.Regex
import scala.io._
def check(num:Int){
val phone=for(line<-Source.fromFile("d:\\phone.txt").getLines)yield line
val phonelist:List[String]=phone.toList
for(line<-phonelist){
if(!(line.matches("\\d{11}"))) println("The wrong number : "+line)}
println("The first three number is "+num+" :")
for(line<-phonelist){
if(line.matches(num+"\\d{8}")){println(line.toLong)}
}
}
check(150)

课后作业： 找出单科成绩为100的学生ID

 val lines = sc.textFile("file:///d:/wendang/student")
 val math = sc.textFile("file:///d:/wendang/student/result_math.txt")
 val m_math = math.map{x=> val line=x.split(" ");(line(0),line(1),line(2).toInt)}  
 val bigdata = sc.textFile("file:///d:/wendang/student/result_bigdata.txt")
 val m_bigdata = bigdata.map{x=>val line=x.split(" ");(line(0),line(1),line(2).toInt)}
 val student_100 = m_math.filter(_._3 == 100).union(m_bigdata.filter(_._3 == 100))
 val result = student_100.map(_._1).distinct
 val resultArray = result.collect