Scala之-数据结构-(集合类型）Array and List

Scala之-数据结构-(集合类型）Array and List

首先看看Scala的集合一览图：

scala中的集合类型有2个包

不可变集合：scala.collection.immutable

• 不可变集合就是本身不能动态变化，类似于Java的数组，不能动态地扩容，只能copy生成另一个集合

可变集合： scala.collection.mutable

• 集合本身可以动态变化，比如Java中的ArrayList

几乎所有的集合类型都有2种形态，scala默认采用不可变的类型。

1 scala集合分类

1.1 immutable Collections

Traversable

• Iterable是三大类型的父特质
  • Seq
    • LinearSeq
      • List
      • Queue
      • Stream
      • Stack
    • IndexedSeq
      • String
      • Array
      • Vector(1 to 10)
      • NumericRange
      • Range
  • Set
    • HashSet
    • SortedSet(TreeSet是其子类)
    • BitSet
    • ListSet
  • Map
    • HashMap
    • SortedMap(TreeMap)
    • ListMap

三种集合都拓展自Iterable的特质，可以循环遍历。

1.2 mutable Collections

在可变类型的包中，引入了一个Buffer集合类，还引入了Syn开头的线程安全的集合类

• Traversable
  • Iterable
    • Set
    • Buffer
      • ArrayBuffer
      • ListBuffer
    • Map
    • Seq
      • IndexedSeq
        • ArraySeq
        • StringBuilder
        • ArrayBuffer
      • LinearSeq
        • LinkedList
        • Queue
        • DoubleLinkedList

2 定长数组Array与不定长数组ArrayBuffer

2.1 声明数组

//声明定长数组
Array(1,2,3,4)
new Array[Int]()

//声明非定长数组
new ArrayBuffer[Int]()

2.2 定长 <=>非定长

 val arr = Array(1,2)
 //定长转不定长
 val buffer:mutable.Buffer = arr.toBuffer()
   
 buffer.append(10)
 //不定长转定长
 val array = buffer.toArray()
   

2.3 定义二维数组

    //定义二维数组
    val array1: Array[Array[Int]] = Array.ofDim[Int](3, 4)

    for (elem <- array1) {
      for (elem1 <- elem) {
        println(elem1)
      }
    }

3 Java与Scala类型的相互转换

首先，我们得导入相关的转换类的相关implicit def

• import scala.collection.JavaConversions._
• Import scala.collection.JavaConverts._

3.1 JavaConversions

实际上是导入了隐式样转换的方法implicit def bufferAsJavaList

    //隐士方法也可以导入
    val buffer: ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4)
    // Scala的Arraybuffer转化Java的List
    import scala.collection.JavaConversions.bufferAsJavaList
    val list: java.util.List[Int] = buffer

    println(list.getClass().getName)

    //Java的List转Scala的ArrayBuffer
    val newBuffer:mutable.Buffer = list
    println(newBuffer)

3.2 JavaConverts

  	//这个包是将类型转换成scala、java中最详尽的类型，类型可以自动推导  
		import scala.collection.JavaConverters._

    val buffe1r:mutable.Buffer[Int] = list.asScala
    buffe1r.append(5,6)
    println(buffe1r)

    val list1  = buffe1r.asJava
    println(buffe1r)

4 mutable.List and ListBuffer的常用操作

4.1 List操作

sortBy(i => i)

sortWith((a,b) => a>b)

**reverse() ** ：反转

take(n) ：从链表头取n个元素

tableright(n). :从末尾开始取n个元素

//List 是不可变集合，针对该集合对象做任何操作都不会修改原List，而是生成新的List
val list = Nil
  
list.++(List(1)) //将List(1)的元素拼接到list的末尾，生成新的list
list.+:(2) // 添加元素到list的头 == 2 +: list == 2 :: list
list.:+(3) //添加元素到list的末尾 == list +: 3  ==  list :: 3 
  2:+list
  list:+3

list.::(2)  => list :: 2 => 2 :: list :: 1  执行顺序是从右往左,  ::左右只能是元素
list.:::(Nil) => Nil:::list:::List(1,2) 执行顺序是从右往左，  :::左右只能是Traversable的集合

4.2 ListBuffer操作

Append() :追加元素

Remove()： 移除元素

Clear()：清空元素

Reverse()：反转链表

Take()\takeRight()\takeWhile()

…

ListBuffer可以使用List的 .+:和.:+和.++(list)，但是不能使用 :+ , +:, :: ,:::

此外还新增了 += , -= ,- ,:/ ,\: ++=(list)

object ListBuffer001 {
  def main(args: Array[String]): Unit = {
    val buffer = new ListBuffer[Int]()

    buffer.append(2)
    buffer.append(1)
    val ints: ListBuffer[Int] = buffer.sortBy(i => i)
    val ints1: ListBuffer[Int] = buffer.sortWith((a, b) => a > b)

    val sorted: ListBuffer[Int] = buffer.sorted

    buffer.remove(1, 1)
    //    buffer.clear()

    println(sorted)

    val ints2: ListBuffer[Int] = buffer.++(Nil) // 添加其他List生成新的List
    buffer.++=(Nil) //在自身基础上添加列表元素
    buffer.-=(1) //在自身基础上减元素
    buffer.+=(1) //在自身基础上添加元素
    buffer.+=(1, 2, 3) //在自身基础上添加元素
    val ints3: ListBuffer[Int] = buffer.-(1) //删除元素，另外生成新的List
    val ints4: ListBuffer[Int] = ints3.+:(1)
    val ints5: ListBuffer[Int] = ints3.:+(1)

    val ints6: ListBuffer[Int] = ints2.++(ints3)
      
    //取元素
    ints6.takeRight(1)
    ints6.take(1)
    ints6.takeWhile(i => i / 2 == 0)
  }
}