Collection advance

Collections in Scala:
Advanced
Collections in Scala:
Advanced
Pranjut Gogoi & Bhavya Aggarwal
Knoldus Software LLP

Agenda
● Collection Hierarchy
● Traversable
● Iterable
● Seq
● Set
● Map
● Vector
● Stream
● ArrayBuffer
● Parallel Collections

Traversable
● An iterator is traversing object which allows one to walk
through the collection.
● Trait Traversable conceptualize the concept of an internal
iterator
● Traversable only method is foreach
● A client code can be passed to the foreach method which will
be executed on each element of the collection it is being
applied
● foreach is side effective

Iterable
● Iterable is an external iterator.
● An external iterator is used to traverse a collection with
custom logic.
● The trait Iterable provides a methods iterator which is used
to get the iterator.
● Iterator can be used as an object to traverse through the
collection.
● Iterable provides methods used to traverse and access the
element from the collection without worrying about the
implementation of the collection.

Seq
● Represents collections that has a sequential ordering.
● Defined in terms of the length and apply method
● apply can be used to index into the collection while length is
used to calculate size of the collection
● Entertain as many duplicate elements as possible but in an
particular sequence

Linear Seq
● Sequence that can be partitioned in a head and a tail
component.
● The LinearSeq trait provides methods such as isEmpty,
head and tail.
● The examples of Linear Sequences are Lists, Stacks etc
● Linear Sequence are best suited for recursive algorithms
● All of the operations defined in the trait has constant time
complexity of element access O(1)

Indexed Seq
● Provides great ease in random access of elements in
Sequences
● It achieves constant or near constant time complexity while
accessing random elements from the sequence.
● The examples of an Indexed Seq is a Vector which behaves
like an array, providing near constant operations on a
immutable Object
val mySeq = IndexedSeq("A","B","C")
mySeq: IndexedSeq[String] = Vector(A, B, C)

Set
● Trait that represents an unordered collection of unique
elements
● Provides methods like contains, subsetOf and apply
methods
● Best suited for requirements like checking the existence of
an element in a collection, Lookup Tables etc
● Scala provides three types of mutable and immutable Sets
implementations, TreeSet, HashSet and BitSet.

TreeSet
● Implemented as a red black tree of elements.
● A Red black tree is a self balancing binary search tree.
● Best suited for requirements like checking the existence of
an element in a collection, Lookup Tables etc
● It guarantees search operations in O(log n) time.
● A TreeSet construction required an implicit Ordering for
comparison of elements during storage.

HashSet
● Implemented as tree of elements but uses Hashing to place
elements in the tree.
● A hash value is calculated for each value and the values with
same hash values are kept at the same tree node.
● HashSet has constant time operations like insertion and
element retrieval from the tree.
● HashSet whose hash function has less chance of collision
can outperform TreeSet in lookup and search operations.

BitSet
● Implemented as sequence of Long Values.
● Can store only non-negative integer values
● Often used to store sequences of bits and memory flags
● The maximum memory consumed by the BitSet is
dependent upon the largest number stored in it.
● The base trait BitSet is implemented in both version in scala,
i.e. scala.collection.immutable.BitSet and
scala.collection.mutable.BitSet.

BitSet: Example
val bits = scala.collection.immutable.BitSet.empty //Initializing the empty BitSet
bits: scala.collection.immutable.BitSet = BitSet()
val addedBits = bits + 3 + 4 + 7 //Adding elements to the bit set
addedBits: scala.collection.immutable.BitSet = BitSet(3, 4, 7)
val finalBits = addedBits + 7 + 9 //Adding more elements
finalBits: scala.collection.immutable.BitSet = BitSet(3, 4, 7, 9)

Map
● The Map trait denotes collection of key value pairs
● Only one value for a given key exists
●
Scala provides two map implementation, i.e. HashMap and
TreeMap.
●
A HashMap is preferred when the hashing algorithm is
enhanced and have less chances of collision.
●
TreeMap and HashMap shares same performance trade-offs
that is in TreeSet and HashSet

Map: Example
val author = Map("Scala"->"Martin Ordersky","Java"->"E Bala","C"->"Dennis Ritchie")
author: scala.collection.immutable.Map[String,String]
val prices = Map("C"->100,"Java"->200,"Scala"->1000)
prices: scala.collection.immutable.Map[String,Int]
val priceOfCBook = prices.get("C")
priceOfCBook: Option[Int] = Some(100)
val priceOfDBook = prices.get("D")
priceOfDBook: Option[Int] = None

Vector
● Vector is an IndexedSeq
● It is very efficient in random accessing the elements
●
It has random access complexity of log32 (N)
●
Vectors are implemented as a trie on the index position of
the element.
●
A trie is a tree where each child down the path share some
common characteristics

Trie: Example
A trie with branching factor of two, where each element is stored
as its binary position in the tree.
A trie with branching factor of two, where each element is stored
as its binary position in the tree.

Vector:Example
● Vector is a good balance of properties like fast random
access and fast random updates
●
It is safe to share across thread since it is immutable:
val vector = Vector(1, 2, 3)
vector: scala.collection.immutable.Vector[Int] = Vector(1, 2, 3)
val updatedVector = vector updated (2, 4)
updatedVector: scala.collection.immutable.Vector[Int] = Vector(1, 2, 4)
vector
res0: scala.collection.immutable.Vector[Int] = Vector(1, 2, 3)

Stream
● Stream is a lazy persistent collection
●
It can store infinite sequences without overflowing the
memory constraints.
●
Streams are just like Lists and composed of cons nodes and
empty stream but
●
Stream is not evaluated until the elements are needed
●
It stores function objects instead of actual elements to
compute the head element and the rest of the stream

Stream:Example
val stream = Stream from 1
stream: scala.collection.immutable.Stream[Int] = Stream(1, ?)
stream.foreach(x => println(x))
1
2
3
..
35
Output exceeds cutoff limit.
val stream = Stream from 1
stream: scala.collection.immutable.Stream[Int] = Stream(1, ?)
stream.foreach(x => println(x))
1
2
3
..
35
Output exceeds cutoff limit.

ArrayBuffer
●
ArrayBuffer collection is a mutable Array defined in the
package scala.collection.mutable
●
Append, update and random access take constant time.
●
ArrayBuffer is created with some initial size given in the
constructor or with some default size defined.
●
When an element is added, the current size is checked,
●
if not sufficient a whole new array is allocated with a different
size and all previous element are moved into new array
along with new elements

ArrayBuffer
val arrayBuf:ArrayBuffer[Int] = new ArrayBuffer() //create empty array buffer
arrayBuf: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()
arrayBuf.append(4) //append element 4 to it
arrayBuf.append(7,8) //append element 7 and 8 to it
arrayBuf // print the arrayBuf now , It will be updated in place
res3: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(4, 7, 8)
arrayBuf.size //Get the size of mutable array
res4: Int = 3 //It has grown to 4

Parallel Collections
●
Parallel collections in Scala aims to reduce the lower level
parallelism and programmer's level
●
It provides a high level abstraction of parallelism over normal
collections so they can be operated in parallel.
●
There are several wrapper methods available for normal
collection to get the parallel version.
●
One has to simply invoke the .par method on sequential
collections to operate it in parallel.

References
● Scala In depth: by Joshua D. Suereth
● http://docs.scala-lang.org/overviews/collections/overview.html

Collection advance

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Ähnlich wie Collection advance

Ähnlich wie Collection advance (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Collection advance