Scala集合总结

数组


    //数组
    val arr01 = new Array[Int](4)
    println(arr01.length) //  4

    println("arr01(0)=" + arr01(0)) // 0
    for (i <- arr01) { //遍历
      println(i) // 0 0 0 0
    }
    var arr02 = Array(1, 3, "xxx") // apply
    for (i <- arr02) {
      println(i)
    }

    //变长数组
    import scala.collection.mutable.ArrayBuffer
    val arr2 = ArrayBuffer[Int]()
    arr2.append(7)
    arr2(0) = 7
    arr2.remove(0)
    arr1.toBuffer //定长数组Array转可变数组ArrayBuffer
    arr2.toArray //可变数组(ArrayBuffer)转定长数组(Array)

    //多维数组
    val arr = Array.ofDim[Double](3, 4)

    //Scala数组转Java的List
    val scalaarr = ArrayBuffer("1", "2", "3")
    import scala.collection.JavaConversions.bufferAsJavaList
    //bufferAsJavaList 隐式函数:作用是 将一个 Buffer 转成 java.util.List
    val javaArr = new ProcessBuilder(scalaarr)
    val arrList = javaArr.command() // arrList 就是 java.util.List 类型

    //Java的List转Scala数组(mutable.Buffer)
    import scala.collection.JavaConversions.asScalaBuffer
    import scala.collection.mutable
    // java.util.List ==> Buffer
    val arrList = new java.util.ArrayList[String]() // Java 的 ArrayList
    val scalaArr: mutable.Buffer[String] = arrList // scalaArr 就是 scala的类型
    scalaArr.append("jack")

元组


//元组
    //tuple1d的类型是Tuple5,最多22个元素类型是Tuple22
    val tuple1 = (1, 2, 3, "hello", 4)
    //访问元组的第一个元素 ,从1开始
    println(tuple1._1)
    // 访问元组的第一个元素,从0开始
    println(tuple1.productElement(0))
    //遍历
    for(item<-tuple1.productIterator){
      println(item)
    }

List


    //list
    // :+运算符表示在列表的最后增加数据
    var list1 = List(1, 2, 3, "abc")
    // 建议: + 后面带的是一个具体元素, :是一个集合
    val list2 = list1 :+ 4
    //// +: 运算符表示在列表的最前增加数据
    val list3 = 4+:list1
    println(list1)
    println(list2) //(1, 2, 3, "abc", 4)
    val list5=4 :: 5 :: 6 :: list1 :: Nil
    //::: 运算符是将集合中的每一个元素加入到空集合中去
    val list7 = 4 :: 5 :: 6 :: list1 ::: Nil

    //ListBuffer
    import scala.collection.mutable.ListBuffer
    val lst0 = ListBuffer[Int](1, 2, 3)
    val lst1 = new ListBuffer[Int] //新的
    lst1 += 4 // 对lst1 变化 (4)
    lst1.append(5) // lst1 (4,5)
    lst0 ++= lst1 //  lst0 (1, 2, 3, 4,5)
    val lst2 = lst0 ++ lst1 //lst2 (1, 2, 3, 4,5, 4,5)
    val lst3 = lst0 :+ 5 // lst3 (1, 2, 3, 4,5, 5)
    lst1.remove(1)  //删除第2个元素, 直接对lst1 有影响
    lst2(0) = 90 //修改

队列Queue


    //队列Queue
    val q1 = new mutable.Queue[Any]
    q1 += 20 //   默认加在队列的后面
    //将各个元素加入到Queue中
    q1 ++= List(2,4,6) // q1 (20,2,4,6)
    //list整体加入到Queue
    q1 += List(1,2,3)
    // 取出队列头的第一个元素
    val ele = q1.dequeue()
    // 将 20, 60, 加入队列尾
    q1.enqueue(20,60)
    //返回队列头的数据(元素),但是不从队列删除
    q1.head
    //返回队列最后一个元素
    q1.last
    //返回除了第一个以外剩余的元素
    q1.tail.tail
    //遍历
    for(ele<- q1) {
      println("ele=" + ele)
    }

map


    //不可变map,有序
    val map1 = Map("Alice" -> 10, "Bob" -> 20, "Kotlin" -> "北京")
    //可变map,无序
    val map2 = scala.collection.mutable.Map("Alice" -> 10, "Bob" -> 20, "Kotlin" -> 30)
    //和第一种方式等价,只是形式上不同而已
    val map4 = mutable.Map(("A", 1), ("B", 2), ("C", 3), ("D", 30))
    println("map4=" + map4)
    println(map4("A"))
    //检查是否存在key
    map4.contains("B")
    //如果E不存在返回默认值
    map4.getOrElse("E", "默认值")
    //修改和增加
    map4("E") = 30
    map4 += ("F" -> 22, "G" -> 56)
    val map5 = map4 + ("F" -> 22, "G" -> 56)
    //删除元素
    map4 -= ("F", "G")
    //遍历
    for ((k, v) <- map4) println(k + v)
    for(v<-map4.keys)println(v)
    for(v<-map4.values)println(v)
    for(v<-map4)println(v._1+v._2)

set


   //不可变
    val set = Set(1, 2, 3)
    import scala.collection.mutable.Set
    //可变
    val mutableSet = Set(1, 2, 3, "ss")
    mutableSet.add(4)
    mutableSet += 5
    mutableSet.+=(6)
    mutableSet -= 5
    mutableSet.-=(4)
    mutableSet.remove("ss")
    for (v <- mutableSet) {
      println(v)
    }
    //    def +(elem: A): Set[A]   
    //    为集合添加新元素,并创建一个新的集合,除非元素已存在
    //    def -(elem: A): Set[A]   
    //    移除集合中的元素,并创建一个新的集合
    //    def contains(elem: A): Boolean   
    //    如果元素在集合中存在,返回 true,否则返回 false。
    //    def &(that: Set[A]): Set[A]  
    //    返回两个集合的交集
    //    def &~(that: Set[A]): Set[A] 
    //    返回两个集合的差集
    //    def ++(elems: A): Set[A] 
    //    合并两个集合
    //    def drop(n: Int): Set[A]]
    //    返回丢弃前n个元素新集合
    //    def dropRight(n: Int): Set[A]
    //    返回丢弃最后n个元素新集合
    //    def dropWhile(p: (A) => Boolean): Set[A] 
    //    从左向右丢弃元素,直到条件p不成立
    //    def max: A
    //    查找最大元素
    //    def min: A  
    //    查找最小元素
    //    def take(n: Int): Set[A] 
    //    返回前 n 个元素

化简、折叠、扫描


//def map[B](f: (A) ⇒ B): HashSet[B]
    val list1 = List(3, 5, 7)
    def f1(n1: Int): Int = {
      2 * n1
    }
    val list2 = list1.map(f1)
    println(list2)
    //flatmap映射
    val names = List("Alice", "Bob", "Nick")
    def upper( s : String ) : String = {
      s. toUpperCase //转成大写
    }
    //注意:每个字符串也是char集合
    println(names.flatMap(upper))

    //化简
    val list = List(1, 2, 3, 4, 5)
    def sum(n1: Int, n2: Int): Int = { //求和 sum 就是一个二元函数
      n1 + n2
    }
    //1, 先取出 list 左边 的 两个元素 (1, 2), 传入给 sum ,  的结果 3
    //2. 将返回的结果,再次传递给 sum 函数的左边参数,即 n1 ,  n 2= 3
    //3. 依次类推,将list 元素遍历完就结束
    //(((1, 2), 3), 4), 5) = 15
    val res = list.reduceLeft(sum)

    //折叠
    def minus( num1 : Int, num2 : Int ): Int = {
      num1 - num2
    }
    //  (((5 - 1) - 2) - 3) - 4 = -5
    println(list.foldLeft(5)(minus))  //-10
    println((5/:list)(_-_))
    //1-  (2-  (3 - (4 - 5)))
    println(list.foldRight(5)(minus)) //-2
    println((list:\5)(minus))

    //扫描
    val i8 = (1 to 5).scanLeft(5)(minus)
    println(i8)//Vector(5, 4, 2, -1, -5, -10)
    val i9 = (1 to 5).scanLeft(5)(sum)
    println(i9)//Vector(5, 6, 8, 11, 15, 20)

拉链、流


    val list7 = List(1, 2 ,3)
    val list8 = List("北京", "天津", "上海")
    val list9 = list7.zip(list8) // 合并
    // List (1->"北京", 2 -> "天津", 3->"上海")
    val iterator = List(1, 2, 3, 4, 5).iterator // 得到迭代器
    while (iterator.hasNext) { //如果有元素,返回true
      println(iterator.next()) // 取出元素
    }

    //创建Stream
    def numsForm(n: BigInt) : Stream[BigInt] = n #:: numsForm(n + 1)
    val stream1 = numsForm(1)
    println(stream1) //
    //取出第一个元素
    println("head=" + stream1.head) // 取出当前流的头元素
    println(stream1.tail) // 再生成下一个数据

Scala集合总结

发表评论

电子邮件地址不会被公开。 必填项已用*标注

滚动到顶部