scala part6 黑马集合

scala不可变集合支持安全的并发访问

Traversable（是可变集合和不可变集合的父特质（immutable.Traversable，mutable.Traversable））

//创建空的Traversable对象
val t1:Traversable[Int] = Traversable.empty[Int]

val t2:Traversable[Int] = Traversable[Int]()

val t3:Traversable[Int] = Nil

println(t1 == t1) //==比较数据值
println(t1 eq t2) //eq比较地址值


//创建带参数的Traversable
val t1:Traversable[Int] = List(1,2,3).toTraversable

val t1:Traversable[Int] = Traversable(1,2,3)

转置Traversable集合（transpose()方法）

Traversable(1,4,7) Traversable(1,2,3)

Traversable(2,5,8) ---> Traversable(4,5,6)

Traversable(3,6,9) Traversable(7,8,9)

val t1:Traversable[Traversable[Int]] = Traversable(Traversable(1,4,7),Traversable(2,5,8),Traversable(3,6,9))


val t2:Traversable[Traversable[Int]] = t1.tanspose

拼接集合

concat()

val t1 = Traversable(11,22,33)
val t2 = Traversable(44,55)
val t3 = Traversable(66,77,88,99)
val t4 = Traversable.concat(t1,t2,t3)

利用偏函数筛选元素

collect()

扫描二维码关注公众号，回复： 12715922 查看本文章

def collect[B](pf: PartialFunction[A,B]):Traversable[B]

def main(args:Array[String]): Unit = {
   val t1 = (1 to 10).toTraversable
   val t2 = Traversable(1,2,3,4,5,6,7,8,9,10)

   
   val pf:PartialFunction[Int, Int] = {
      //x表示集合中的每一个元素
      case x if x % 2 == 0 => x
   }

   val t3 = t1.collect(pf)


   val t4 = t2.collect({case x if x % 2 == 0 => x})

}

计算阶乘（计算每一个元素的阶乘并把他放到另一个集合中）

scan()

def scan[B](z: B)(op:(B,B)=> B)

t1.scan(初始化值)(函数对象)

//x表示前一个值的阶乘值，y表示要计算的下一个数据

val t2 = t1.scan(1)((x:Int, y:Int) => x*y )  //1 1 2 6 24 120

val t3 = t1.scan(2)(_ * _)  //2 2 4 12 48 240

获取集合中指定元素

head, last, headOption, lastOption, find, slice

def slice(from:Int, until:Int):Traversable[A]

判断元素是否合法

//所有元素都满足条件，返回true

def forall(p: (A) => Boolean): Boolean

//有一个满足就返回true

def exists(p: (A) => Boolean): Boolean

聚合函数

sum,product,count,max,min

集合类型转换

toArray, toList, toSet

填充元素（往集合中快速添加相同元素）

fill()快速生成指定数量的元素

iterate()根据指定的条件生成指定个数的元素

range()生成某个区间的指定间隔的所有数据

//5表示五个元素（每个元素对象都是一个集合对象），2是每个集合对象的长度为二
Traversable.fill(5,2)("sdfgh")
Traversable.fill(3)(Random.nextInt(100))

//1表示初始化值，5表示最终要获取的元素个数
Traversable.iterable(1,5)(_*10)  //1 10 100 1000 10000

//包左不包右，间隔为5
Traversable.range(1,21,5) //1，6，11，16 


Traversable.range(1,5) //1，2，3，4

遍历集合（iterable和foreach）

val list = (1 to 5).toList

val it:Iterator[Int] = list.iterator

while(it.hasNext){
   val num = it.next()

}

list.foreach((x:Int) => println(x))

分组遍历

def grouped(size: Int): Iterator[Iterable[A]]

//grouped方法将iterable集合五个元素一组进行分组
val list = (1 to 13).toList
val it = list.grouped(5)

while(it.hasNext){
   val result1 = it.next


}

按照索引生成元组

zipWithIndex

val list1 = Iterable("A","B","C","D")

val list2:Iterable[(String,Int)] = list1.zipWithIndex

val list3:Iterable[(Int,String)] = list2.map(x => x._2 -> x._1)

list3.foreach(println(_))

判断集合是否相同(list：顺序相同，元素相同。set：无所谓顺序)

sameElements()

可变栈

ArrayStack(1,2,3,4,5)

val s1 = mutable.ArrayStack(1,2,3,4,5)

s1.dup() //复制栈顶元素  //1，1，2，3，4，5


s1.preserving({
   //该方法中的内容执行后，栈中的数据会恢复到该方法执行前的状态
   s1.clear()
})

scala part6 黑马 集合

猜你喜欢

scala part6 黑马集合