集合、数组、列表List、Set集合、Map集合、元组、集合常用函数、队列、并行集合

目录

 数组

列表List 

Set集合

 Map集合

元组 

衍生集合 

 集合计算简单、高级函数

reduce归约 

合并映射

WordCount普通、复杂计算 

队列 

并行集合 

---

 数组

package chapter07
//不可变数组
object Test01_ImmutableArray {
  def main(args: Array[String]): Unit = {
    //1.创建数组 [数组里面每个元素的类型] [Int]给个泛型
    val arr:Array[Int]=new Array[Int](5) //大小为5 长度为5的整数Int类型的数组
    //另一种创建方式
    val arr2=Array(12,37,42,58,97)

    //2.访问数组中的元素  不可变数组
    println(arr.mkString(","))
    arr(0)=12
    arr(4)=57
    println(arr(0))
    println(arr(1))
    println(arr(4))
    println(arr2(1))
//    println(arr(5))
    println(arr2.mkString(","))

    println("----------------------------------------------")

    //3.数组的遍历
    //1)普通for循环
    for(i <- 0  to  arr.length-1 ){   //for循环 循环的是下标
      println(arr(i))
    }
    println("---------------------------------------")

    for(i <- 0  until  arr.length ){   //for循环 循环的是下标
      println(arr(i))
    }
    println("-----------------------------------------")
    for(i <- arr.indices )
      println(arr(i))

    println("-------------------------------------------")

    //2)直接遍历所有元素，增强for循环
    for(elem <-arr2) println(elem)

    println("---------------------------------------")

    //3)用迭代器去做当前集合所有元素的遍历
    val iter=arr2.iterator
    while(iter.hasNext)
      println(iter.next())

    println("--------------------------")

    //4)调用foreach方法
    arr2.foreach((elem:Int) =>println(elem))
    println("----------------------------------------")
    arr.foreach(println)
    println(arr2.mkString("-"))

    println("------------------------------------")

    //4.添加元素
    val newArr=arr2.:+(73)
    println(arr2.mkString("-"))
    println(newArr.mkString("-"))

    val newArr2=newArr.+:(30)
    println(newArr2.mkString("-"))

    val newArr3=newArr2 :+ 15
//    val newArr4 =newArr3 +: 29  // error 若是省略点号 改成空格 就变成了右边是对象 左边是参数
    val newArr4=19 +: 29 +: newArr3 :+ 26 :+73
    println(newArr4.mkString("-"))


  }

}

package chapter07

import scala.collection.mutable
import scala.collection.mutable.ArrayBuffer

//可变数组
object Test02_ArrayBuffer {
  def main(args: Array[String]): Unit = {

    //1.创建可变数组
    val arr1:ArrayBuffer[Int] = new ArrayBuffer[Int]()  //可变这里需要导包 Array底层有对应的隐式转换 不需要
    val arr2=ArrayBuffer(23,57,92)

    println(arr1.mkString(","))
    println(arr2) //这里直接可以打印值 而不是Array里面的地址
    println(arr2.mkString("-"))


    //2.访问元素
//    println(arr1(0))  //error 数组越界 arr1里面什么都没有
    println(arr2(1))
    arr2(1)=39
    println(arr2(1))
    println("-----------------------------------------")


    //3.添加元素
    val newArr1=arr1 :+ 15  //15
    println(newArr1)

    println(arr1==newArr1)


    val newArr2=arr1+=20  //20
    arr1 += 19

    println(arr1)

    println(arr1==newArr2) //指向同一个引用

    77 +=: arr1
    println(arr1)
    println(newArr2)

    arr1.append(36)
    arr1.prepend(11,76)
    arr1.insert(1,13,59)
    println(arr1)

    arr1.insertAll(2,newArr1)  //添加数组
    arr1.prependAll(newArr2)

    println(arr1)

    //4.删除元素
    arr1.remove(3)
    println(arr1)

    arr1.remove(0,10)
    println(arr1)

    arr1 -= 19
    println(arr1)
    println("---------------------------------------------------------")

    //5.可变数组转换为不可变数组
    val arr:ArrayBuffer[Int]=ArrayBuffer(23,56,98)
    val newArr:Array[Int]=arr.toArray
    println(newArr.mkString(","))
    println(arr)

    //6.不可变数组转换为可变数组
    val buffer: mutable.Buffer[Int] = newArr.toBuffer
    println(buffer)
    println(newArr) //Array Int 是地址


  }

}

package chapter07
//多维数组
object Test03_MulArray {
  def main(args: Array[String]): Unit = {

    //1.创建二维数组
    val array: Array[Array[Int]] = Array.ofDim[Int](2, 3) //数组的数组

    //2.访问元素
    array(0)(2) = 19
    array(1)(0) = 25

    println(array.mkString(","))

    for (i <- 0 until array.length; j <- 0 until array(i).length) {
      println(array(i)(j))
    }
    println("------------------------------------------")

    for (i <- array.indices; j <- array(i).indices) {
      print(array(i)(j) + "\t")
      if (j == array(i).length - 1) println() //换一行

    }
    println("------------------------------------------")

    array.foreach(line => line.foreach(println)) //第一重处理每一行的数据 然后再对每一个数据进行处理
    println("-------------------------------------------------")

    array.foreach(_.foreach(println))  //是几维数组就有几个foreach


  }
}

列表List 

package chapter07


object Test04_List {
  def main(args: Array[String]): Unit = {
    //1.创建一个List 不可变的
    val list1 =List(23,65,87)  //list是抽象方法 不能用类的构造方法去创建 可以用伴生对象的apply去创建
    println(list1)


    //2.访问和遍历元素
    println(list1(1))

//    list1(1)=12 //error 不能更改它的值

    list1.foreach(println)

    //3.添加元素
    val list2=10 +: list1
    val list3=list1 :+ 23
    println(list2)
    println(list3)

    println("-------------------------------------")

    val list4=list2.::(51)  //加在开头
    println(list4)

    //Nil 空列表
    val list5=Nil.::(13) //很少用空列表去添加元素 相当于创建一个新列表
    println(list5)

    val list6=73::32 :: Nil
    val list7 = 17 :: 28 :: 59 :: 16  :: Nil //定义空列表 方便定义一个列表
    println(list6)
    println(list7)


    //4.合并列表
    val list8 =list6::list7
    println(list8)

    val list9=list6:::list7  //::: 拆分之后合成一个完成的list 扁平化
    println(list9)

    val list10=list6++list7
    println(list10)

  }

}

package chapter07

import scala.collection.mutable.ListBuffer

object Test05_ListBuffer {
  def main(args: Array[String]): Unit = {

    //1.创建可变列表
    val list1:ListBuffer[Int] =new ListBuffer[Int]()
    val list2=ListBuffer(12,53,75)  //伴生对象 来创建列表

    println(list1)
    println(list2)

    println("----------------------")

    //2.添加元素
    list1.append(15,62)
    list2.prepend(20)

    list1.insert(1,19,22)
    println(list1)
    println(list2)

    println("--------------------------")

    list1+=25+=11
    31 +=:96 +=: list1 +=25 +=11
    println(list1)
    println("--------------------------")

    //3.合并列表
    val list3=list1 ++ list2
    println(list1)
    println(list2)

    println("-------------------------------")

    list1 ++=list2  //在list1后加  list++=:list2 在list2后加
    println(list1)
    println(list2)

    println("-------------------------")

    //4.修改元素
    list2(3)=30
    list2.update(0,89)
    println(list2)

    //5.删除元素
    list2.remove(2)
    println(list2)
    list2-=30
    println(list2)



  }

}

Set集合

package chapter07
//不可变set 原始内容是不做改变的
object Test06_ImmutableSet {
  def main(args: Array[String]): Unit = {

    //1.创建set
    val set1=Set(13,23,53,12,13,23,78)
    println(set1)
    println("------------------------------")

    //2.添加元素
    val set2=set1 + 129
//    val set2=set1.+(20)  //无序 没必要关注朝哪个方向添加
    println(set1)
    println(set2)
    println("----------------------------------------")

    //3.合并set
    val set3=Set(19,13,23,53,67,99)
    val set4=set2 ++ set3
    println(set2)
    println(set3)
    println(set4)
    println("---------------------------------------")

    //4.删除元素
    val set5=set3 -13
    println(set3)
    println(set5)


  }

}

package chapter07

import scala.collection.mutable

//可变set 基于原始set来做更改
object Test07_MutableSet {
  def main(args: Array[String]): Unit = {

    //1.创建set  无序去重
    val set1:mutable.Set[Int]=mutable.Set(13,23,53,12,13,23,78)
    println(set1)
    println("------------------------------")

    //2.添加元素
    val set2 =set1 + 11
    println(set1)
    println(set2)

    println("--------------------------------------")

    set1 += 11
    println(set1)


    println("-----------------------------------")
    val flag1=set1.add(10)
    println(flag1)
    println(set1)
    val flag2=set1.add(10)  //已经有了 没有做任何操作 false
    println(flag2)
    println(set1)

    println("----------------------------")

    //3.删除元素

    set1 -= 11
    println(set1)
    println("-----------------------------------")

    val flag3=set1.remove(10)
    println(flag3)
    println(set1)
    val flag4=set1.remove(10)  //已经删除了 没有做任何操作 false
    println(flag4)
    println(set1)
    println("---------------------------------")

    //4.合并两个Set
    val set3=mutable.Set(13,12,13,27,98,29)
    println(set1)
    println(set3)

    println("-------------------------------")

    val set4 =set1 ++ set3
    println(set4)

    println("-------------------------------")

//    set1 ++=set3 //谁调用谁改变
    println(set1)
    println(set3)

    println("--------------------------")
    set3 ++=set1
    println(set1)
    println(set3)


  }

}

 Map集合

package chapter07
//不可变map
object Test08_ImmutableMap {
  def main(args: Array[String]): Unit = {

    //1.创建不可变map
    val map1:Map[String,Int]=Map("a"->13,"b"->25,"hello"->3)
    println(map1)
    println(map1.getClass) //当前类的表达 class scala.collection.immutable.Map$Map3 Map3三个元素
    println("--------------------------")
    //2.遍历元素
    map1.foreach(println)
    map1.foreach((kv:(String,Int)) => println(kv)) //元组

    println("---------------------------------")

    //3.取map中所有的key或者value
    for(key <- map1.keys){
      println(s"$key---> ${map1.get(key)}")

    }
    println("----------------------------")

    //4.访问某一个key的value
    println("a  "+map1.get("a").get)  //不安全 改成getOrElse
    println("c  "+map1.get("c"))  //包装成option 不会返回空指针异常 Java8中借鉴option类型
    println("c  "+map1.getOrElse("c",0)) //或者"c"的值 如果没有"c"的值 就返回一个默认的值
    println("---------------------------")

    println(map1("a"))

  }

}

package chapter07

import scala.collection.mutable

object Test09_MutableMap {
  def main(args: Array[String]): Unit = {

    //1.创建可变map
    val map1:mutable.Map[String,Int]=mutable.Map("a"->13,"b"->25,"hello"->3)
    println(map1)
    println(map1.getClass) //当前类的表达 class scala.collection.mutable.HashMap
    println("--------------------------")

    //2.添加元素  hashmap无序 顺序是不需要考虑的
    map1.put("c",5)
    map1.put("d",9)
    println(map1)

    map1+=(("e",7))
    println(map1)
    println("-----------------------")

    //3.删除元素
    println(map1("c"))
    map1.remove("c")
    println(map1)
    println(map1.getOrElse("c",0))
    println("-----------------------------")
    map1-="d"
    println(map1)
    println("-----------------------")

    //4.修改元素
    map1.update("c",5)
    map1.update("e",10)
    println(map1)
    println("--------------------------------")

    //5.合并两个Map
    val map2:Map[String,Int]=Map("aaa"->13,"b"->29,"hello"->3)
//    map1 ++=map2
    println(map1)
    println(map2)
    println("------------------------------------------")

    val map3: Map[String, Int] = map2 ++ map1 //相同的覆盖成map1的值
    //    map2 ++=map1 map2不可变
    println(map1)
    println(map2)
    println(map3)




  }

}

元组 

package chapter07
//元组
//元组也是可以理解为一个容器，可以存放各种相同或不同类型的数据。
// 说的简单点，就是将多个无关的数据封装为一个整体，称为元组。
//注意：元组中最大只能有 22 个元素。
object Test10_Tuple {
  def main(args: Array[String]): Unit = {

    //1.创建元组
    val tuple:(String,Int,Char,Boolean)=("hello",100,'a',true)
    println(tuple)

    //2.访问数据
    println(tuple._1)
    println(tuple._2)
    println(tuple._3)
    println(tuple._4)

    println(tuple.productElement(1))
    println("-------------------------------------")

    //3.遍历元组数据
    for (elem <- tuple.productIterator)
      println(elem)

    //4.嵌套元组
    val mulTuple=(12,0.3,"hello",(23,"scala"),29)
    println(mulTuple._4._2)


  }

}

package chapter07
//基本属性和常用操作
object Test11_CommonOp {
  def main(args: Array[String]): Unit = {
    val list=List(1,3,5,7,2,89)
    val set=Set(23,34,423,75)

//    （1）	获取集合长度
    println(list.length)
//    （2）	获取集合大小
    println(set.size)  //set不是线性序列 没有length
    println("--------------------------------")
//    （3）	循环遍历
    for(elem <- list)
      println(elem)
    set.foreach(println)
    println("---------------------------")
//    （4）	迭代器
    for(elem <- list.iterator)
      println(elem)
    println("-----------------------------")
//    （5）	生成字符串
    println(list)
    println(set)
    println(list.mkString("--"))
    println("-------------------------------")
//    （6）	是否包含
    println(list.contains(23))
    println(set.contains(23))

  }

}

衍生集合 

package chapter07
//衍生集合
object Test12_DeriverCollection {
  def main(args: Array[String]): Unit = {
    val list1=List(1,3,5,7,2,89)
    val list2=List(3,7,2,45,4,8,19)
//    （1）获取集合的头
    println(list1.head)  //有序集合才去考虑头和尾
//    （2）获取集合的尾（不是头的就是尾）
    println(list1.tail)  //去掉头 剩下的元素
//    （3）	集合最后一个数据
    println(list2.last)
//    （4）	集合初始数据（不包含最后一个）
    println(list2.init) //去掉尾 剩下的元素
//    （5）	反转
    println(list1.reverse)
//    （6）	取前（后）n 个元素
    println(list1.take(3))
    println(list1.takeRight(4))
//    （7）	去掉前（后）n 个元素
    println(list1.drop(3))
    println(list1.dropRight(4))
    println("-------------------------------------")
//    （8）	并集
    val union=list1.union(list2)
    println("union: "+union)
    println(list1:::list2)
    //如果是set做并集，会去重
    println("---------------------------------")
    val set1=Set(1,3,5,7,2,89)
    val set2=Set(3,7,2,45,4,8,19)
    val union2=set1.union(set2)
    println("union2: "+union2)
    println(set1 ++ set2)
    println("---------------------------------")
//    （9）	交集
    val intersection =list1.intersect(list2)
    println(intersection)
    println("-----------------------------")
//    （10）	差集
    val diff1=list1.diff(list2)
    val diff2=list2.diff(list1)
    println(diff1)
    println(diff2)
    println("-----------------------------------")
//    （11）	拉链
    println("zip: "+ list1.zip(list2))
    println("zip: "+ list2.zip(list1))
    println("---------------------------------------")
//    （12）	滑窗 //val list1=List(1,3,5,7,2,89)
   for (elem <- list1.sliding(3))  //三个数一个窗口
     println(elem)

    /**
      * List(1, 3, 5)
      * List(3, 5, 7)
      * List(5, 7, 2)
      * List(7, 2, 89)
      */
    println("------------------------")

    //val list2=List(3,7,2,45,4,8,19)
    for(elem <- list2.sliding(4,2))  // 四个数一个窗口 下个窗口隔两个元素 作为开始
    println(elem)

    /**
      * List(3, 7, 2, 45)
      * List(2, 45, 4, 8)
      * List(4, 8, 19)
      */

    println("------------------------------")

    for(elem <- list2.sliding(3,3)) // 翻跟头 没有重复计算 滚动窗口
      println(elem)





  }

}

 集合计算简单、高级函数

package chapter07
//集合计算简单函数
object Test13_SimpleFunction {
  def main(args: Array[String]): Unit = {
    val list=List(5,1,8,2,-3,4)
    val list2=List(("a",5),("b",1),("c",8),("d",2),("e",-3),("f",4))

//    （1）	求和
    var sum=0
    for(elem <- list)
      sum+=elem
    println(sum)
    println(list.sum)
//    （2）	求乘积
    println(list.product)
//    （3）	最大值
    println(list.max)
    println(list2.maxBy((tuple:(String,Int))=>tuple._2))
    println(list2.maxBy(_._2)) //按照某种方式排列

//    （4）	最小值
    println(list.min)
    println(list2.minBy(_._2))
//    （5）	排序
    //5.1 sorted
    val sortedList=list.sorted
    println(sortedList)
    //从大到小逆序排序
    println(list.sorted.reverse)  //两个步骤 效率不高
    //传入隐式参数
    println(list.sorted(Ordering[Int].reverse))
    println(list2.sorted) //按照字母序列排序 List((a,5), (b,1), (c,8), (d,2), (e,-3), (f,4))

    //5.2 sortBy
    println(list2.sortBy(_._2)) //从小到大 List((e,-3), (b,1), (d,2), (f,4), (a,5), (c,8))
    println(list2.sortBy(_._2)(Ordering[Int].reverse))  //从大到小 List((c,8), (a,5), (f,4), (d,2), (b,1), (e,-3))
    println("--------------------------------")
    //5.3 sortWith 将规则传入
    println(list.sortWith((a:Int,b:Int)=>{a_))







  }

}

package chapter07
//集合计算高级函数 map
object Test14_HighLevelFunction_Map {
  def main(args: Array[String]): Unit = {
    val list =List(1,2,3,4,5,6,7,8,9)

    //1.过滤
    //选取偶数
    val evenList =list.filter((elem:Int)=>{elem%2==0})
    println(evenList)
    //选取奇数
    println(list.filter(_%2==1))

    println("--------------------------")

    //2.map
    //把集合中每个数乘2
    println(list.map(_*2))
    println(list.map(x=>x*x))
    println("-------------------------------")

    //3.扁平化
    val nestedList:List[List[Int]]=List(List(1,2,3),List(4,5),List(6,7,8,9))

    val flatList=nestedList(0):::nestedList(1):::nestedList(2)
    println(flatList)

    val flatList2=nestedList.flatten
    println(flatList2)
    println("------------------------------------")

    //4.扁平映射
    //将一组字符串进行分词，并保存成单词的列表
    val strings:List[String]=List("hello world","hello java","hello scala","we study")
    val splitList:List[Array[String]]=strings.map(string=>string.split(" ")) //分词
    val flattenList=splitList.flatten //打散 扁平化
    println(flattenList)

    val flatmapList=strings.flatMap(_.split(" "))
    println(flatmapList)
    println("---------------------------------")

    val intToInts: Map[Int, List[Int]] = list.groupBy(_ % 2)
    //5.分组groupBy
    //分成奇偶两组
    val groupMap=intToInts
    val groupMap2=list.groupBy(data=>if (data%2==0) "偶数"else "奇数")
    println(groupMap)
    println(groupMap2)
    println("----------------------------------")

    //给定一组词汇，按照单词的首字母进行分组
    val wordList=List("china","america","alice","canda","ace","japa","bob")
    println(wordList.groupBy(_.charAt(0)))






  }

}

reduce归约 

package chapter07
//reduce 归约
object Test15_HighLevelFunction_Reduce {
  def main(args: Array[String]): Unit = {

    val list=List(1,2,3,4)

    //1.reduce
    println(list.reduce(_ + _)) //10
    println(list.reduceLeft(_+_))
    println(list.reduceRight(_+_))

    println("-----------------------------------")

    val list2=List(3,4,5,8,10)
    println(list2.reduce((_-_))) //-24
    println(list2.reduceLeft(_-_))
    println(list2.reduceRight(_-_)) //6  3-(4-(5-(8-10)))
    println("-----------------------------------")

    //2.fold
    println(list.fold(10)(_+_)) //10+1+2+3+4 20
    println(list.foldLeft(10)(_-_)) //10-1-2-3-4 0
    println(list2.foldRight(11)(_-_))  // 3-(4-(5-(8-(10-11))))



  }

}

合并映射

package chapter07

import scala.collection.mutable

object Test16_MergeMap {
  def main(args: Array[String]): Unit = {

    val map1=Map("a"->1,"b"->3,"c"->6)
    val map2=mutable.Map("a"->6,"b"->2,"c"->9,"d"->3)

//    println(map1++map2) //这里出现的就只是map2的结果

    //作为基本的map作为状态的初始值 然后遍历另外一个map的key value对 然后去更新状态

    val map3=map1.foldLeft(map2)( //合并两个map里面的数值
      (mergedMap,kv)=>{
        val key=kv._1
        val value=kv._2
        mergedMap(key)=mergedMap.getOrElse(key,0)+value
        mergedMap
      }
    )
    println(map3)



  }

}

WordCount普通、复杂计算 

package chapter07
//普通版WordCount
//单词计数：将集合中出现的相同的单词，进行计数，取计数排名前三的结果
object Test17_CommonWordCount {
  def main(args: Array[String]): Unit = {

    val stringList:List[String]=List(
      "hello",
      "hello world",
      "hello scala",
      "hello spark from scala",
      "hello flink from scala"
    )

    //1.对字符串进行切分，得到一个打散所有单词的列表
    val wordList1=stringList.map(_.split(" "))
    val wordList2=wordList1.flatten
    println(wordList1)
    println(wordList2)
    println("-------------------------------------")
    val wordList=stringList.flatMap(_.split(" "))
    println(wordList)

    //2.相同的单词进行分组
    val groupMap=wordList.groupBy(word=>word)
    println(groupMap)
    println("------------------------------------")


    //3.对分组之后的list取长度，得到每个单词的个数
    val stringToInt: Map[String, Int] = groupMap.map(kv => (kv._1, kv._2.length))
    val countMap=stringToInt
    println(countMap)
    println("---------------------------------------")

    //4.将map转换为List，并排序取前3
    val sortList:List[(String,Int)]=countMap.toList
      .sortWith(_._2>_._2) //按照Int降序排列
      .take(3)
    println(sortList)






  }


}

package chapter07

object Test18_ComplexWordCount {
  def main(args: Array[String]): Unit = {

    val tupleList:List[(String,Int)]=List(
      ("hello",1),
      ("hello world",2),
      ("hello scala",3),
      ("hello spark from scala",1),
      ("hello flink from scala",2)
    )

    //思路一：直接展开成普通版本
    val newStringList:List[String]=tupleList.map(
      x=>{
        (x._1.trim + " ")*x._2
      }

    )
    println(newStringList)
    println("-----------------------------------------")

    //接下来操作与普通版本完全一致
    val wordCountList:List[(String,Int)]=newStringList
      .flatMap(_.split(" ")) //空格分词
      .groupBy(word =>word) //按照单词分组
      .map(kv =>(kv._1,kv._2.size)) //统计出每个单词的个数
      .toList
      .sortBy(_._2)(Ordering[Int].reverse)
      .take(3)
    println(wordCountList)
    println("----------------------------------")

    //思路二：直接基于预统计的结果进行转换
    //1.将字符串打散成单词，并结合对应的个数包装成二元组
    val preCountList:List[(String,Int)]=tupleList.flatMap(
      tuple=>{
        val strings:Array[String]=tuple._1.split(" ")
        strings.map(word=>(word,tuple._2))
      }
    )
    println(preCountList) //二元组
    println("------------------------------------")

    //2.对二元组进行按照单词进行分组
    val preCountMap=preCountList.groupBy(_._1)
    println(preCountMap)
    println("------------------------")

    //3.叠加每个单词预统计的个数值
    val countMap=preCountMap.mapValues(
      tupleList=>tupleList.map(_._2).sum

    )
    println(countMap)
    println("---------------------------------")

    //4.转换成list，排序取前3
    val countList=countMap.toList
      .sortWith(_._2>_._2)
    println(countList)










  }

}

队列 

package chapter07

import scala.collection.immutable.Queue
import scala.collection.mutable
//队列
object Test19_Queue {
  def main(args: Array[String]): Unit = {

    val strings: mutable.Queue[String] = new mutable.Queue[String]()
    //创建一个可变队列
    val queue=strings

    queue.enqueue("a","b","c")
    println(queue)

    queue.dequeue()
    println(queue)

    queue.dequeue()
    println(queue)
    println("---------------------------")


    //不可变队列
    val queue2=Queue("a","b","c")
    queue2.enqueue("d")
    val queue3=queue2.enqueue("d")
    println(queue3)



  }

}

并行集合 

package chapter07

import scala.collection.immutable
import scala.collection.parallel.ParSeq

//并行集合 并行执行
object Test20_Parallel {
  def main(args: Array[String]): Unit = {

    val result: immutable.IndexedSeq[Long] = (1 to 100).map(
      x => Thread.currentThread.getId
    )
    println(result)

    val result2: ParSeq[Long] = (1 to 100).par.map(
      x => Thread.currentThread.getId
    )
    println(result2)
  }

}