Scala基础：数组（Array）、映射（Map）、元组（Tuple）、集合（List）

数组

package com.zy.scala

object ArrayDemo {
  def main(args: Array[String]): Unit = {
    //定长数组
    val arr1 = new Array[Int](5)
    //不定长数组
    val arr2 = Array[Int]()

    val arr3: Array[Int] = Array(1, 2, 3, 4, 5)
    println(arr3.toBuffer)
    println(arr3(2))

    //遍历数组
    //初始化一个数组
    val arr4 = Array(1, 2, 3, 4, 5, 6, 7, 8)
    //增强 for 循环
    for (i <- arr4)
      println(i)

    //好用的 until 会生成一个 Range
    //reverse 是将前面生成的 Range 反转
    for (i <- (0 until arr4.length).reverse)
      println(arr4(i))

    println("----------------------------------------------")
    //数组转换
    //yield 关键字将原始的数组进行转换会产生一个新的数组，原始的数组不变
    //定义一个数组
    val arr = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)
    //将偶数取出乘以 10 后再生成一个新的数组
    val res = for (e <- arr if e % 2 == 0) yield e * 10
    println(res.toBuffer)

    //更高级的写法,用着更爽
    //filter 是过滤，接收一个返回值为 boolean 的函数
    //map 相当于将数组中的每一个元素取出来，应用传进去的函数
    val r = arr.filter(_ % 2 == 0).map(_ * 10)
    println(r.toBuffer)

    //排序
    val sorted: Array[Int] = arr.sorted
    //求和 极值
    val sum: Int = arr.sum
    val max: Int = arr.max
    val min: Int = arr.min

  }

}

映射

package com.zy.scala

import scala.collection.mutable.Map

object MapDemo {
  def main(args: Array[String]): Unit = {
    //创建映射map
    val map1: Map[Int, String] = Map(1 -> "1", 2 -> "2")
    println(map1)
    val map2: Map[Int, String] = Map((1, "1"), (2, "2"))
    println(map2)

    //获取值
    val v1: String = map1(2)
    val v2: Option[String] = map1.get(1)
    val v3: String = map2.getOrElse(3, "3")
    println(v1)
    println(v2)
    println(v3)

    //修改值
    //改变值需要引入import scala.collection.mutable.Map
    map2(1) = "666"
    println(map2)

    //遍历所有的map集合的key
    for (i <- map1.keys) {
      map1(i)
    }
  }
}

元组

package com.zy.scala

object TupleDemo {
  def main(args: Array[String]): Unit = {
    //创建元组
    val tuple: (Int, Int, Int, Int, Int) = (1, 2, 3, 4, 5)
    println(tuple)
    println(tuple._1)

    //将对偶的集合转换成映射
    val arr: Array[(String, Int)] = Array(("zhangsan", 88), ("lisi", 66))
    val map1: Map[String, Int] = arr.toMap
    println(map1)

    //拉链操作
    val arr1: Array[String] = Array("张学友", "刘德华", "郭富城", "黎明")
    val arr2: Array[String] = Array("66", "77", "88", "99")
    val zip: Array[(String, String)] = arr1.zip(arr2)
    println(zip.toMap)

    val arr3: Array[String] = Array("66", "77", "88")
    val zipAll: Array[(String, String)] = arr1.zipAll(arr3, "黎明", "100")
    println(zipAll.toMap)
  }
}

集合

list

package com.zy.scala

object ListDemo {
  def main(args: Array[String]): Unit = {
    def main(args: Array[String]) {
      //创建一个不可变的集合
      val lst1 = List(1, 2, 3)
      //补充：另一种定义 list 方法
      val other_lst = 2 :: Nil
      //获取集合的第一个元素
      val first = lst1.head
      //获取集合中除第一个元素外的其他元素集合,
      val tail = lst1.tail
      //补充：其中如果 List 中只有一个元素，那么它的 head 就是这个元素，它的 tail 就是 Nil；
      println(other_lst.head + "----" + other_lst.tail)
      //将 0 插入到 lst1 的前面生成一个新的 List
      val lst2 = 0 :: lst1
      val lst3 = lst1.::(0)
      val lst4 = 0 +: lst1
      val lst5 = lst1.+:(0)
      //将一个元素添加到 lst1 的后面产生一个新的集合
      val lst6 = lst1 :+ 3
      val lst0 = List(4, 5, 6)
      //将 2 个 list 合并成一个新的 List
      val lst7 = lst1 ++ lst0
      //将 lst0 插入到 lst1 前面生成一个新的集合
      val lst8 = lst1 ++: lst0
      //将 lst0 插入到 lst1 前面生成一个新的集合
      val lst9 = lst1.:::(lst0)
      println(other_lst)
      println(lst1)
      println(first)
      println(tail)
      println(lst2)
      println(lst3)
      println(lst4)
      println(lst5)
      println(lst6)
      println(lst7)
      println(lst8)
      println(lst9)
    }
  }
}

package com.zy.scala

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

    //创建一个List
    val list0 = List(1, 7, 9, 8, 0, 3, 5, 4, 6, 2)

    //获取list集合元素个数
    val size: Int = list0.size
    println(size)

    //将list0中的每一个元素乘以10后生成一个新的集合
    val list1: List[Int] = list0.map(x => x * 10)
    //更简洁的方法
    // list0.map(_ * 10)
    println("list1==== " + list1)

    //将list0中的偶数取出来生成一个新的集合  (集合过滤)
    val list2: List[Int] = list0.filter(x => x % 2 == 0)
    println("list2==== " + list2)

    //将list0排序后生成一个新的集合
    val list3: List[Int] = list0.sorted
    val list4: List[Int] = list0.sortBy(x => x)
    val list5: List[Int] = list0.sortWith((x, y) => x < y)
    println("list3==== " + list3)
    println("list4==== " + list4)
    println("list5==== " + list5)

    //反转顺序
    val list6: List[Int] = list3.reverse
    println("list6==== " + list6)

    //将list0中的元素4个一组,类型为Iterator[List[Int]]
    val list7: Iterator[List[Int]] = list0.grouped(4)
    println("list7==== " + list7)

    //将Iterator转换成List
    val list8: List[List[Int]] = list7.toList
    println("list8==== " + list8)

    //将多个list压扁成一个List
    val list9: List[Int] = list8.flatten
    println("list9==== " + list9)

    val lines: List[String] = List("hello tom hello jerry", "hello jerry", "hello kitty")
    //先按空格切分，在压平
    val result1: List[String] = lines.flatMap(_.split(" "))
    println("result1==== " + result1)

    //并行计算求和
    val result2: Int = list0.par.sum
    println("result2==== " + result2)

    //化简：reduce
    //将非特定顺序的二元操作应用到所有元素
    val result3: Int = list0.reduce((x, y) => x + y)
    println("result3==== " + result3)

    //按照特定的顺序
    val result4: Int = list0.reduceLeft(_ + _)
    val result5: Int = list0.reduceRight(_ + _)
    println("result4==== " + result4)
    println("result5==== " + result5)

    //折叠：有初始值（无特定顺序）
    val result6: Int = list0.fold(100)((x, y) => x + y)
    println("result6==== " + result6)

    //折叠：有初始值（有特定顺序）
    val result7: Int = list0.foldLeft(100)((x, y) => x + y)
    println("result7==== " + result7)

    //聚合
    val list10: List[List[Int]] = List(List(1, 2, 3), List(4, 5, 6), List(7, 8), List(9, 0))
    val result8: Int = list10.par.aggregate(10)(_ + _.sum, _ + _)
    println("result8==== " + result8)

    //获取到参与并行计算的线程
    println(list10.par.collect {
      case _ => Thread.currentThread().getName
    }.distinct)

    val l1: List[Int] = List(5, 6, 4, 7)
    val l2: List[Int] = List(1, 2, 3, 4)
    //求并集
    val r1: List[Int] = l1.union(l2)
    println("r1=== " + r1)

    //求交集
    val r2: List[Int] = l1.intersect(l2)
    println("r1=== " + r2)

    //求差集
    val r3: List[Int] = l1.diff(l2)
    println("r3=== " + r3)

  }

}

set

package com.zy.scala

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

    //val set: Set[Any] = Set("hadoop","hadoop","spark",18)

    //定义一个set集合
    val ints: Set[Int] = Set(1, 2, 3, 4, 5, 6, 7)

    //获取元素个数有几个
    val size: Int = ints.size

    //获取集合中最大值
    val max: Int = ints.max

    //获取集合中的最小值
    val min: Int = ints.min

    //给set集合添加一个元素
    val addElement: Set[Int] = ints + 8
    val addElement1: Set[Int] = ints ++ Set(8, 8, 9, 9)

    //println(addElement1)

    val set1 = Set(7, 8, 9)

    //求两个set集合的交集
    val ints1: Set[Int] = ints & set1

    //求两个set集合的并集，去重操作
    val ints2: Set[Int] = ints ++ set1

    //求差集
    val ints3: Set[Int] = ints -- set1

    //返回第一个不同于第二个set的元素集合
    val ints4: Set[Int] = ints &~ set1

    //对set集合进行过滤统计
    val count: Int = ints.count(_ >= 4)

    println(count)

    //返回第一个set集合不同于第二个set集合的操作
    //(1,2,3,4,5)  (3,4,5)
    val diff: Set[Int] = ints.diff(set1)

    println(diff)

    //返回第二个set集合不同于第一个set集合的操作
    val diff1: Set[Int] = set1.diff(ints)

    println(diff1)

    //取set集合中子集
    val slice: Set[Int] = ints.slice(2, 5) //[2,5)

    println(ints)
    println(slice)

    val foreach1: Unit = ints.subsets(2).foreach(x => println(x))

    println("---------------------------------------------")
    val foreach: Unit = ints.subsets(3).foreach(println(_))
  }