【scala系列】5、容器类型：Array、List、Range

1. 可变集合与不可变集合

这里的可变与不可变不是说集合中的值是否改变而是指该对象在内存中的引用是否改变，如下代码所示：

    //Array 不可变即使修改某个元素，对象hashcode 仍然不会改变
    var arr1 = Array(1,2,3)
    println(arr1.hashCode()) //896681694
    arr1.update(0,2)
    println(arr1.hashCode()) //896681694

    //ArrayBuffer 可变当修改某个元素时，对象hashcode会改变
    var arr2 = ArrayBuffer(1,2,3)
    println(arr2.hashCode()) //387518613
    arr2.update(0,2)
    println(arr2.hashCode()) //87975734

不可变（collection.immutable._）	可变（collection.mutable._）
Array,ArrayStack	ArrayBuffer,ArraySeq
List	ListBuffer,LinkedList, DoubleLinkedList,MutableList
/	Queue
Stack	Stack
mutable.Set	immutable.Set
HashMap HashSet	HashMap HashSet

2. Array

在scala中数组分为：

• Array：不可变长数组，长度不可变，但是数组中下标元素的值是可变的
• ArrayBuffer：可变长数组，长度跟下标对应的元素值都是可变的

2.1 Array 初始化

scala> val arr1 = Array[Int](1,2,3)
arr1: Array[Int] = Array(1, 2, 3)

scala> val arr2 = new Array[String](3) // Array(null, null, null)
arr2: Array[String] = Array(null, null, null)

scala> val arr3 = new Array[String](0) // Array()
arr3: Array[String] = Array()

scala> val arr4:Array[String] = new Array(3)
arr4: Array[String] = Array(null, null, null)

scala> val arr5:Array("a","b","c","d")
res0: Array[String] = Array(a, b, c, d)

// 定义一个类型为Any的Array
scala> val arr6 = Array[Any](1, 2)
arr6: Array[Any] = Array(1, 2)
// 同
scala> val arr7: Array[Any] = Array(1, 2)
arr7: Array[Any] = Array(1, 2)
// 同
scala> val arr8: Array[_] = Array(1, 2)
arr8: Array[_] = Array(1, 2)

// 定义一个整数集合
scala> val arr9 = Array (1,3,5,7,9,11)
arr9: Array[Int] = Array(1, 3, 5, 7, 9, 11)
// 同
scala> val arr10 = Array[Int](1 to 11 by 2:_*)
arr10: Array[Int] = Array(1, 3, 5, 7, 9, 11)

// 如果Array中的元素为不同类型，那么该数组类型是这些元素的公共类型 Any
scala> var arr11 = Array("true",true,1,"1")
arr11: Array[Any] = Array(true, true, 1, 1)

//创建Array，初始化长度为5， 每个下标的初始值和泛型的初始值一致，也就是0
scala> var arr12 = new Array[Int](5)
arr12: Array[Int] = Array(0, 0, 0, 0, 0)

//不可变长数组
val arr = Array[Int](1,2,3)
// 如果一个数组中有不同类型的元素，那么这个数组的类型是这些元素的公共类型 Any
var arr2 = Array("true",true,1,"1")
// 创建一个数组，给数组初始化了长度为5， 每个下标的初始值和泛型的初始值一致，也就是0
val arr4 = Array(5) //ArrayBuffer(0, 0, 0, 0, 0)
//用 ++ 运算符组成新的数组，原来的数组并没有被改变
val arr6 = arr ++ arr4

//可变长数组
val buffer1 = ArrayBuffer[Int](1,2,3)

2.2 Array 查看元素

Array 查看数据统一使用()，而不是[]。 ()也就是apply()的简写，a(i)===a.apply(i)

scala> val arr1 = Array[Int](1, 2, 3)
arr1: Array[Int] = Array(1, 2, 3)

// 下标从0 开始最大下标为Array.length -1
scala> arr1(0)
res4: Int = 1

// 取出元素下标大于Array元素个数会抛出异常
scala> arr1(3)
java.lang.ArrayIndexOutOfBoundsException: 3
  ... 32 elided

//遍历 Array
scala> arr1.map(println(_))
1
2
3

//遍历 Array
scala> arr1.map(a=>{println(a)})
1
2
3

// 查看Array 长度
scala> arr1.length
res0: Int = 3

scala> arr1.size
res1: Int = 3

2.3 Array 增加元素

Array 是不可变长数组，长度不可变，但是数组中下标元素的值是可变的。

2.4 Array 修改元素

scala> val arr1 = Array[Int](1, 2, 3)

// 指定Array下表赋新的值
scala> arr1(0)=10

scala> arr1(1)=10

scala> arr1(2)=10

scala> arr1
res14: Array[Int] = Array(10, 10, 10)

// 使用update方法更新值
scala> arr1.update(1,200)

scala> arr1
res15: Array[Int] = Array(100, 200, 10)

// 使用updated方法更新数据，会返回一个新的Array，不会修改原Array的值
scala> arr1.updated(0,100)
res16: Array[Int] = Array(100, 10, 10)

2.5 Array 删除元素

Array 是不可变长数组，长度不可变，所以不能删减元素个数，只能将指定下表的元素置为所属类型的空值

2.6 Array 元素排序

scala> val arr1 = Array(3, 1, 5, 4, 7, 6, 9)
arr1: Array[Int] = Array(3, 1, 5, 4, 7, 6, 9)

// 排序（比较两个值得哈希值） 默认升序排列
scala> arr1.sorted
res2: Array[Int] = Array(1, 3, 4, 5, 6, 7, 9)

// 排序 降序排列
scala> arr1.sorted.reverse
res3: Array[Int] = Array(9, 7, 6, 5, 4, 3, 1)

// 排序 升序排列
scala> arr1.sortBy(a => a)
res4: Array[Int] = Array(1, 3, 4, 5, 6, 7, 9)

// 排序 降序排列
scala> arr1.sortBy(a => a).reverse
res5: Array[Int] = Array(9, 7, 6, 5, 4, 3, 1)

// 排序 升序排列
scala> arr1.sortWith(_ < _)
res6: Array[Int] = Array(1, 3, 4, 5, 6, 7, 9)

// 排序 降序排列
scala> arr1.sortWith(_ > _)
res7: Array[Int] = Array(9, 7, 6, 5, 4, 3, 1)

2.7 其他操作

scala> val arr1 = Array[Int](1, 2, 3)
arr1: Array[Int] = Array(1, 2, 3)

// 检查Array 中是否存在某个值
scala> arr1.contains(1)
res8: Boolean = true

scala> arr1.contains(11)
res9: Boolean = false

// 转换成字符串 指定分隔符
scala> arr1.mkString(",")
res10: String = 1,2,3

// 转换成字符串，指定头尾与分隔符
scala> arr1.mkString("开头位置-", "-", "-结尾位置")
res11: String = 开头位置-1-2-3-结尾位置

// 删除前 2 位元素
scala> arr1.drop(2)
res12: Array[Int] = Array(3)

// Array 反转
scala> arr1.reverse
res13: Array[Int] = Array(3, 2, 1)

//Array 的转换操作
val arr4 = Array(1,3,2,5,4)
arr4
  .map((x:Int)=>x*2) //每个元素 乘2
  .sortBy((x:Int)=>x) //按照元素顺序排序
  .reverse //将数组反转
  .foreach(println(_))

/**
  * 10
  * 8
  * 6
  * 4
  * 2
  */

//上面代码可以简写成
arr4.map(_*2).sortBy(x=>x).reverse.foreach(println)

// 字符串数组 转换操作
val strArr = Array("hello you","hello world")

val strArr2 = strArr
  .map(x=>{
    val fields = x.split(" ") // 按照空格分隔
    fields
  }).flatten

println(strArr2.toBuffer) //ArrayBuffer(hello, you, hello, world)

//上面代码简写
val strArr3 = strArr.flatMap(x=>x.split(" "))
println(strArr3.toBuffer) //ArrayBuffer(hello, you, hello, world)

3. ArrayBuffer

一个ArrayBuffer缓冲包含数组和数组的大小。对数组缓冲的大多数操作，其速度与数组本身无异。因为这些操作直接访问、修改底层数组。另外，数组缓冲可以进行高效的尾插数据。追加操作均摊下来只需常量时间。因此，数组缓冲可以高效的建立一个有大量数据的容器，无论是否总有数据追加到尾部。

3.1 ArrayBuffer 初始化

scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer

scala> val buff1 = ArrayBuffer(1,2,3)
buff1: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3)

scala> val buff2 = ArrayBuffer[Any]("hello",1,false)
buff2: scala.collection.mutable.ArrayBuffer[Any] = ArrayBuffer(hello, 1, false)

3.2 ArrayBuffer 查看元素

scala> val buff1 = ArrayBuffer(1, 2, 3)
buff1: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3)

// 根据下标访问元素
scala> val i1 = buff1(0)
i1: Int = 1

//查看是否存在某个元素
scala> val b1 = buff1.contains(1)
b1: Boolean = true
//查看是否存在某个元素
scala> val b2 = buff1.contains(9)
b2: Boolean = false

// 查看大于1 的元素
scala> buff1.filter(i => {i > 1})
res16: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(2, 3)

scala> buff1.map(a=>{println(a)})
1
2
3

3.3 ArrayBuffer 增加元素

scala> val buff1 = ArrayBuffer(1,2)
buff1: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2)

scala> val buff2 = ArrayBuffer(6,7)
buff2: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(6, 7)

// 增加一个元素
scala> buff1 += 3
res18: buff1.type = ArrayBuffer(1, 2, 3)

// 增加一个元素 , 可以添加多个
scala> buff1.append(4)
scala> buff1
res25: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4)

// 增加一个元素
scala> buff1 ++= Array(5)
res20: buff1.type = ArrayBuffer(1, 2, 3, 4, 5)

// 两个ArrayBuffer合并
scala> val buff3 = buff1 ++ buff2
buff3: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4, 5, 6, 7)

// 生成一个新的ArrayBuffer 末尾增加两个元素
scala> val buff4 = buff1 ++ Array(6,7)
buff4: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4, 5, 6, 7)

// 生成一个新的ArrayBuffer 头部追加两个元素
scala> val buff5 = buff1.++:(Array(-1,0))
buff5: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(-1, 0, 1, 2, 3, 4, 5)

// 在下标2 的位置插入100 ，后面的元素下标一次后延
scala> buff2.insert(2,100)
scala> buff2
res53: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(6, 7, 100)

scala> buff2.insertAll(3,Array(200,300))
scala> buff2
res55: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(6, 7, 100, 200, 300)

3.4 ArrayBuffer 修改元素

scala> val buff1 = ArrayBuffer(1, 2, 3)
buff1: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3)

scala> buff1(0)=10
scala> buff1
res42: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(10, 2, 3)

scala> buff1.update(1,20)

scala> buff1
res44: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(10, 20, 3)

scala> buff1.updated(2,30) // 会生成一个新的ArrayBuffer
res45: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(10, 20, 30)

3.5 ArrayBuffer 删除元素

scala> val buff1 = ArrayBuffer(1, 2, 3, 4, 5, 6, 7, 8)
buff1: scala.collection.mutable.ArrayBuffer[Int]=ArrayBuffer(1, 2, 3, 4, 5, 6,7,8)

// 删除第一个值为 1 的元素
scala> buff1 -= 1
res32: buff1.type = ArrayBuffer(2, 3, 4, 5, 6, 7, 8)

// 删除第一个值为 10 的元素 因为当前数组没有 值为10 的元素 所以不做元素删除操作
scala> buff1 -= 10
res33: buff1.type = ArrayBuffer(2, 3, 4, 5, 6, 7, 8)

// 删除一组元素(两个Array的交集)
scala> buff1 --= Array(2, 3) // ArrayBuffer(4, 5, 6, 7, 8)
res34: buff1.type = ArrayBuffer(4, 5, 6, 7, 8)

// 删除下标为0 的元素
scala> buff1.remove(0)
res35: Int = 4

// 从下标为1 开始移除 移除2个元素,如果个数超过数组剩余长度会报下标越界
scala> buff1.remove(1, 2)
scala> buff1
res37: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(5, 8)

// 删除两个Array的交集
scala> buff1 --= Array(5,9)
res38: buff1.type = ArrayBuffer(8)

3.6 ArrayBuffer 元素排序

scala> val buff1 = ArrayBuffer(3, 1, 5, 4, 7, 6, 9)
buff1: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(3, 1, 5, 4, 7, 6, 9)

// 排序（比较两个值得哈希值） 默认升序排列
scala> val buff2 = buff1.sorted
buff2: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 3, 4, 5, 6, 7, 9)

// 排序 降序排列
scala> val buff3 = buff1.sorted.reverse
buff3: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(9, 7, 6, 5, 4, 3, 1)

// 排序 升序排列
scala> val buff4 = buff1.sortBy(a => a)
buff4: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 3, 4, 5, 6, 7, 9)

// 排序 降序排列
scala> val buff5 = buff1.sortBy(a => a).reverse
buff5: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(9, 7, 6, 5, 4, 3, 1)

// 排序 升序排列
scala> val buff6 = buff1.sortWith(_ < _)
buff6: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 3, 4, 5, 6, 7, 9)

// 排序 降序排列
scala> val buff7 = buff1.sortWith(_ > _)
buff7: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(9, 7, 6, 5, 4, 3, 1)

3.7 ArrayBuffer 其他操作

val buff1 = ArrayBuffer(1, 2, 3, 4, 5)
println(buff1.max) //最大值 5
println(buff1.min) //最小值 1
println(buff1.mkString) //转字符串 12345
println(buff1.mkString(",")) //转字符串 元素按"," 隔开 1,2,3,4,5
println(buff1.mkString("[", ",", "]")) // [1,2,3,4,5]
//转字符串 元素按"," 隔开, "[" 开头, "]" 结尾
//反转数组
val buffer2 = buff1.reverse
println(buffer2) // ArrayBuffer(5, 4, 3, 2, 1)

/** 数组的转换操作 */
val buff3 = ArrayBuffer(1, 3, 2, 5, 4)
val buff4 = buff3
  .map((x: Int) => x * 2) //,每个元素 乘以2
  .sortBy((x: Int) => x) //按照元素顺序排序
  .reverse //将数组反转

println(buff4) //ArrayBuffer(10, 8, 6, 4, 2)

//上面代码可以简写成
val buff5 = buff3.map(_*2).sortBy(x=>x).reverse
println(buff5) //ArrayBuffer(10, 8, 6, 4, 2)

val buff6 = ArrayBuffer("hello you", "hello world")
val buff7 = buff6
  .map(x => {
    val fields = x.split(" ")
    fields
  }).flatten
println(buff7) //ArrayBuffer(hello, you, hello, world)

//上面代码简写
val buff8 = buff6.flatMap(x => x.split(" "))
println(buff7) //ArrayBuffer(hello, you, hello, world)

// 去重
val buff9 = buff8.distinct
println(buff9) //ArrayBuffer(hello, you, world)

// 清空
buff7.clear()
println(buff7) //ArrayBuffer()

/**
  * 拉链操作
  * zip函数将传进来的两个参数中相应位置上的元素组成一个pair数组。
  * 如果其中一个参数元素比较长，那么多余的参数会被删掉
  */
val buff10 = ArrayBuffer(1, 2, 3, 4, 5, 6)
val buff11 = ArrayBuffer(1, 2, 3, 4)
val buff12 = buff10.zip(buff11)
println(buff12) //ArrayBuffer((1,1), (2,2), (3,3), (4,4))

4. Range

Range表示的是一个有序的等差整数数列。比如说，“1，2，3，”就是一个Range，“5，8，11，14，”也是。在Scala中创建一个Range类，需要用到两个预定义的方法to和by。

4.1 Range 初始化

scala> 1 to 5
res56: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5)

scala> 1 until 5
res57: scala.collection.immutable.Range = Range(1, 2, 3, 4)

scala> // 设置步长

scala> 1 to 10 by 2
res58: scala.collection.immutable.Range = Range(1, 3, 5, 7, 9)

scala> //定义Double类型的Range

scala> 1L to 10L by 3
res59: scala.collection.immutable.NumericRange[Long] = NumericRange(1, 4, 7, 10)

scala> //定义Double类型的Range 设置步长

scala> 1.1 to 4.5 by 1.2
res60: scala.collection.immutable.NumericRange[Double] = NumericRange(1.1, 2.3, 3.5)

scala> //定义Char类型的Range

scala> 'a' to 'z' by 4
res61: scala.collection.immutable.NumericRange[Char] = NumericRange(a, e, i, m, q, u, y)

scala> val r2 = Range('a','f')
r2: scala.collection.immutable.Range = Range(97, 98, 99, 100, 101)

scala> 1 to (11,2)
res62: scala.collection.immutable.Range.Inclusive = Range(1, 3, 5, 7, 9, 11)

scala>  1 to 11 by 2
res63: scala.collection.immutable.Range = Range(1, 3, 5, 7, 9, 11)

scala> 1 until (11,2)
res64: scala.collection.immutable.Range = Range(1, 3, 5, 7, 9)

scala> 1 until 11 by 2
res65: scala.collection.immutable.Range = Range(1, 3, 5, 7, 9)

scala> (1 to 10 by 4)
res66: scala.collection.immutable.Range = Range(1, 5, 9)

scala> //BigInt 类型的Range

scala> (1:BigInt) to 3
res67: scala.collection.immutable.NumericRange.Inclusive[BigInt] = NumericRange(1, 2, 3)

4.2 Range 查看元素

scala> val r1 = Range(1, 5)
r1: scala.collection.immutable.Range = Range(1, 2, 3, 4)

scala> r1(0)
res68: Int = 1

scala> r1.filter(_>2)
res69: scala.collection.immutable.IndexedSeq[Int] = Vector(3, 4)

scala> r1.map(print(_))
1234res70: scala.collection.immutable.IndexedSeq[Unit] = Vector((), (), (), ())

scala> r1.size
res71: Int = 4

scala> r1.length
res72: Int = 4

scala> r1.find(i=>i<3)
res73: Option[Int] = Some(1)

scala> r1.start
res74: Int = 1

scala> r1.end
res75: Int = 5

scala> r1.last
res76: Int = 4

4.3 Range 增加和删除元素

Range 是不可变长的，不能增加或减少长度，但是数组中下标元素的值是可变的。

5. List 与 ListBuffer

List是一种有限的不可变序列式，通常被认为是Scala中最重要的数据结构。
List：底层是链表结构，元素不可变，插入有序、可重复、增加移除元素快、查询慢，由于List不是index sequence，定位访问成本高，不建议使用。同样不建议使用的还有List 的 length
ListBuffer：类似于数组缓冲。区别在于前者内部实现是链表， 而非数组。如果你想把构造完的缓冲转换为列表，那就用列表缓冲，别用数组缓冲。

5.1 List 初始化

// 定义不可变长list，长度不可变且下标对应的元素不可变
val list1 = List(1,2,3,4,5)
println(list1) //List(1, 2, 3, 4, 5)

// 定义可变长list
val list2  = ListBuffer(1,2)
println(list2) //ListBuffer(1, 2)

5.2 List 查看元素

val list1 = List(1,2,3,4,5)
println(list1(0))

val list2  = ListBuffer(1,2)
list2.map(print(_)) //12

println("")
list1.filter(_>2).map(print(_)) //345

5.3 List 增加元素

scala> import scala.collection.mutable.ListBuffer
import scala.collection.mutable.ListBuffer

scala>

scala> val list1  = ListBuffer(1,2)
list1: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2)

scala> // += 符号后面只能跟数组的单个元素

scala> list1 += 3 //ListBuffer(1, 2, 3)
res81: list1.type = ListBuffer(1, 2, 3)

scala> // ++= 符号后面只能跟数组集合

scala> list1 ++= List(4,5)
res82: list1.type = ListBuffer(1, 2, 3, 4, 5)

scala> //添加 三个元素

scala> list1.append(6,7,8)

scala> //在下标为1 的元素前插入元素

scala> list1.insert(1, 10, 11)

scala> // 向头部添加元素 形成一个新的list

scala> val list2 = List(4,5,6)
list2: List[Int] = List(4, 5, 6)

scala> // 需要注意的是后面的(1,2,3) 是作为一个整体 与前面的list进行合并的

scala> val list3 = list2.::(1,2,3)
list3: List[Any] = List((1,2,3), 4, 5, 6)

scala> // 同

scala> val list4 = list2.+:(1,2,3)
list4: List[Any] = List((1,2,3), 4, 5, 6)

scala> // 同

scala> val list5 =  (1,2,3)::list2
list5: List[Any] = List((1,2,3), 4, 5, 6)

scala> // 同

scala> val list6 =  (1,2,3)+:list2
list6: List[Any] = List((1,2,3), 4, 5, 6)

scala> //将1,2,3 拆分 与后面的集合进行合并

scala> val list7 =  List(1,2,3) ++ list2
list7: List[Int] = List(1, 2, 3, 4, 5, 6)

scala> //向list 尾部添加元素

scala> val list8 = List(4,5,6)
list8: List[Int] = List(4, 5, 6)

scala> val list9 = list8.:+(7,8,9)
list9: List[Any] = List(4, 5, 6, (7,8,9))

scala> val list10 = list8 ++ List(7,8,9)
list10: List[Int] = List(4, 5, 6, 7, 8, 9)

scala> // 同

scala> val list11 = List(4, 5, 6) ++ List(7, 8, 9)
list11: List[Int] = List(4, 5, 6, 7, 8, 9)

5.4 List 修改元素

val list1 = ListBuffer(1, 2, 3)
list1(0)=10
println(list1) //ListBuffer(10, 2, 3)

list1.update(1,20)
println(list1) //ListBuffer(10, 20, 3)

val list2 = list1.updated(2,30)
println(list2) //ListBuffer(10, 20, 30)

5.5 List 删除元素

scala> val list1 = ListBuffer(1, 2, 3, 4, 5, 6, 7, 8)
list1: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3, 4, 5, 6, 7, 8)

scala> //删除第一个值为 1 的元素

scala> list1 -= 1
res85: list1.type = ListBuffer(2, 3, 4, 5, 6, 7, 8)

scala> //删除一组元素

scala> list1 --= List(2, 3)
res86: list1.type = ListBuffer(4, 5, 6, 7, 8)

scala> //删除下标为0 的元素

scala> list1.remove(0) //ListBuffer(5, 6, 7, 8)
res87: Int = 4

scala> //从下标为1 开始移除 移除2个元素,如果个数超过数组剩余长度会报下标越界

scala> list1.remove(1, 2)

scala> list1
res89: scala.collection.mutable.ListBuffer[Int] = ListBuffer(5, 8)

5.6 List 元素排序

val list1 = List(3, 1, 5, 4, 7, 6, 9)

// 排序（比较两个值得哈希值） 默认升序排列
val list2 = list1.sorted
println(list2.toBuffer) //ArrayBuffer(1, 3, 4, 5, 6, 7, 9)

// 排序 降序排列
val list3 = list1.sorted.reverse
println(list3.toBuffer)

// 排序 默认升序排列
val list4 = list1.sortBy(a => a)
println(list4.toBuffer) //ArrayBuffer(1, 3, 4, 5, 6, 7, 9)

// 排序 降序排列
val list5 = list1.sortBy(a => a).reverse
println(list5.toBuffer) //ArrayBuffer(9, 7, 6, 5, 4, 3, 1)

// 排序 升序排列
val list6 = list1.sortWith(_ < _)
println(list6.toBuffer) //ArrayBuffer(1, 3, 4, 5, 6, 7, 9)

// 排序 降序排列
val list7 = list1.sortWith(_ > _)
println(list7.toBuffer) ////ArrayBuffer(9, 7, 6, 5, 4, 3, 1)

println(sortList(list1)) //List(1, 3, 4, 5, 6, 7, 9)

def sortList(list:List[Int]):List[Int] = list match{
    case List() => List()
    case head :: tail => compute(head,sortList(tail))
}

def compute (data:Int,dataSet:List[Int]):List[Int] = dataSet match{
    case List() => List(data)
    case head :: tail => if (data <= head) data :: dataSet
    else head :: compute(data,tail)
}

5.7 List 其他操作

val list1 = List(4, 5, 6)
println(list1.sum) // 求和 15
println(list1.max) // 最大值 6
println(list1.min) // 最小值 4
println(list1.head) // 第一个元素 4
println(list1.last) // 最后一个元素 6
println(list1.reverse) // 反转序列 形成一个新的list 原有list 不变  List(6, 5, 4)
println(list1.mkString) //转换stirng 456
println(list1.mkString("[", ",", "]")) //拼接string [4,5,6]

/** 序列的转换 */
val list2 = List(1, 2, 3, 4, 5, 6, 7, 8, 4, 5, 6)
//每次转换都会形成新的list
list2.map(_ * 2).filter(x => x >= 10).distinct.reverse.foreach(println)

/**
  * 16
  * 14
  * 12
  * 10
  */

List(1, 2, 3, 4) intersect List(4, 3, 6) // 交集 = List(3, 4)
List(1, 2, 3, 4) diff List(4, 3, 6) // 差集A-B = List(1, 2)
List(1, 2, 3, 4) union List(4, 3, 6) // 并集 A+B = List(1, 2, 3, 4, 4, 3, 6)