Scala集合使用详解-优快云博客

本文链接：https://blog.youkuaiyun.com/blackproof/article/details/88302221

转http://www.importnew.com/4543.html

Scala提供了一系列的集合类的实现。同时，它对于集合类型也进行了一些抽象。这就使得你可以操作一个集合的Foo对象，而不用去关心这个集合是一个List，Set还是其他的什么。

这个网页提供了一个很好的方式来理解scala里的集合的默认实现，并且都链接到了相应的scaladoc。

基本集合类常用的集合类型
层级关系集合类的抽象关系
集合方法
可变性
Java 集合类也可直接使用

基本集合类

List

标准的linked list。

 
    
         scala> List( 
         1 
         ,  
         2 
         ,  
         3 
         ) 
        
 
         res0: List[Int] = List( 
         1 
         ,  
         2 
         ,  
         3 
         ) 
        
 
  

你也可以像在函数式语言里一样把它们串接起来。

 
    
         scala>  
         1 
         ::  
         2 
         ::  
         3 
         :: Nil 
        
 
         res1: List[Int] = List( 
         1 
         ,  
         2 
         ,  
         3 
         ) 
        
 
  

参考 API文档

Set

Set里不包含重复元素

 
    
         scala> Set( 
         1 
         ,  
         1 
         ,  
         2 
         ) 
        
 
         res2: scala.collection.immutable.Set[Int] = Set( 
         1 
         ,  
         2 
         ) 
        
 
  

参考 API文档

Seq

Sequence都有一个预定义的顺序。

 
    
         scala> Seq( 
         1 
         ,  
         1 
         ,  
         2 
         ) 
        
 
         res3: Seq[Int] = List( 
         1 
         ,  
         1 
         ,  
         2 
         ) 
        
 
  

(注意返回的结果是一个List。Seq是一个trait；List是它的一个实现类。Seq对象是一个工厂对象，正如你所看到的，它会创建一个List。)

参考 API文档

Map

Map是保存键-值对的容器。

 
    
         scala> Map( 
         'a' 
         ->  
         1 
         ,  
         'b' 
         ->  
         2 
         ) 
        
 
         res4: scala.collection.immutable.Map[Char,Int] = Map((a, 
         1 
         ), (b, 
         2 
         )) 
        
 
  

参考 API文档

层级关系

上面的这些都是trait，在可变(mutable)包和不可变(immutable)包里都有对应的实现，同时也有其他特殊用途的实现。

Traversable

所有的集合都可遍历的。这个trait定义了标准函数组合器。这些组合器都是通过foreach这个方法来实现的，并且所有的集合都实现了这个方法。

参考 API文档

Iterable

这个trait有一个iterator()方法，它返回一个可以遍历所有元素的Iterator。参考 API文档

Seq

一组有序的元素。

参考 API文档

Set

一组没有重复元素的集合。

参考 API文档

Map

键-值对。

参考 API文档

方法

Traversable

上面所有的方法在子类中都是可用的。参数和返回值可能会改变，因为子类可以覆盖它们。

 
         def head : A 
        
         def tail : Traversable[A]

这里我们可以定义函数组合器。

def map [B] (f: (A) => B) : CC[B]

上面的代码返回一个集合，里面的每一个元素都通过函数f进行了转换。

def foreachU: Unit

对一个集合里的每一个元素都执行函数f。

def find (p: (A) => Boolean) : Option[A]

它返回第一个符合断言函数的元素。

def filter (p: (A) => Boolean) : Traversable[A]

这个返回一个包含所有符合断言函数的元素的集合。

切分：

def partition (p: (A) ⇒ Boolean) : (Traversable[A], Traversable[A])

通过一个断言函数把一个集合拆成两份

def groupBy [K] (f: (A) => K) : Map[K, Traversable[A]]

转换：

有趣的是，集合之间可以相互进行转换。

 
         def toArray : Array[A] 
        
         def toArray [B >: A] (implicit arg0: ClassManifest[B]) : Array[B] 
        
         def toBuffer [B >: A] : Buffer[B] 
        
         def toIndexedSeq [B >: A] : IndexedSeq[B] 
        
         def toIterable : Iterable[A] 
        
         def toIterator : Iterator[A] 
        
         def toList : List[A] 
        
         def toMap [T, U] (implicit ev: <:<[A, (T, U)]) : Map[T, U] 
        
         def toSeq : Seq[A] 
        
         def toSet [B >: A] : Set[B] 
        
         def toStream : Stream[A] 
        
         def toString () : String 
        
         def toTraversable : Traversable[A]

我们可以把一个Map转换成一个数组，然后得到一个键值对数组。

 
         scala> Map( 
         1 
         ->  
         2 
         ).toArray 
        
         res41: Array[(Int, Int)] = Array(( 
         1 
         , 
         2 
         ))

Iterable

这个接口给你提供了一个迭代器iterator。

 
         def iterator: Iterator[A]

Iterator提供了什么操作呢？

 
         def hasNext(): Boolean 
        
         def next(): A

这个是非常‘Java式’的用法。在Scala中，你很少会见到使用iterator的地方，大部分的时候你看到的都是函数组合器以及for循环语句。

Set

 
         def contains(key: A): Boolean 
        
         def +(elem: A): Set[A] 
        
         def -(elem: A): Set[A]

Map

一序列键值对，提供按key进行查询的操作。可以通过给apply()方法传入一个键值对的列表来创建Map：

 
    
         scala> Map( 
         "a" 
         ->  
         1 
         ,  
         "b" 
         ->  
         2 
         ) 
        
 
         res0: scala.collection.immutable.Map[java.lang.String,Int] = Map((a, 
         1 
         ), (b, 
         2 
         )) 
        
 
  

或者按照下面的方式：

 
    
         scala> Map(( 
         "a" 
         ,  
         2 
         ), ( 
         "b" 
         ,  
         2 
         )) 
        
 
         res0: scala.collection.immutable.Map[java.lang.String,Int] = Map((a, 
         2 
         ), (b, 
         2 
         )) 
        
 
  

题外话

->是什么呢？这是一个特殊的语法，它是一个返回值为元组的方法。

 
         scala>  
         "a" 
         ->  
         2 
        
         res0: (java.lang.String, Int) = (a, 
         2 
         )

记住，它只是下面这种形式的语法糖：

 
         scala>  
         "a" 
         .->( 
         2 
         ) 
        
         res1: (java.lang.String, Int) = (a, 
         2 
         )

你也可以通过++来构造Map

 
    
         scala> Map.empty ++ List(( 
         "a" 
         ,  
         1 
         ), ( 
         "b" 
         ,  
         2 
         ), ( 
         "c" 
         ,  
         3 
         )) 
        
 
         res0: scala.collection.immutable.Map[java.lang.String,Int] = Map((a, 
         1 
         ), (b, 
         2 
         ), (c, 
         3 
         )) 
        
 
  

常用的集合子类

HashSet 和 HashMap 支持快速查找的最常用的集合类。HashSet API, HashMap API

TreeMap SortedMap的子类，它提供有序的访问方式。 TreeMap API

Vector 支持快速查找和更新 Vector API

 
    
         scala> IndexedSeq( 
         1 
         ,  
         2 
         ,  
         3 
         ) 
        
 
         res0: IndexedSeq[Int] = Vector( 
         1 
         ,  
         2 
         ,  
         3 
         ) 
        
 
  

Range 有序的通过空格分隔的Int序列。在之前很多用来计数的for循环经常使用它。Range API

 
         scala>  
         for 
         (i <-  
         1 
         to  
         3 
         ) { println(i) } 
        
         1 
        
         2 
        
         3

Range也支持标准的函数组合器。

 
    
         scala> ( 
         1 
         to  
         3 
         ).map { i => i } 
        
 
         res0: scala.collection.immutable.IndexedSeq[Int] = Vector( 
         1 
         ,  
         2 
         ,  
         3 
         ) 
        
 
  

默认实现

在trait上使用apply方法会得到该trait的一个默认实现，例如，Iterable(1,2)返回一个List作为它的默认实现。

 
         scala> Iterable( 
         1 
         ,  
         2 
         ) 
        
         res0: Iterable[Int] = List( 
         1 
         ,  
         2 
         )

Seq也是这样的，我们之前见过

 
         scala> Seq( 
         1 
         ,  
         2 
         ) 
        
         res3: Seq[Int] = List( 
         1 
         ,  
         2 
         ) 
        
         scala> Iterable( 
         1 
         ,  
         2 
         ) 
        
         res1: Iterable[Int] = List( 
         1 
         ,  
         2 
         ) 
        
         scala> Sequence( 
         1 
         ,  
         2 
         ) 
        
         warning: there were deprecation warnings; re-run with -deprecation  
         for 
         details 
        
         res2: Seq[Int] = List( 
         1 
         ,  
         2 
         )

Set

 
         scala> Set( 
         1 
         ,  
         2 
         ) 
        
         res31: scala.collection.immutable.Set[Int] = Set( 
         1 
         ,  
         2 
         )

一些描述性的trait

IndexedSeq 支持对元素进行快速随机访问以及快速的length操作 API doc

LinearSeq 只对第一个和最后一个元素支持快速访问。 API doc

可变性 vs. 不可变性

不可变性

优点

在多线程场景下不会被改变

缺点

没有办法进行修改

Scala允许我们根据实际需求决定可变性，它鼓励我们只用不可变的对象，但是也不禁止我们使用具有可变性的对象。这个和var与val的场景非常相似。我们一开始都是使用val，当实际需要的时候会改成var。

可变集合

我们前面讨论的所有的类都是不可变的。我们现在来讨论一下常用的可变集合。

HashMap 定义了getOrElseUpdate, += HashMap API

 
    
         scala> val numbers = collection.mutable.Map( 
         1 
         ->  
         2 
         ) 
        
 
         numbers: scala.collection.mutable.Map[Int,Int] = Map(( 
         1 
         , 
         2 
         )) 
        

            
        
 
         scala> numbers.get( 
         1 
         ) 
        
 
         res0: Option[Int] = Some( 
         2 
         ) 
        

            
        
 
         scala> numbers.getOrElseUpdate( 
         2 
         ,  
         3 
         ) 
        
 
         res54: Int =  
         3 
        

            
        
 
         scala> numbers 
        
 
         res55: scala.collection.mutable.Map[Int,Int] = Map(( 
         2 
         , 
         3 
         ), ( 
         1 
         , 
         2 
         )) 
        

            
        
 
         scala> numbers += ( 
         4 
         ->  
         1 
         ) 
        
 
         res56: numbers.type = Map(( 
         2 
         , 
         3 
         ), ( 
         4 
         , 
         1 
         ), ( 
         1 
         , 
         2 
         )) 
        
 
  

ListBuffer和ArrayBuffer 定义了+=操作符 ListBuffer API, ArrayBuffer API

LinkedList和DoubleLinkedList LinkedList API, DoubleLinkedList API

PriorityQueue API doc

Stack和ArrayStack Stack API, ArrayStack API

StringBuilder 有趣的是StringBuilder是竟然一个集合 API doc

和Java进行交互

你可以通过 JavaConverters 包在Java和Scala的集合类之间进行转换. 它给常用的Java集合提供了asScala方法，同时给常用的Scala集合提供了asJava方法。

 
         import 
         scala.collection.JavaConverters._ 
        
         val sl =  
         new 
         scala.collection.mutable.ListBuffer[Int] 
        
         val jl : java.util.List[Int] = sl.asJava 
        
         val sl2 : scala.collection.mutable.Buffer[Int] = jl.asScala 
        
         assert 
         (sl eq sl2)

双向转换：

 
         scala.collection.Iterable <=> java.lang.Iterable 
        
         scala.collection.Iterable <=> java.util.Collection 
        
         scala.collection.Iterator <=> java.util.{ Iterator, Enumeration } 
        
         scala.collection.mutable.Buffer <=> java.util.List 
        
         scala.collection.mutable.Set <=> java.util.Set 
        
         scala.collection.mutable.Map <=> java.util.{ Map, Dictionary } 
        
         scala.collection.mutable.ConcurrentMap <=> java.util.concurrent.ConcurrentMap

另外，下面提供了一些单向的转换方法：

 
         scala.collection.Seq => java.util.List 
        
         scala.collection.mutable.Seq => java.util.List 
        
         scala.collection.Set => java.util.Set 
        
         scala.collection.Map => java.util.Map