spark递归查询

练习1：List类型的使用

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

1.1 不可变的List

• :: 方法

// 1. Nil为空列表，使用 :: 将元素放入列表中
val list01 = "baidu" :: "google" :: Nil

val list02 = "Facebook" :: "taobao"::Nil

• ::: 方法

//2.  ::: 来连接两个列表
val list03 = list01 ::: list02
// List(baidu, google, Facebook, taobao)

• concat方法

// 3. 连接两个列表
val list04 = List.concat(list01,list02)

• List.::: 方法

// 4. 将list02插入到list01前面生成一个新的集合
val list05 = list01.:::(list02)

• filter

val intList = List(1,2,3,4,5,6)

//5.  过滤，取符合条件的，创建新列表，取偶数
intList.filter(x => x%2 == 0)
// res6: List[Int] = List(2, 4, 6)

• map方法

// 6. 每个元素都做了相同的操作,对每个元素都乘了3
intList.map(x =>x * 3)
// res8: List[Int] = List(3, 6, 9, 12, 15, 18)

• 模拟添加、移除、更新操作，返回新的集合，原来集合不发生改变

// 7. :: ---->将0插入到 intList 的前面生成一个新的List
val newList01 = 0 :: intList
println(newList01 )

// 8.  .:: ---> 将7插入到 newList01的前面生成一个新的List
val newList02 = newList01.::(7)   
println(newList02)

• 通过查看不可变List的方法，发现并无append 方法

1.2 可变List

查看可变List的方法，发现无:: 、 :::、concat 方法

• ListBuffer的定义、添加元素、删除元素

//1.  引入ListBuffer 
import scala.collection.mutable.ListBuffer

val listBuffer01 = ListBuffer(1,2,3)
val listBuffer02 = ListBuffer(4,5,6)

// 2. 向listBuffer01中追加元素,原来的List也会发生改变
listBuffer01.append(9)

// 打印元素
println(listBuffer01)
// ListBuffer(1, 2, 3, 9)

// 3. 删除元素 ---删除index为3的元素( 注意：index从0开始 )
listBuffer01.remove(3)

println(listBuffer01)
// ListBuffer(1, 2, 3)

• ++= 方法

// 4. 将listBuffer02中的元素添加到listBuffer01中，没有生成新的集合
listBuffer01 ++= listBuffer02
println(listBuffer01)

• map 方法

// listBuffer02没有发生改变
listBuffer02.map( x => x * 3)

• filter 方法

// 过滤，但 listBuffer02没有发生改变
listBuffer02.filter( x => x % 2 == 0)

println(listBuffer02)
// ListBuffer(4, 5, 6)

总结

• 对于不可变List，可以模拟添加、移除、更新操作，但这些操作都会返回一个新的集合，原来的集合不会发生改变；可使用:: 、 :::、concat、filter、map方法，不能使用append方法。
• 对可变List 可进行修改、添加、移除一个元素，不会返回新的集合。无:: 、 :::、concat 方法，可使用append、map 、filter 方法。

练习2：Set类型的使用

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

不可变Set

// 默认引用不可变的
val set01 = Set(1,2,3)
// set01: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

可变集合

// 引入 mutable
import scala.collection.mutable.Set

// 此时定义的是可变的集合
val set02 = Set(1,2,3)
// set02: scala.collection.mutable.Set[Int] = Set(1, 2, 3)

Set唯一性的试验

• Set里所有的元素都是唯一的

// 有相同元素，会过滤重复，只留下一个唯一的
val set02 = Set(1,2,3,3)
// set02: scala.collection.mutable.Set[Int] = Set(1, 2, 3)

// 添加相同元素，返回false，添加失败，所以只保留一个唯一的
set02.add(2)
// res14: Boolean = false

• Set的增加

// 为True表示添加成功
set02.add(4)
// res16: Boolean = true

print(set02)
// Set(1, 2, 3, 4)

val set03 = Set("ab","cd","ef")
// 添加"gh"元素
set03 += "gh"
// res22: set03.type = Set(ab, gh, ef, cd)

• Set的删除

print(set02)
// Set(1, 2, 3, 4)

// 移除元素值为1的元素
set02.remove(1)
// res18: Boolean = true

print(set02)
// res19: scala.collection.mutable.Set[Int] = Set(2, 3, 4)
// 移除元素为4的元素
set02.remove(4)
// res20: Boolean = true

print(set02)
// Set(2, 3)

set03 -="ab"

练习3：Tuple元组 的使用

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

3.1 对元组进行定义和赋值

val t = (1,2,3.14,"a")
val t1 = new Tuple5(1,2,3,2.7,"cd")

3.2 元组的取值访问（通过下标、迭代器）

• 通过下标

t._1
// Int = 1

t1._5
// String = cd

• 通过迭代器

val t0= (1,2,3.14,"a")
val iterator = t0.productIterator
while(iterator.hasNext){
      val ele = iterator.next()
        println(ele)
}

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

// 创建不可变的Map 
val map1 = Map(1 -> "a",2 -> "b")

import scala.collection.mutable.Map
// 可变Map
val map2 = Map(1 -> "a",2 -> "b")
// 类似于HashMap 
val map3 = Map((1,"a"),(2,"b"),(3,"c"),(4,"d"))

map2 += ((4,"d"))

val iter = mapTwo.keysIterator
   while(iter.hasNext)
  {
    val ele = iterator.next()
    println("key:"+ele)
  }
  // 获得value迭代器对象
  val valueIter = mapTwo.valuesIterator
  while(valueIter.hasNext)
  {
    val ele = iterator.next()
    println("value:"+ele)
  }

• foreach方法遍历

map2 .foreach{
     case(k,v) => println("key:"+k + ",value: "+v)
     }

• Tuple语法访问键/值字段

// 访问第一个字段 key 和第二个字段 value
map2 .foreach(x => println("key:"+x._1 + ",value: "+x._2))

• print 所有的键

// keys方法返回Iterable
map2 .keys.foreach((key) => println(key))

• print 所有的值

map2 .values.foreach((value) => println(value))

练习5：groupBy的使用

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

5.1 对List[Int]进行分组

// 分为两组，若为false，则这组为List(1, 3, 5),若为true一组是List(2, 4, 6)
val num = List(1,2,3,4,5,6)
println(num.groupBy(x => x%2 == 0))

5.2 对List[String]根据首字母进行分组

// 根据首字母来分组，分为两组，一组是a开头，一组是d开头
val strList = List("abc","de","aa")

println(strList.groupBy(s => s.charAt(0)))
// Map(d -> List(de), a -> List(abc, aa))