Scala 数组、集合、列表、队列、栈、基本函数

scala 没有自己定义的数组，底层就是java的数组

• :+ 一般用于给不可变的集合添加单个元素在末尾
• +: 一般用于给不可变的集合添加单个元素在头部
• ++ 合并两个集合
• += 一般用于可变集合，便是原地修改集合 尾部
• +=: 一般用于可变集合，便是原地修改集合 头部
• ++= 把后面的集合追加到前面集合的后面, 更新的是前面的集合 ,后面集合不变
• ++=: 把前面集合的元素添加到后面集合的前面, 更新的是后面的集合，前面集合不变
• -= 删除元素
• –= 移除两个集合中的共同部分
• -=() 移除指定元素可移除多个，但已经不推荐使用了
• :: List专用 在前面添加一个元素
• ::: List专用 合并两个集合

1、创建数组

• 直接通过给数组初始化元素的方式创建数组
• 创建时指定数组长度

object Array1{
	def main(args: Array[String]): Unit = {
		//第一种
		val arr:Array[int] = Array[Int](1,2,3,4)
		//第二种
		//val arr:Array[int] =new Array[Int](10) 默认值为 0
		println(arr(0)) //通过此方法访问数组中的元素
		println(arr.mkString(",")) //用逗号将元素拼接
		//遍历数组 for 、 while
		val arr1:Array[Int] = arr :+ 100 //等价于：arr.+:(100)
		//在尾部追加元素 100
		val arr2:Array[Int] = 100 +: arr
		//在数组前面追加元素100
		val arr3:Array[int] = Array[Int](30,40,50,60)
		val arr4:Array[int] = Array[Int](70,80,90,100)
		val arr5:Array[Int] = arr3 ++ arr4 //将两个数组合并
		println(arr5.mkString(",")) 
	}
}

2、可变数组、集合

ArrayBuffer

1. ArrayBuffer(1,2,3)
2. new ArrayBufferInt

object Array2 {
  def main(args: Array[String]): Unit = {
    // ArrayBuffer.apply(1,2,3,4) 第一种
    // val buffer2 = new ArrayBuffer[Int]() 第二种
    //遍历
    //for (elem <- buffer1){}
    val buffer1: ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4, 1)
    val buffer2: ArrayBuffer[Int] = ArrayBuffer(1, 2, 30, 40)
    val b2:ArrayBuffer[Int] = 100 +: buffer1 :+ 10 //100加前面 10加后面
    println(buffer1)
    println(buffer2)
  	// 原地修改buffer1, 在他的尾部添加元素
    buffer1 += 100 //这前面不能加 : 
    200 +=: buffer1  //在集合的头部添加
    println(buffer1)
    val b3 = buffer1 ++ buffer2
    buffer1 ++= buffer2  // 把buffer2 的集合追加到buffer1的后面, 更新的是buffer1 ,buffer2 不变
 	buffer2.++:(buffer1)
	buffer1 ++=: buffer2  // 把buffer1的元素添加到buffer2的前面, 更新的是buffer2 ，buffer1不变
	buffer1 -= 1 //删除元素 若集合中又两个或多个1 ，只删除满足的第一个 set 用的比较多
	buffer1 --= buffer2 //类似求差集
	buffer1 -= (1,2,3)  // 已经不推荐使用了
	val a:Array[Int] = buffer1.toSet.toArray //去重
	println(buffer1)
  }
}

3、可变数组与不可变的转换

object Array3 {
  def main(args: Array[String]): Unit = {
   	val arr1:Array[Int]  = Array(30, 50, 70, 60, 10, 20)
    val buffer: mutable.Buffer[Int] = arr1.toBuffer
    println(buffer)
    val b: ArrayBuffer[Int] = ArrayBuffer(10, 20)
    println(b.toArray.mkString(","))
  }
}

4、多维数组的创建

object Array4 {
  def main(args: Array[String]): Unit = {
    // 多维数组  (二维数组), 假的, 用一维数组模拟的多维数组
    // 生成一个 2 * 3 的数组
    val arr: Array[Array[Int]] = Array.ofDim[Int](2, 3)
    println(arr(0)(1))
    for (a1 <- arr) {
      for (elem <- a1) {
        println(elem)
      }
    }
  }
}

5、List列表

List 列表，默认不可变

~不可变List

object List1 {
  def main(args: Array[String]): Unit = {
    // 1.创建有元素的集合
    val l1 = List(1, 2, 3)
    // 2. 空List
    val l2 = List[Int]() //必须说明范型
    // 3. 空集合
    val l3 = Nil
    // 4. 向List添加元素
    val l4 = 200 +: l1 :+ 100
    val l5 = 200 :: 100 :: l1
    println(l4)
    println(l5)
  }
}

object List2 {
  def main(args: Array[String]): Unit = {
    val list1 = List(30, 50, 70, 60, 10, 20)
   	val list2 = List(3, 5, 7, 6, 1, 2)
    val list3 = list1 ++ list2 
    val list4 = list1 ::: list2  // 等价于list2.:::(list1)
    println(list3)
    println(list4)
    val l1 = ::[Int](1, 1 :: Nil)
    println(l1)  //输出：List(1,1)
  }
}

~ 可变List ListBuffer

object ListBuffer1 {
  def main(args: Array[String]): Unit = {
		val buffer:ListBuffer[Int] = ListBuffer(1,2,3)
		buffer += 10
		100 +=: buffer
		println(buffer)
	}
}

object List3 {
  def main(args: Array[String]): Unit = {
    var arr1:Array[Int] = Array(30, 50, 70, 60, 10, 20,80)
    println(System.identityHashCode(arr1))
    arr1 :+= 100
    println(System.identityHashCode(arr1))
    println(arr1.mkString(", "))
    //本来arr1为不可变的，往后加100时数组的地址发生改变，
    //其实时产生一个新的不可变集合，在把新的不可变集合赋值给变量
  }
}

6、Set集合

• 可变和不可变 默认不可变
• 元素不重复，无序

~不可变 Set

object Set1