Scala有三类集合：序列Seq、Set、映射Map。
Scala中，几乎全部的集合，都提供可变和不可变两个版本。java
通常，咱们根据集合所在的包来区分是可变集合仍是不可变集合。数组
object Scala_Coll {
def main(args: Array[String]): Unit = {
// Scala 数组 - 不可变
// 1. 建立数组对象
// 方式一
// new Array[String](5) 编译后会生成java的数组代码
val array = new Array[String](5)
// 方式二
val array1 = Array(1,2,3,4)
// 2. 打印数组
println(array) // 输出结果 [Ljava.lang.Object;@4cdbe50f
// 3.数组赋值，Scala下标索引使用小括号
array(0) = "张三"
array(1) = "李四"
array(2) = "王五"
array(3) = "赵六"
// 4.采用update方式修改数组的值
array.update(4,"哈哈")
// 5.查看数组
println(array.mkString(","))
// 6.遍历数组- 方式1
for(i<-array){
println(i)
}
// 7.遍历数组 - 方式2
// array.foreach(i => println(i)) 精简为
array.foreach(println)
/////// 数组操做 ///////
// 1)添加数组元素，不可变数组添加数组元素后，返回一个新的数组，自己不会发生改变
// :+ 添加元素到尾部
val arr1 = array :+ 5
// +: 添加元素到首部
val arr2 = arr1.+:(5)
// ++ 添加数组
val arr3 = arr1 ++ arr2
}
}
import scala.collection.mutable.ArrayBuffer
object Scala_Coll {
def main(args: Array[String]): Unit = {
// 1.声明可变数组：scala.collection.mutable.ArrayBuffer
// 方式1
val arr1 = new ArrayBuffer[Int]()
// 方式2
val arr2 = ArrayBuffer(1,2,3,4)
// 2.增长数据
arr1.append(4,5,6,7)
println(arr1.mkString(","))
// 3.修改数据
arr1.update(1,10)
println(arr1.mkString(","))
// 4.删除数据
arr1.remove(1,2) //从索引位置1开始删除2个数据
println(arr1.mkString(","))
// 5.查询数据
println(arr1(1))
// 6.遍历集合
arr1.foreach(println)
// 7. ++ 运算符会产生新的集合数组
val arr3 = arr1 ++ arr2
println(arr3.mkString(","))
// 8. ++= 运算符则更新以前集合，并不产生新的数组
arr1 ++= arr2
println(arr1.mkString(","))
}
}
import scala.collection.mutable.ArrayBuffer
object Scala_Coll {
def main(args: Array[String]): Unit = {
val arr1 = Array(1,2,3,4)
// 将不可变数组arr1转换为可变数组
val arr2 = arr1.toBuffer
// 将可变数组arr2转换为不可变数组
val arr3 = arr2.toArray
}
}
object Scala_Coll {
def main(args: Array[String]): Unit = {
// 不可变list
// 1.声明对象
val list = List(1, 2, 3, 4)
// 2.增长元素，返回新的list
val list1 = list :+ 1
// 3.遍历list
list1.foreach(println)
// 4.空集合Nil
// 通常用于增长数据
val list2 = 1 :: 2 :: 3 :: 4 :: Nil
println(list2.mkString(","))
// 添加集合
val list3 = 1 :: 2 :: 3 :: list1 :: Nil
println(list3.mkString(",")) // 输出结果 1,2,3,List(1, 2, 3, 4, 1)
// 咱们须要将list1的元素做为一个一个的个体使用，也就是扁平化操做
val list4 = 1 :: 2 :: 3 :: list1 ::: Nil
println(list4.mkString(",")) // 输出结果 1,2,3,1,2,3,4,1
// 5.链接集合
val list5 = List.concat(list3, list4)
list5.foreach(println)
// 6.建立一个指定重复数量的列表
val list6 = List.fill[String](3)("Hello")
list6.foreach(println)
}
}
import scala.collection.mutable.ListBuffer
object Scala_Coll {
def main(args: Array[String]): Unit = {
// 1.可变list
var list1 = new ListBuffer[Int]
// 2.增长数据
list1.append(1,2,3,4)
val list2 = list1 :+ 5
list1+=5
println(list1.mkString(","))
println(list2.mkString(","))
val list3 = list1 ++ list2
println(list3.mkString(","))
// 3.修改数据
list1.update(1,10)
println(list1(1))
// 4.删除数据
list1.remove(1,2)
println(list1.mkString(","))
// 5.获取数据
println(list1(1))
}
}
import scala.collection.mutable.ListBuffer
object Scala_Coll {
def main(args: Array[String]): Unit = {
// 建立一个不可变集合
var list = List(1,2,3,4)
// 将不可变集合转变为可变集合
val buffer = list.toBuffer
// 将可变集合buffer转变为不可变集合
val list1 = buffer.toList
}
}
import scala.collection.mutable.ListBuffer
object Scala_Coll {
def main(args: Array[String]): Unit = {
// 1.建立Map 两种方式
val map1 = Map("a"->"张三","b"->"李四","c"->"王五")
val map2 = Map(("a","张三"),("b","李四"),("c","王五"))
println(map1)
println(map2)
// 2.添加数据
val map3 = map1 + ("d" -> "张三丰")
println(map3)
// 3.删除数据
val map4 = map3 - "d"
println(map4)
// 4.修改数据
val map5 = map4.updated("b", "黄蓉")
println(map5)
// 5.遍历
map5.foreach(println)
// 6.获取指定key的值
val str = map5.apply("a")
println(str)
// 7.获取可能存在的key值
val maybeString:Option[String] = map5.get("a")
println(maybeString.get) // 若是是从None值获取会发生异常
println(maybeString.getOrElse(-1)) // 若是获取到返回值，获取不到返回默认值
// 更加简洁的用法
val value = map5.getOrElse("d", -1)
println(value)
}
}
import scala.collection.mutable
object Scala_Coll {
def main(args: Array[String]): Unit = {
// 声明可变Map
val map1 = mutable.Map("a" -> "郭靖", "b" -> "黄蓉")
val map2 = mutable.Map(("a","杨过"),("b","小龙女"))
// 添加数据
map1.put("c","郭襄")
val map3 = map1 + ("d" -> "郭芙")
map1 += ("d"->"郭芙")
// 修改数据
map1.update("d","郭破虏")
map1("d") = "郭芙"
// 删除数据
map1.remove("d")
}
}
object Scala_Coll {
def main(args: Array[String]): Unit = {
// 元组能够当作是容纳元素的容器，最多能够容纳22个元素
// 声明一个元组
val tuple = (1, "a", "张三丰", 18)
// 元组中的数据能够经过数据的顺序来访问
println(tuple._1)
println(tuple._2)
println(tuple._3)
println(tuple._4)
// 元组遍历
val iterator = tuple.productIterator
while (iterator.hasNext){
println(iterator.next())
}
// 对偶元组:只有两个元素,也能够叫键值对
val map = Map(("a", "张三丰"), ("b", "张翠山")) //这种声明方式，里面就是对偶元组
}
}