java scala 数组_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

ListQueueStreamStack IndexedSeq

StringArrayVector(1 to 10)NumericRangeRange  Set

HashSetSortedSet(TreeSet是其子类)BitSetListSet Map

HashMapSortedMap(TreeMap)ListMap

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

1.2 mutable Collections

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

Traversable

Iterable

SetBuffer

ArrayBufferListBuffer MapSeq

IndexedSeq

ArraySeqStringBuilderArrayBuffer LinearSeq

LinkedListQueueDoubleLinkedList

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

for (elem1

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)

}

}