Scala系列学习二scala中数组、集合等

1、Array数组

object ArrayDemo extends App {
  //初始化长度为8的数组，其初始值为0
  private val arr1 = new Array[Int](8)
  println(arr1) //直接打印，其是指对象的hash值,[I@668bc3d5
  //  如果需要查看其中的内容，可以使用循环或者转换为缓冲数组
  println(arr1.toBuffer) //ArrayBuffer(0, 0, 0, 0, 0, 0, 0, 0)
  //  可以不使用new，会直接调用apply方法，直接给数组复制，下面的长度为1值为10
  private val arr2: Array[Int] = Array[Int](10)
  println(arr2.toBuffer) //ArrayBuffer(10)
  //也可以直接赋值，而不用定义长度
  private val arr3 = Array("allen", "tom", "jack", "alex")
  println(arr3.toBuffer, arr3(1)) //(ArrayBuffer(allen, tom, jack, alex),tom)

  //以上的数组是定长的，如果需要使用变长的，需要使用mutable
  import scala.collection.mutable.ArrayBuffer

  private val ab1: ArrayBuffer[Int] = ArrayBuffer[Int]()
  //  添加数据
  ab1 += 1
  ab1 += (5, 6, 7, 9)
  ab1 ++= Array(1, 2, 3)
  ab1 ++= ArrayBuffer(90878, 9897)
  println("添加数据" + ab1) //ArrayBuffer(1, 5, 6, 7, 9, 1, 2, 3, 90878, 9897)
  //  移除数据
  ab1 -= 1
  ab1 -= (5, 3)
  ab1 --= Array(1, 2, 3)
  println("移除数据" + ab1) //移除数据ArrayBuffer(6, 7, 9, 90878, 9897)

  ab1.insert(0, 0)
  println("添加数据" + ab1) //添加数据ArrayBuffer(0, 6, 7, 9, 90878, 9897)
  ab1.remove(0)
  println("移除数据" + ab1) //移除数据ArrayBuffer(6, 7, 9, 90878, 9897)
  ab1.clear() //清除数据
  println(ab1) //ArrayBuffer()

  //  在前期使用了，在for进行过滤操作
  private val res0: immutable.IndexedSeq[Int] = for (i <- 1 to 10 if i % 2 == 0) yield i * 10
  println(res0)
  //Vector(20, 40, 60, 80, 100)
  //  更换,使用filter进行过滤操作
  val arr4 = 1 to 10
  private val res1: immutable.IndexedSeq[Int] = arr4.filter(_ % 2 == 0).map(_ * 10)
  println(res1) //Vector(20, 40, 60, 80, 100)

  //  常用方法
  private val arr5 = Array(1, 6, 2, 90, 76, 6)
  println(arr5.min)
  println(arr5.max)
  println(arr5.sum)
  println(arr5.sorted.reverse.toBuffer)
}

2、Map

object MapDemo extends App {
  // 映射就是kv对， map创建的两种方式
  private val map1 = Map("tom" -> 21, "allen" -> 18, "alex" -> 10)
  private val map2 = Map(("tom", 21), ("allen", 18), ("alex", 10))
  println(map1, map2) //(Map(tom -> 21, allen -> 18, alex -> 10),Map(tom -> 21, allen -> 18, alex -> 10))
  //  获取值
  println(map1("tom"))
  //  添加默认值，如果没有对应的key的时候，返回返回默认的值
  println(map1.getOrElse("jack", 18))
  //该变量的引用不可变，该引用中的内容是不是可变，取决于这个引用指向的集合的类型
  private val map3 = mutable.Map(("tom", 21), ("allen", 18), ("alex", 10))
  map3("tom") = 19
  println(map3) //Map(alex -> 10, allen -> 18, tom -> 19)

  private val map4: mutable.HashMap[String, Int] = mutable.HashMap[String, Int]()
  map4("allen") = 18
  map4 += ((("alex", 20)))
  map4.put("jack", 23)
  println(map4)
  //从map中移除元素
  map4 -= "allen"
  map4.remove("jack")
  println(map4)
}

3、Tuple

object TupleDemo extends App {
  //映射是K/V对偶的集合，对偶是元组的最简单形式，元组可以装着多个不同类型的值。
  //  创建元组
  private val p: (String, Int, String) = ("allen", 23, "M")
  //  获取其中的值
  println(p._1, p._2, p._3)
  private val t1, (a, b, c): (String, Int, String) = ("tom", 21, "F")
  println(t1)
  println(a, b, c)
  //  注意上面的表达式，其实是两句话和在一块的
  private val t2, (e, f, g): (String, Int, String) = {
    println("次数，会打印几次？")
    ("tom", 21, "F")
  } //会打印两次

  //  将对偶的集合转换为映射
  private val arr = Array(("tom", 12), ("allen", 18))
  private val map1: Map[String, Int] = arr.toMap
  println(map1)

  //  利用zip进行操作
  private val names = Array("tom", "allen", "alex")
  private val ages = Array(21, 18, 20)
  private val p2: Array[(String, Int)] = names.zip(ages)
  println(p2.toBuffer) //ArrayBuffer((tom,21), (allen,18), (alex,20))
}

4、Sequence

object SequenceDemo extends App {
  //  Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质
  private val list1 = List(1, 2, 3)
  //  将数据插入到前面
  private val list2: List[Int] = 0 :: list1
  //  将数据插入到后面
  private val list3: List[Int] = list1.::(0)
  private val list4: List[Int] = 0 +: list1
  private val list5: List[Int] = list1.+:(0)
  println(list1, list2, list3, list4, list5)
  //  将一个元素添加到lst1的后面产生一个新的集合
  private val list6: List[Int] = list1 :+ 0
  private val list7: List[Int] = list1 ++ list2
  println(list6, list7)
  //将lst0插入到lst1前面生成一个新的集合
  val list8 = list1 ++: list2

  //  可变list
  //构建一个可变列表，初始有3个元素1,2,3
  val lb0 = ListBuffer[Int](1, 2, 3)
  //  空的可变列表
  private val lb1 = new ListBuffer[Int]
  lb1 += 0
  println(lb1)
  lb1.append(1)
  lb0 ++= lb1 //将lb1追加到lb0中，没有新的集合生成
  private val lb2: ListBuffer[Int] = lb0 ++ lb1 //生成了新的集合
}

5、Set

object SetDemo extends App {
  private val set1 = new immutable.HashSet[Int]()
  private val set2: immutable.HashSet[Int] = set1 + 4
  //  注意其中元素是不重复的
  private val set3: immutable.HashSet[Int] = set1 ++ Set(4, 5, 6)
  println(set3)

  //  可变set
  private val set4: mutable.HashSet[Int] = mutable.HashSet[Int]()
  set4 += 1
  set4.add(2)
  println(set4)
  set4 -= 1
  set4.remove(2)
  println(set4)
}