(Scala四.1) Scala中的集合集成结构和常用方法

import java.awt.Font

import scala.collection.mutable
import scala.collection.mutable.ArrayBuffer
import scala.util.Sorting
//#######################4.1主要的集合特质#####################################
/**
  * scala同时支持可变集合和不可变集合
  * 1)不可变集合: scala.collection.mutable
  * 2)可变集合: scala.collection.immultable
  * scala优先采用不可变集合
  * 集合主要分为三大类:序列(List),集(Set),映射(Map)
  */


//#######################4.2数组#####################################
/**
  * 定长数组Array
  */
val array = new Array[Int](10)

/**
  * 变长数组ArrayBuffer (类似java中的ArrayList)
  */
val arrayBuffer = ArrayBuffer[Int](1, 2, 3, 4, 5, 6)
arrayBuffer -= 2 += 3 //去掉第2个元素,在后面加上第3个元素


/**
  * Array与ArrayBuffer的互转
  */
val ab = array.toBuffer
val a = arrayBuffer.toArray

/**
  * 数组的遍历
  */
for (i <- 0 to a.length - 1)
  println(i + ":" + a(i))

for (i <- 0 until a.length)
  println(i + ":" + a(i))

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

/**
  * 过滤/映射
  */
val arr = Array(2, 13, 5, 17, 11, 12)
arr.filter(_ % 2 == 0) //过滤,模2=0,()中的是匿名函数
arr.map(2 * _) //映射,所有值x2,()中的是匿名函数
arr.filter(_ % 2 == 0).map(_ % 2 == 0)

/**
  * 求和
  */
Array(2, 3, 5, 7, 11, 12).sum

/**
  * 寻最大值
  */
arr.max

/**
  * 排序
  */
arr.sorted
arr
Sorting.quickSort(arr) //快排
arr

/**
  * 转String
  */
arr.mkString(" and ")
arr.mkString("<", ",", ">")
arr.toString

/**
  * 定长数组扩充
  * 扩充到20,用-1填充
  */
arr.padTo(20, -1)
(1 to 10)
(1 to 10).padTo(20, -1)


/**
  * 数组拷贝
  * 定长数组2有多大,就往里面装多大
  */
val arr2 = Array(1, 2, 3)
arr.copyToArray(arr2)
arr2



/**
  * 多维数组
  * 多维数组的创建和遍历
  * 三行四列的矩阵(大数组中3个小数组,每个小数组中4个元素)
  */
val matrix = Array.ofDim[Int](3, 4)
matrix(0)(0) = 0
matrix(0)(1) = 1
matrix(0)(2) = 2
matrix(0)(3) = 3
matrix(1)(0) = 10
matrix(1)(1) = 11
matrix(1)(2) = 12
matrix(1)(3) = 13
matrix(2)(0) = 20
matrix(2)(1) = 21
matrix(2)(2) = 22
matrix(2)(3) = 23
for (bigElem <- matrix) {
  for (elem <- bigElem) {
    print(elem + " ")
  }
  println()
}


/**
  * 和Java数组的互操作
  */

import scala.collection.JavaConverters._
import scala.collection.mutable._

val command = ArrayBuffer("ls", "-al", "/")

val pb = new ProcessBuilder(command.asJava) //Scala to Java
val cmd: Buffer[String] = pb.command().asScala //Java to Scala  :后是类型
//val cmd = pb.command().asScala //Java to Scala
cmd == command


//###########################4.3 映射#################################
/**
  * 不可变构造映射
  */
val scores = scala.collection.immutable.Map("Tom" -> 80, "Bob" -> 90, "Liy" -> 100)

/**
  * 可变映射
  */
val scores1 = scala.collection.mutable.Map("Tom" -> 80, "Bob" -> 90, "Liy" -> 100)

//空映射(空集合、空映射需要用new关键字)
val scores2 = new scala.collection.immutable.HashMap[String, Int]
//对偶
val scores3 = "Alice" -> 10

val scores4 = Map(("Alice", 10), ("Bob", 3), ("Cindy", 8))


/**
  * 获取值
  */
val bobScore = scores("Bob")
//val bob2Score = scores("Bob2") //报异常java.util.NoSuchElementException: key not found: Bob2
scores.get("Bob2") //None
scores.get("Bob2").getOrElse("nobody")
scores.contains("Bob2")


/**
  * 可变映射更新值
  */
//scores("Bob") = 10
//scores1("Bob") = 50
scores1 += ("Bob" -> 10, "Fred" -> 7) //有则更新,没则新增
scores1 -= "Tom"

//不能更新一个不可变映射,但是可以获取一个修改过的新映射
scores + ("Bob" -> 10, "Fred" -> 7)

/**
  * 迭代映射
  */
for ((k, v) <- scores) println(k + " = " + v)
for (k <- scores.keys) println(k)
for (v <- scores.values) println(v)


/**
  * 排序
  */
val scores5 = scala.collection.mutable.SortedMap(100 -> "Tom", 90 -> "Bob", 80 -> "Liy")

/**
  * 双向链表HashMap
  */
val months = scala.collection.mutable.LinkedHashMap("Tom" -> 100, "Bob" -> 90, "Liy" -> 80)

/**
  * 与Java互转
  */
//val command = ArrayBuffer("ls", "-al", "/")
//
//val pb = new ProcessBuilder(command.asJava) //Scala to Java
//val cmd: Buffer[String] = pb.command().asScala //Java to Scala  :后是类型
////val cmd = pb.command().asScala //Java to Scala
//cmd == command

val props = System.getProperties.asScala

import java.awt.font.TextAttribute._

val attrs = Map(FAMILY -> "Serif", SIZE -> 12)
val font = new Font(attrs.asJava)


//###########################4.4 元组#################################

/**
  * 元组是不同类型的值得聚集
  * 元组是从1开始不是0,可以把t._2写成t _2,但补鞥呢写成t_2
  * 元组可用于函数需要返回不止一个值的情况,使用元组的原因之一是把多个值绑在一起,以便他们能够被一起处理
  */
val t = (1, 3.14, "Fred")

val second = t._2
val three = t _3

/**
  * 拉链操作
  * 见异思迁,把2ge集合的元素根据索引位置绑在一块,大小取决于小的那个长度
  */
val symbols = Array("<", "-", ">")
val counts = Array(2, 10, 3, 4)

val pairs = symbols.zip(counts)



//###########################4.5 队列#################################
/**
  * 队列
  * 是一个先进先出的结构
  */
val q1 = new mutable.Queue[Int]()
q1 += 1 //压栈
q1 += 2 //压栈
q1 ++= List(3, 4) //压栈
q1.dequeue() //弹栈
q1.enqueue(5, 6, 7) //压栈
q1
q1.head
q1.tail //除首元素之外的元素


//########################### 4.6 堆栈 #################################
/**
  * 堆栈
  * Stack是一个先进后出的结构
  */
val s = new mutable.Stack[Int]()
s.push(1)
s.push(2)
s.pushAll(List(3, 4))
s.pop()
s
s.head
s.tail

//########################### 4.7 列表 #################################
/**
  * 列表
  * 如果List为空,用Nil来表示
  */
val digits = List(4, 2)

9 :: List(4, 2)

1::2::List(4, 2)

1::2::3::4::Nil



//########################### 4.8 集 #################################
/**
  * 集 Set
  * 不重复元素的集合,不保留顺序,默认哈希排序
  * 需要排序的话可以用SortedSet,它的排序时通过红黑树实现的
  */

4.10常用方法

类似文章:https://blog.youkuaiyun.com/bitcarmanlee/article/details/72795013