Scala10_集合02_Seq&Set&Map&Tuple&并行

1.Seq集合

Seq是个特质，不能直接创建对象；可以使用其下面的类；因此学习Seq，就是学习Seq下面的类

1.1 不可变集合 List

Scala默认提供不可变集合，不可变集合对数据的操作会产生新的集合；
并且不可变集合一般都没有英文单词的方法；

object Scala04_Collection_Seq {
  def main(args: Array[String]): Unit = {
   //TODO 集合 Seq
    //Scala默认提供的集合是不可变的
    // List 是抽象类，但是有伴生对象
    val list = List(1, 2, 3, 4) 
    val list1 = list :+ 5
    val list2 = 5 +: list
    println(list1)//List(1, 2, 3, 4, 5)
    println(list2)//List(5, 1, 2, 3, 4)


    //todo 2.空集合
    //Scala中采用特殊对象Nil 代表空集合
    println(List()) //List()
    //3::Nil 等价于List(3)
    Nil
    val list3 = 1::2::3::Nil
    println(list3) //List(1, 2, 3)
    println(Nil) //List()

    //::: 将集合拆成元素来添加
    //:: 将对象当作整体来添加
    val list4 = 4::5::list3:::Nil
    val list5 = 4::5::list3::Nil
    println(list4) //List(4, 5, 1, 2, 3)
    println(list5) //List(4, 5, List(1, 2, 3))
  }
}

代码中知识点小结：

1. 运算符 +: 和 :+两个运算符的用法
   用于给List添加元素，+在:哪边，元素就往哪边添加

2. 空集合List()和Nil对象是一样的
   二者打印都是List()

3. ::和::: 用于给集合添加元素

1.2 可变集合 ListBuffer

object Scala04_Collection_Seq1 {
  def main(args: Array[String]): Unit = {
   val list : ListBuffer[Int] = ListBuffer(1, 2, 3, 4)
   list.append(1,2,3,4)
   list.update(1,10)
   list.remove(2)

   val str: String = list.mkString(",")
  }
}

1.3 可变集合和不可变集合转换

import scala.collection.mutable
import scala.collection.mutable.ListBuffer
object ScalaCollection{
    def main(args: Array[String]): Unit = {

        val buffer = ListBuffer(1,2,3,4)
        val list = List(5,6,7,8)
 
        // 可变集合转变为不可变集合
        val list1: List[Int] = buffer.toList
        // 不可变集合转变为可变集合
        val buffer1: mutable.Buffer[Int] = list.toBuffer
    }
}

2. Set集合

无序，不重复集合

object Scala04_Collection_Set {
  def main(args: Array[String]): Unit = {
      val set = Set(1,2,3,4,5,3,2,1)
       println(set) //Set(5, 1, 2, 3, 4)

      val newSet = set + 7

      val newSet1 = newSet - 5


    //todo 可变set集合 可以直接用包名来指定
    val sets : mutable.Set[Int] = mutable.Set(1, 2, 3, 4, 5, 3, 2, 1)

    sets.add(7)  //增加元素会打乱顺序
    sets.update(8,true)//true表示认为集合中包含元素8，如果没有就给你添加   false认为不包含，有就给你删除
    sets.remove(5)

    sets + 7  // + 会返回新的集合
    sets += 7 // += 不会返回新的集合，只做添加

  }

交并差

import scala.collection.mutable
object ScalaCollection{
    def main(args: Array[String]): Unit = {

        val set1 = mutable.Set(1,2,3,4)
        val set2 = mutable.Set(4,5,6,7)

        // 交集
        val set3: mutable.Set[Int] = set1 & set2
        println(set3.mkString(","))
        // 差集
        val set4: mutable.Set[Int] = set1 &~ set2
        println(set4.mkString(","))
    }
}

3. Map集合

特点：存储key无序不重复的 k-v对象
键值对就是两个元素的tuple

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

    //todo 1.map中的kv对
    // kv有两种写法：
    //  1. (k,v)
    //  2. k->v
    val map = Map(("a", 1), "Hadoop"-> 2, ("Spark", 4))
    println(map)  //Map(a -> 1, Hadoop -> 2, Spark -> 4)

    //todo 2.map中元素 key重复的话，后者覆盖前者
    val map2 = Map(("a", 1), ("Hadoop", 2), ("Spark", 4),("a",5))
    println(map2)  //Map(a -> 5, Hadoop -> 2, Spark -> 4)

    //todo 3.所有类都有 -> 方法 ，这个方法用于创建关联关系 构成k-v
    val kv1 = "a" -> 1
    val kv2 = kv1 -> 2
    println(kv1) //(a,1)
    println(kv2) //((a,1),2)



    //todo 4.可变Map
    val map3: mutable.Map[String, Int] = mutable.Map("a" -> 1, "b" -> 2, ("c", 3), ("a", 3))
    println(map3) //Map(b -> 2, a -> 3, c -> 3)

    map3.put("d",4)
    map3.update("c",13)
    map3.remove("a")
    
  }
}

Option

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

    val map = Map(("a", 1), ("Hadoop", 2), ("Spark", 4))

    val v: Option[Int] = map.get("a")
    val v1: Option[Int] = map.get("d")
    println(v) //Some(1)
    println(v1)//None

    //通过key获取value，返回值是个Option对象
    //Option叫做选项，Some为有值  None为无值
    
  }
}

Option的出现是为了防止空指针异常；

---

理解空指针异常

这里报异常的原因不在于user为null，user.age本身并没有问题，因为age是类属性，与对象无关；
这里报错是因为在调用test()方法的时候，实际参数是Integer类型，而声明的参数类型是int类型，所以这里会进行拆箱；
拆箱的原理是：Integer.intValue()方法，而这个方法是成员方法，所以会报空指针异常
装箱原理：Integer.valueOf()方法

---

map集合允许放置空key空value
option就是为了解决空指针异常出现的类型

Option的一些方法

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

    val map = Map(("a", 1), ("Hadoop", 2), ("Spark", 4))

    val v: Option[Int] = map.get("a")
    val v1: Option[Int] = map.get("d")
    println(v) //Some(1)
    println(v1)//None

    //通过key获取value，返回值是个Option对象
    //Option叫做选项，Some为有值  None为无值
    //Option有isEmpty用于判断是否为Nonde的
    //Option的get方法用于取出值
    if(!v1.isEmpty){
      println(v1.get)
    }
    //println(v1.get) //空指针异常

    //Option的getOrElse()方法，如果取不到值，就给予默认值
    println(v1.getOrElse(0))//0

    println(map.getOrElse("d", 0))//0
  }
}

isEmpty 判断是否为None
get :如果为None，会报空指针异常
getOrElse(default) : 如果为null，返回传入的默认值
map.get("c").getOrElse(0)可以简化为：map.getOrElse("c",0)

4.Tuple

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


    //todo 元组通过顺序号访问元素
    val t = (1,"张三",30)
    println(t._1)
    println(t._2)
    println(t._3)
    //通过索引访问
    println(t.productElement(1))
    //获取元组迭代器
    val iterator: Iterator[Any] = t.productIterator


    //todo Tuple也有类型的概念 TupleX  X是元素个数  最多放置22个
    // 元素可以是各种类型，也可以是集合
    val t1 : (Int,String,Int) = (1,"张三",30)
    //todo 对偶元组   元组数量为2  也叫做对偶元组
  }
}

5.Queue

Kafka分区

（1）kafka的数据是分区内有序，分区间无序；

（2）放在一个分区内也有可能会无序：

假设生产者在往broker中写入2的时候失败重发，此时2就会回到队列尾部
（3）kafka如何处理这个问题？
采用双端队列，两边都可以上两边都可以下

也就是说如果2发送失败了，再原路放回队列中

Queue

(1)Deque 是jdk1.6引入的
(2)java中还有BlockingQueue
当队列满了，不再往里写
队列空了，不再消费
从而实现削峰

6.并发和并行

并发：吃一根烤肠，你一口我一口
并行：一人吃一根烤肠

并发
如下图所示：三个线程，一个核
一个核同一时间点只能做一件事情；
此时只能并发，也就是你执行一会我执行一会；
和串行不同，串行是你执行完了，我再执行。

串行

并行
并行的前提是有多核

T2和T3是抢用一个核的，因此他俩是并发
T1和T2或者T3是并行的

总结：
无论是并发还是并行，都一定指的是多线程，只不过是看有几个核而已 ;

scala中并行集合

object Scala09_Collection_paraller {
  def main(args: Array[String]): Unit = {
    val result1 = (0 to 100).map{x => Thread.currentThread.getName}
    //par 并行的缩写，并行集合   用多线程来处理每一条数据  处理顺序无法保障
    val result2 = (0 to 100).par.map{x => Thread.currentThread.getName}

    println(result1)
    println(result2)
  }
}

线程安全问题

(1)栈内存线程独享，堆内存共享
所谓线程安全问题，其实就是多线程在并发访问的时候，对共享内存中的共享对象的属性进行修改所导致的数据冲突问题
Keyword:

• 并发访问
• 共享内存
• 共享对象 (共享内存中的共享对象)
• 属性的修改 （方法是在栈中，不会有并发问题）