Scala数组| 集合

arrays :+ 5尾部   头部5 +: arrays

TODO 声明不可变数组，不能删; 默认情况下，scala中集合的声明全都是不可变的

 val arrays: Array[Int] = Array(1, 2, 3, 4)
//增加  不可变使用伴生对象添加数
    val newArrays1: Array[Int] = arrays :+5  //1,2,3,4,5 // 增加数据到集合的尾部，产生新的集合
    val newArrays2: Array[Int] = 6+:arrays  //6,1,2,3,4 // 增加数据到集合的头部，产生新的集合
    //println(newArrays.length)
    //println(arrays == newArrays1) //false ； ==是否是同一块内存
    //println(arrays.length)

    // 修改数据:数组(索引) = 修改的值； 修改，不变的是内存地址，里边内容可以变
    arrays(1)=1
    println(arrays.mkString(",")) //1,1,3,4

 // 获取数组中的数据
//println(arrays(3))
    //循环遍历
    for (elem <- arrays) {
      println(elem)
    }
    //println(arrays.mkString(",")) // 生成字符串

    // 将不可变数组变成可变数组
    arrays.toBuffer

 TODO 声明可变数组 可变数组的数据操作其实都是对同一个数组做操作
arrayBuffer+=5,跟之前数组是同一个内存地址，即一个数组

var arrayBuffer: ArrayBuffer[Int] = ArrayBuffer(1,2,3,4,5)
    // 增加数据
    var newArrayBuffer: ArrayBuffer[Int] = arrayBuffer:+6
    var newArrayBuffer1: ArrayBuffer[Int] = 7+:arrayBuffer
    println(arrayBuffer == newArrayBuffer) //false  +=6就是true

// 修改数据
    arrayBuffer.insert(2, 9)
　　arrayBuffer.update(1, 3)

    arrayBuffer(0) = 6
    println(arrayBuffer.mkString(",")) //1,2,9,3,4,5
    //println(newArrayBuffer1.mkString(",")) //7,1,2,3,4,5

    // 删除数据
    //arrayBuffer.remove(2)  //按索引删 // 如果删除的个数超过数组的容量，会发生错误
    //arrayBuffer.remove(2, 2) //删索引后的后两位
    //arrayBuffer-=5  //arrayBuffer-5它是针对新集合的，arrayBuffer-=5是操作完之后重新赋值给arrayBuffer，删除的是元素

//查询
    println(arrayBuffer(2))
    for (elem <- arrayBuffer) {
      print(elem)
    }

    def test(i: Int): Unit = {
      print(i)
    }
    // foreach方法会传递一个函数作为参数; foreach方法会将集合的每一个元素都调用这个函数
    arrayBuffer.foreach(test)
    //arrayBuffer.foreach((i: Int) => {print(i)})
    //arrayBuffer.foreach(i => {print(i)})
    //arrayBuffer.foreach({print(_)})
    //arrayBuffer.foreach(print(_))

    arrayBuffer.foreach(print)  //只有一个参数时(_)也可以省略

    // 将可变数组变成不可变数组
    arrayBuffer.toArray

list -- seq序列

TODO immutable : 不可变// java:list  ==> scala:Seq

:紧挨着集合表增加

    val list: List[Int] = List(1,2,3,4)
    // 增加数据
    list:+5
    val newList: List[Int] = 5+:list //5,1,2,3,4

    // 特殊的List集合对象， Nil => List()
    val nil: List[Nothing] = List()
    val nils: List[Int] = nil:+3 //3

    // 给空集合增加数据，不是空集合也可以, 元素可以重复
    // 双冒号的运算规则是从右向左
    val list1: List[Int] = 1:: 2:: 3:: 4:: nils  //1,2,3,4,3
    println(list1.mkString(","))
    val list2: List[Int] = 5:: list //5,1,2,3,4 加在头部
    println(list2.mkString(","))

    val list3: List[Any] = 5:: list:: nils //5,List(1, 2, 3, 4),3  list作为整体
    val list3: List[Any] = 5:: list::: nils //5,1,2,3,4,3  整体拆开--扁平化
    println(list3.mkString(","))

// 修改数据:list无法通过索引的方式对象数据进行修改 //list(1) = 7
    // 可以通过updated方法修改数据，但是会产生新集合
    val newUpdateList: List[Int] = list.updated(1, 8) //1,8,3,4
    println(newUpdateList.mkString(","))

// 删除数据,产生新的集合
    val dropList: List[Int] = list.drop(2) //删除前两个
    println("删除="+ dropList.mkString(",")) //删除=3,4

    // 查询数据
    println(list(1)) //2
    // 获取指定个数的数据，产生新的集合
    println(list.take(3)) //List(1, 2, 3)
    for (elem <- list) {}
    list.foreach(println)

mutable ： 可变，易变 ListBuffer

    val listBuffer: ListBuffer[Int] = ListBuffer(1,2,3,4)
    //listBuffer.insert(1, 6)
    //listBuffer.remove(1)
    //listBuffer.updated(1, 9)

    val listBuffer1: ListBuffer[Int] = listBuffer+=5 //内存指向同一块
    val listBuffer2: ListBuffer[Int] = listBuffer-=4
    println(listBuffer.mkString(",")) //1,2,3,5
    println(listBuffer1.mkString(","))//1,2,3,5
    println(listBuffer2.mkString(","))//1,2,3,5

    listBuffer(1)=9
    println(listBuffer.mkString(","))

    println(listBuffer.to) //Vector(1, 9, 3, 5)
    println(listBuffer(0)) //1
    for (elem <- listBuffer) {}
    //listBuffer.foreach(println)

队列特殊集合：mutable.Queue  队列, 必须为可变的 先进先出

    // TODO 队列, 必须为可变的  先进先出
    val mqueue: mutable.Queue[Int] = new mutable.Queue
    // 增加数据
/*    mqueue += 1
    mqueue += 2*/
    mqueue.enqueue(1,2,3,4,5,6)
    println("Before=" + mqueue) //Before=Queue(1, 2, 3, 4, 5, 6)
    println(mqueue.dequeue()) //
    println(mqueue.dequeue()) //2 按增加数据去取
    println("after = " + mqueue) //after = Queue(3, 4, 5, 6)

Set:immutable 无序 不可变--   java:set ==> scala:Set

    val set: Set[Int] = Set(1,2,3,4)
    // 增加数据
    //set:+1 //报错
    println(set + 5) //Set(5, 1, 2, 3, 4)  形成新的集合
    // 删除数据
    println(set.drop(2)) //Set(3, 4)，删除前两个
    //修改，没有update； 无序，没有索引;
    println(set - 2) //Set(1, 3, 4)

    // 获取数据
    println(set(1)) //set集合中有这个元素就返回true，没有返回false
    println(set) //Set(1, 2, 3, 4)
    println(set.mkString(",")) //1,2,3,4
    for (elem <- set) {}
    //set.foreach(println)

mutable.set可变

    val mset = mutable.Set(1,2,3,4)
    // 加号运算一定会产生新的集合
    mset+=5 //产生新的集合又赋值给它
    mset+6 ///产生新的集合
    println(mset.add(7)) //true 添加元素

    val list = List(11,22,33,44)
    mset++=(list) //添加集合
    println(mset.mkString(",")) //33,1,5,2,3,7,4,22,11,44

    // 修改数据,等同于增加或删除。
    //mset.update(9, false) ////true就是添加元素到mset集合; false是不添加

    // 删除数据
    //mset.remove(1) //删除元素1
    //mset-=44  //删除元素44

    // 查询数据
    println(mset.head) //
    println(mset.tail) // tail ：集合中除了头以外的元素 Set(1, 5, 2, 3, 7, 4, 22, 11, 44)
    println(mset.last)  //最后一个元素
    println(mset.init)  // init : 集合中除了最后一个以外的元素
    println(mset)

    // java:map   ==> scala:Map
    println(mset.mkString(","))

Map 
 scala中的map也是存储k v对 ，转换结构，把a 转换为另外一个结构的 a
不可变的Map集合  没有专门类，就是包

    val map: Map[String, Int] = Map("a" -> 1, "b" -> 2)
    println(map + ("c" -> 3)) //Map(a -> 1, b -> 2, c -> 3) 产生新集合
    println(map.updated("b", 5)) //Map(a -> 1, b -> 5)
    println(map - "b") //Map(a -> 1)   新的集合

    // Option : Some就是有值或者 None是无值, java中可能空指针;scala中用Option  为了代替空指针判断
    println(map.get("a"))//Some(1)
    println(map.get("k")) //None
    println(map.get("k").getOrElse(10)) //10如果为空，则取默认值10

    println(map.keys) //Set(a, b)
    println(map.values)//MapLike(1, 2)
    println(map) //Map(a -> 1, b -> 2)

mutable.Map可变

    // TODO 可变的Map集合
    val mMap = mutable.Map("a" -> 1, "b" -> 2)

    mMap += ("c" -> 3, "d" -> 4, "E"->5)  //=是把原来的值给覆盖掉
    mMap -= ("b", "E")
    mMap.update("a", 8) //,

   // mmap.get("").getOrElse(0)
    println(mMap)  //Map(d -> 4, a -> 8, c -> 3)

Tuple元组，22个元素；函数中有22个参数数据

(, , , )
tuple._1 ._2

   // TODO Tuple 元组：将多个无关联的数据当成一个整体来使用。
    // 声明元组 : 使用小括号
    val tuple= ("abc", 123, "c")
    // 使用特殊方式(下划线+顺序号)访问元组数据
    println(tuple._2) //
    val iterator: Iterator[Any] = tuple.productIterator //迭代器
    while (iterator.hasNext){
      print(iterator.next())// abc 123 c

    }
    // 如果元组中的元素只有两个，我们称之为“对偶”，Map集合中的K，V其实就是“对偶”
    val map1 = Map(("a", 1), ("b", 2))
    map1.foreach(println) //(a,1) (b,2)
    map1.foreach(t=>{println(t._1 + "," + t._2)}) //a,1 b,2

    // 模式匹配
    map1.foreach{
      case(k, v)=>{
        println(k + "," + v)  //a,1 b,2
      }
    }

Java集合和Scala集合的互相转换

scala的集合转换为java的集合

// Scala集合和Java集合互相转换
    val arr = ArrayBuffer("", "", "")

    import scala.collection.JavaConversions.bufferAsJavaList
    val javaArr = new ProcessBuilder(arr)
    val arrList = javaArr.command()

    println(arrList) //[1, 2, 3]

Java的List转Scala数组(mutable.Buffer)

隐式转换（即自动转换，二次编译，第一次编译没通过就尝试在指定范围内看看类参数等是否可以再次编译），隐藏的把它转换为想要的类型；

    // Scala集合和Java集合互相转换
    //Scala ==> Java
    val arr = ArrayBuffer("", "", "")
    import scala.collection.JavaConversions.bufferAsJavaList
    val javaArr = new ProcessBuilder(arr)
    val arrList = javaArr.command()
    println(arrList) //[1, 2, 3]

    //Java ==> Scala
    import scala.collection.JavaConversions.asScalaBuffer
    import scala.collection.mutable
    // java.util.List ==> Buffer
    //val scalaArr: mutable.Buffer[String] = arrList
    val javaList: util.List[String] = new util.ArrayList[String]() //java中的
    val scalaArr: mutable.Buffer[String] = javaList  //scala中的 ;如果没有上边的import隐式转换，就会报错，两个不同的类型无法转换

    scalaArr.append("jack") //ArrayBuffer(1, 2, 3, jack)  Buffer(jack)
    println(scalaArr)