Scala集合（二）

最新推荐文章于 2021-02-02 17:29:41 发布

码界一棵葱

最新推荐文章于 2021-02-02 17:29:41 发布

阅读量377

点赞数

分类专栏： Scala Scala学习之旅

本文链接：https://blog.csdn.net/lyyybz/article/details/52297416

版权

Scala 同时被 2 个专栏收录

13 篇文章 1 订阅

订阅专栏

Scala学习之旅

10 篇文章 2 订阅

订阅专栏

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