Scala_集合(三)

数组

    // var 约等于final 不可变描述的是val指定的引用的值(值: 字面值，地址)
    val array01 = Array[Int](1,2,3,4)
    //错误     array01 =  Array[Int](1,2,3,4)
    array01(1) = 99
    println(array01(1))

    for(elem <- array01){
        println(elem)
    }

    array01.foreach(println)

链表

        val linkedList = new util.LinkedList[String]()
        linkedList.add("aa")
        linkedList.add("bb")
        println(linkedList.get(1))
        结果: 99
        
        
        // scala中的collection 中有两个包：immutable、mutable 默认的是不可变的immutable
            var list01 = List(1,2,3,2,1)
            print(list01)
            结果：List(1, 2, 3, 2, 1)
            
            var list02 = new ListBuffer[Int]()
            list02.+=(1)
            list02.+=(2)
            list02.+=(3)
            list02.+=(1)
            list02.foreach(print)
            结果:1231
            
   val set01 : Set[Int] = Set(1,2,3,4, 1,2)
    for (elem <- set01) {
      print(elem)
    }
    结果: 1234
    

Tuple

从1到22，最大22



    // key value
    格式一：
    val tuple2 = new Tuple2(11, "aa")
    print(tuple2)
    结果: (11,aa)
    
    格式二：
    val tuple3 = Tuple3(1,2,"c")
    
    格式三：
    val tuple4 = (1,2,3,4)
    println(tuple4._3)
    结果: 3
    
     var  tuple22:((Int, Int) => Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int)
    = ((a:Int, b:Int)=> a + 8 + b, 2,3,4,5,6,7,8,9,1,2,3,4,5,6,7,8,9,1,2,3,4)
    println(tuple22._1(8, 10))
    println(tuple22._1)
    结果：
    26
    <function2> 2代表的意思就是方法有两个参数，自己定义的 (Int, Int) => Int

Map

     var tuple22:((Int, Int) => Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int)
    = ((a:Int, b:Int)=> a + 8 + b, 2,3,4,5,6,7,8,9,1,2,3,4,5,6,7,8,9,1,2,3,4)
    
    val iterator = tuple22.productIterator
    while(iterator.hasNext){
      print(iterator.next())
    }
    结果:<function2>234567891234567891234
    
    
    val map01 = Map(("a", 33), "b" -> 33, ("c", 44), ("a", 55))
    println(map01)
    结果: Map(a -> 55, b -> 33, c -> 44)
    
    val keys = map01.keys
    for (elem <- keys) {
      println(s"key: $elem  value: ${map01.get(elem).get}")
    }
    结果: 
key: a  value: 55
key: b  value: 33
key: c  value: 44

    println(keys) //Set(a, b, c)
    println(map01.get("a")) //Some(55)
    println(map01.get("d")) //None
    println(map01.get("a").get) // 55
    println(map01.get("d").get) //会报错
    println(map01.get("a").getOrElse("hello")) // 55
    println(map01.get("d").getOrElse("hello")) // hello


    
    val map02 = scala.collection.mutable.Map(("a", 11), ("b", 22))
    map02.put("c", 22)
    val keys2 = map02.keys
    for (elem <- keys2) {
      print(s"key: $elem  value: ${map02.get(elem).get} 	")
    }
    key: b  value: 22     key: a  value: 11     key: c  value: 22     11
    
    
    
    var list =  List(1,2,3,2,1)
    val listMap = list.map( (x:Int) => x+10)
    listMap.foreach(print)
    结果:11 12 13 12 11
    
    val listMap2 = list.map(_*10)
    listMap2.foreach(print)
    结果:10 20 30 20 10
    
    
    val listStr = List("hello world", "hello xiaoke", "hello idea")
    val flatMap = listStr.flatMap( (x:String)=> x.split(" "))
    flatMap.foreach(print)
    结果: hello world hello xiaoke hello idea
    
    
    val mapList = flatMap.map( (_, 1))
    mapList.foreach(println)
    结果: 
    (hello,1) 
    (world,1)
    (hello,1)
    (xiaoke,1)
    (hello,1)
    (idea,1)
    

迭代器

   // 以上代码有内存问题， 内存扩大了N倍，每一步计算内存都留有对象数据。有没有什么现成的技术解决数据计算中间状态占用内存这一问题?     迭代器
    // 什么是迭代器，为什么会有地带起模式？ 迭代器里不存数据
    val itera = listStr.iterator
    val iterator_flatMap = itera.flatMap( (x:String)=> x.split(" "))
    iterator_flatMap.foreach(println)
    结果：
        hello
        world
        hello
        xiaoke
        hello
        idea
        
    val iterator_mapList = iterator_flatMap.map( (_, 1))
    iterator_mapList.foreach(println)
    结果: 并没有打印，原因是迭代器的指针在上面已经指到最后一个了
    
    
    


源代码梳理：
    val listStr = List("hello world", "hello xiaoke", "hello idea")
    val itera = listStr.iterator
    val iterator_flatMap = itera.flatMap( (x:String)=> x.split(" "))
    while (iterator_flatMap.hasNext){
      val tuple = iterator_flatMap.next()
      println(tuple)
    }
    
1.iterator_flatMap.hasNext
->flatMap 
-> AbstractIterator 
-> hasNext 
-> self.hasNext 
-> listStr.iterator 
-> hasNext 
->  !these.isEmpty(有值) 
-> true 
->  nextCur() 
-> cur = f(self.next()).toIterator 
-> listStr.iterator.next() 
-> val result = these.head; these = these.tail; result(取出第一条) 
->  flatMap(true) 

2.iterator_flatMap.next()
-> flatMap
-> (if (hasNext) cur else empty).next()
->  hasNext((!cur.hasNext)= false）返回  true
->  cur中取 cur.next()

3. iterator_flatMap.hasNext
-> flatMap
-> hasNext((!cur.hasNext)= false）返回  true
4. iterator_flatMap.next()
-> 以此类推