大数据技术之scala

大数据技术之scala

一、多维数组

object TestSet {

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

//（1）创建了一个二维数组, 有三个元素，每个元素是，含有 4 个元素一维数组()

val arr = Array.ofDim[Int](3, 4) arr(1)(2) = 88

//（2）遍历二维数组

for (i <- arr) { //i 就是一维数组

for (j <- i) {

print(j + " ")

}

println()

}}}

二、列表List

1、不可变 List

object TestSet {

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

//（1）List 默认为不可变集合

//（2）创建一个 List（数据有顺序，可重复） val list: List[Int] = List(1,2,3,4,3)

//（7）空集合 Nil

val list5 = 1::2::3::4::Nil

//（4）List 增加数据

//（4.1）::的运算规则从右向左

//val list1 =  5::list val list1 = 7::6::5::list

//（4.2）添加到第一个元素位置val list2 = list.+:(5)

//（5）集合间合并：将一个整体拆成一个一个的个体，称为扁平化val list3 = List(8,9)

//val list4 = list3::list1 val list4 = list3:::list1

//（6）取指定数据println(list(0))

//（3）遍历 List

//list.foreach(println)

//list1.foreach(println)

//list3.foreach(println)

//list4.foreach(println)

list5.foreach(println)

}

}

三、可变ListBuffer

import scala.collection.mutable.ListBuffer object TestSet {

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

//（1）创建一个可变集合

val buffer = ListBuffer(1,2,3,4)

//（2）向集合中添加数据

buffer.+=(5)

buffer.append(6)

buffer.insert(1,2)

//（3）打印集合数据

buffer.foreach(println)

//（4）修改数据

buffer(1) = 6

buffer.update(1,7)

//（5）删除数据

buffer.-(5)

buffer.-=(5) buffer.remove(5)

}

}

四、Set 集合

1、不可变 Set

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

//（1）Set 默认是不可变集合，数据无序

val set = Set(1,2,3,4,5,6)

//（2）数据不可重复

val set1 = Set(1,2,3,4,5,6,3)

//（3）遍历集合for(x<-set1){ println(x)

}}}

2、可变mutable.Set

import scala.collection.mutable

object TestSet {

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

    //（1）创建可变集合

    val set = mutable.Set(1,2,3,4,5,6)

    //（3）集合添加元素

    set += 8

    //（4）向集合中添加元素，返回一个新的 Set

    val ints = set.+(9)

    println(ints)

    println("set2=" + set)

    //（5）删除数据

    set-=(5)

    //（2）打印集合

    set.foreach(println)

    println(set.mkString(","))

  }

}

五、Map 集合

1、不可变 Map

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

  // Map

  //（1）创建不可变集合 Map

  val map = Map( "a"->1, "b"->2, "c"->3 )

  //（3）访问数据

  for (elem <- map.keys) {

    // 使用 get 访问 map 集合的数据，会返回特殊类型 Option(选项):有值（Some），无值(None)

    println(elem + "=" + map.get(elem).get)

  }

  //（4） 如 果 key 不 存 在 ， 返 回 0

  println(map.get("d").getOrElse(0))

  println(map.getOrElse("d", 0))

  //（2）循环打印

  map.foreach((kv)=>{println(kv)})

}}

2、可变Map

 object TestSet {

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

      //（1）创建可变集合

      val map = mutable.Map("a" -> 1, "b" -> 2, "c" -> 3)

      //（3）向集合增加数据

      map.+=("d"->4)

      // 将数值 4 添加到集合，并把集合中原值 1 返回

      val maybeInt: Option[Int] = map.put("a", 4)

      println(maybeInt.getOrElse(0))

      //（4）删除数据

      map.-=("b", "c")

      //（5）修改数据

      map.update("d",5)

      map("d") = 5

      //（2）打印集合

      map.foreach((kv) => {

        println(kv)

      })

    }

  }

六、元组

object TestTuple {

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

    //（1）声明元组的方式：(元素 1，元素 2，元素 3)

    val tuple: (Int, String, Boolean) = (40,"bobo",true)

    //（2）访问元组

    //（2.1）通过元素的顺序进行访问，调用方式：_顺序号

  println(tuple._1)

  println(tuple._2)

  println(tuple._3)

    //（2.2）通过索引访问数据

  println(tuple.productElement(0))

    //（2.3）通过迭代器访问数据

    for (elem <- tuple.productIterator) {

      println(elem)

    }

    //（3）Map 中的键值对其实就是元组,只不过元组的元素个数为 2，称之为对偶

    val map = Map("a"->1, "b"->2, "c"->3)

    val map1 = Map(("a",1), ("b",2), ("c",3))

    map.foreach(tuple=>{

      println(tuple._1 + "=" + tuple._2)})

  }

}

七、基本属性和常用操作

object TestSet {

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

val list: List[Int] = List(1, 2, 3, 4, 5, 6, 7)

//（1）获取集合长度

println(list.length)

//（2）获取集合大小,等同于 length

println(list.size)

//（3）循环遍历

list.foreach(println)

//（4）迭代器

for (elem <- list.itera tor) { println(elem)

}

//（5）生成字符串

println(list.mkString(","))

//（6）是否包含

println(list.contains(3))

}

}

八、衍生集合

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

    val list1: List[Int] = List(1, 2, 3, 4, 5, 6, 7)

    val list2: List[Int] = List(4, 5, 6, 7, 8, 9, 10)

    //（1）获取集合的头

  println(list1.head)

    //（2）获取集合的尾（不是头的就是尾）

  println(list1.tail)

    //（3）集合最后一个数据

  println(list1.last)

    //（4）集合初始数据（不包含最后一个）

  println(list1.init)

    //（5）反转

  println(list1.reverse)

    //（6）取前（后）n 个元素

    println(list1.take(3))

  println(list1.takeRight(3))

    //（7）去掉前（后）n 个元素

  println(list1.drop(3))

  println(list1.dropRight(3))

    //（8）并集

  println(list1.union(list2))

    //（9）交集

  println(list1.intersect(list2))

    //（10）差集

  println(list1.diff(list2))

    //（11）拉链 注:如果两个集合的元素个数不相等，那么会将同等数量的数据进行拉链，多余的数据省略不用

    println(list1.zip(list2))

    //（12）滑窗

    list1.sliding(2, 5).foreach(println)

  }

九、集合计算简单函数

object TestSet{

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

val list: List[Int] = List(1, 5, -3, 4, 2, -7, 6)

//（1）求和println(list.sum)

//（2）求乘积println(list.product)

//（3）最大值println(list.max)

//（4）最小值println(list.min)

//（5）排序

// （5.1）按照元素大小排序

println(list.sortBy(x => x))

// （5.2）按照元素的绝对值大小排序

println(list.sortBy(x => x.abs))

// （5.3）按元素大小升序排序

println(list.sortWith((x, y) => x < y))

// （5.4）按元素大小降序排序

println(list.sortWith((x, y) => x > y))

}

}