1 Stream Stream

stream is a collection. This set can be used to store an infinite number of elements, but this infinite number of elements will not be produced at one time, but will be dynamically produced if the interval needs to be used, and the last element follows the lazy rule (ie: to use results are calculated).

Create a Stream object

def numsForm(n: BigInt) : Stream[BigInt] = n #:: numsForm(n + 1)
val stream1 = numsForm(1)

illustrate

The data type stored in the Stream collection is BigInt

numsForm is a custom function, and the function name is specified by the programmer.

The first element of the created set is n , and the rule for subsequent elements is n + 1

The rules for the generation of subsequent elements can be specified by the programmer, such as numsForm(n * 4)...

Using tail, will dynamically generate new elements to the stream collection according to the rules

//create Stream
def numsForm(n: BigInt) : Stream[BigInt] = n #:: numsForm(n + 1)
val stream1 = numsForm(1)
println(stream1) //
//take the first element
println("head=" + stream1.head) //
println(stream1.tail) //
println(stream1) //?

Use map to map elements of stream and do some calculations

//create Stream
def numsForm(n: BigInt) : Stream[BigInt] = n #:: numsForm(n + 1)
def multi(x:BigInt) : BigInt = {
x * x
}
println(numsForm(5).map(multi)) //? (25,?)

2 View View

basic introduction

With the lazy loading feature of Stream, you can also apply the view method to other collections to get a similar effect, with the following features:

1) The view method produces a collection that is always executed lazily.

2) The view does not cache data and needs to be recalculated every time, such as when traversing the View.

def multiple(num: Int): Int = {
num}
def eq(i: Int): Boolean = {
i.toString.equals(i.toString.reverse)
}
//illustrate: did not use view
val viewSquares1 = (1 to 100)
.map(multiple)
.filter(eq)
println(viewSquares1)
//for (x <- viewSquares1) {}
//use view
val viewSquares2 = (1 to 100)
.view
.map(multiple)
.filter(eq)
println(viewSquares2)

3 Thread-safe collections

All thread-safe collections are collections that start with Synchronized

SynchronizedBuffer
SynchronizedMap
SynchronizedPriorityQueue
SynchronizedQueue
SynchronizedSet
SynchronizedStack

4 Parallel Collections

1) In order to make full use of multi-core CPU s, Scala provides parallel collections (different from the previous serial collections) for parallel computing in multi-core environments.

2) The main algorithms used are: Divide and conquer : Divide and conquer algorithm, Scala is implemented through abstraction layers such as splitters (decomposers), combiners (combiners), etc. The main principle is to decompose the computing work into many tasks and distribute them to some processing. processor to complete, and combine their processing results back

Applications

1) Print 1~5

 

2) View threads accessing elements in parallel collections

val result1 = (0 to 100).map{case _ => Thread.currentThread.getName}
val result2 = (0 to 100).par.map{case _ => Thread.currentThread.getName}
println(result1)
println(result2)

5 Operators