Scala quene、set、map、模式匹配

import scala.collection.mutable

val q1 = new mutable.Queue[Int]

// 队列追加单个元素
q1 += 9
// 队列追加list
q1 ++= List(8, 7, 6)

val quene = new mutable.Queue[Int]()
quene += 0
quene += 1

// 加入队列，会改变quene本身
quene.enqueue(12)
// 出去队列，会改变quene本身
println(quene)
// 返回quene的第一个元素，并不改变quene本身
println(quene.head)
// 返回quene的第一个元素，并不改变quene本身
println(quene.last)
// 返回quene的尾部元素，并不改变quene本身
println(quene.tail)

// set 中是无序的，不可重复的

// 创建不可变的Set
val set = Set(1, 2, 3, 4, 5)
// 创建可变的Set
val setn = mutable.Set(1, 2, 3, 4, 5)

println(set)

val set1 = set + (6)
val set2 = set + (6, 7, 8, 9)
val set3 = set ++ List(11, 12, 13)

// 求所有元素的和
println(set.sum)
// 求满足条件的个数
println(set.count(x => x > 3))
// 判断set是否为空
println(set.isEmpty)
// 删除set中的元素
println(set.drop(1))
// 两个set的差集
println(set.diff(mutable.Set(3, 4, 5)))
// 可变集合中移除某个元素
setn.remove(4)
println(setn)
// 迭代set中的值
for (s <- set) {
  println(s)
}

def main(args: Array[String]): Unit = {
    // tuple是一个容器，可以存放各种数据类型的元素
    // tuple 的创建
    // 推荐使用该种方式
    val tp = (1, 2, "hadoop", "scala")
    // 创建一个长度为6的tuple
    val tuple = new Tuple6(1, 2, 3, 4, 5, "hadoop")
    // 采用映射的方式创建tuple
    val t1 = 2 -> "hdfs" // (2,hdfs)
    // 采用多级映射的方式创建tuple
    val t2 = 3 -> "hdfs" -> "mapreduce" //((3,hdfs),mapreduce)

    // tuple 元素的访问使用._1,._2 。。来进行访问
    println(tuple._1)
    
    // tuple元素的遍历
    for (i <- 0 until tuple.productArity) {
      println(tuple.productElement(i))
    }

    // Tuple 继承自product ,product 中有productArity用于计算product的大小
    // Product 中productElement(n:Int) 用于输出指定位置的元素

    // tuple 中有两个元素，成为对偶元祖
    val tuple1: (String, String) = new Tuple2("first", "second")

    // 对偶元祖中可以交换两个元素的位置
    tuple1.swap

    val tup = (("hadoop", 30), 89)
    println(tup._1._2) // 获取到30
  }

def main(args: Array[String]): Unit = {
	// 创建不可变的Map
	val map = Map("hadoop" -> 20, "scala" -> 30)
	// 创建可变的Map
	val mmap: mutable.HashMap[String, Int] = new mutable.HashMap[String, Int]()
	// Map 元素的访问根据键获取值
	println(map("hadoop"))
	// 从Map中取数据，取不到就用默认值
	println(map.getOrElse("kafka", 12))

	// map元素的添加和删除
	mmap += ("hadoop" -> 12)
	mmap.remove("hadoop")
	println(mmap)

	val map2 = Map("hadoop" -> 20, "scala" -> 30, "kafka" -> 23)
	// 获取所有key的集合，返回一个set类型的数据
	println(map2.keys)
	println(map2.keySet)
	// 获取map中所有值的集合，返回一个值类型的数据,再转List
	println(map2.values.toList)
	// 使用get方法返回的是一个Som类型的数据，再次用get获取到值
	println(map2.get("hadoop"))
	println(map2.get("hadoop").get)

	// 遍历Map
	for ((k, v) <- map2) {
	  println("key:   " + k + "   value:   " + v)
	}
	// 利用所有的可以的集合获取数据
	for (key <- map2.keySet) {
	  println("key:   "+key+ "   value:   "  + map2.get(key).get)
	}
}

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

    /**
     * 语法：
     * 变量 match{
     * case 值1 =>...
     * case 值2 =>...
     * case 值3 =>...
     * case 值4 =>...
     * _ =>...
     * }
     */

    // 根据内容进行匹配
    val courses = Array("Hadoop", "HDFS", "MapReduce", "Spark", "Flink")
    val course = courses(Random.nextInt(courses.length))
    course match {
      case "Hadoop" => println("Hadoop")
      case "HDFS" => println("HDFS")
      case "Spark" => println("Spark")
      case _ => println("Other")
    }

    // 匹配数组
    def matchArray(array: Array[String]) = {
      array match {
        // 单个匹配
        case Array("Hadoop") => println("Hadoop")
        // 匹配两个
        case Array(x, y) => println("Hi:  " + x + " , " + y)
        // 匹配动态参数
        case Array("Hadoop", _*) => println("匹配动态参数")
        case _ => println("Default")
      }
    }

    // 匹配集合
    def matchList(array: List[String]) = {
      array match {
        case "Hadoop" :: Nil => println("match single")
        case x :: y :: Nil => println("match two")
        case "Hadoop" :: tail => println("match start with Hadoop")
        case _ => println("Others")
      }
    }

    // 根据类型进行匹配
    def matchType(obj: Any) = {
      obj match {
        case i: Int => println("Int")
        case l: String => println("Stirng")
        case m: Map[_, _] => println("Map")
        case _ => println("Other")
      }
    }

    val grades = Map("Hadoop" -> "A", "Spark" -> "B", "Flink" -> "C")

    def matchGrade(name: String) = {
      val grade = grades.get(name)
      grade match {
        case Some(grade) => println("your grade is " + grade)
        case None => println("Error")
      }
    }
    // 模式匹配进行异常处理
    try {
      val i = 1 / 0
    } catch {
      case e: ArithmeticException => println("除数不能为0")
      case e: Exception => println(e.getMessage)
    }

    /**
     * 模式匹配在工作中典型的场景就是异常处理
     * IO操作、JDBC连接
     * 1）open
     * 2）TODO
     * 3）close / release
     */

  }
}

/**
 * 下划线的使用
 * 1.定义变量的时候给变量占空位
 * 2.定义方法时候的可变参数
 * 3.方法转变量
 */

def sayHello(name: String) = {
  println("hello:\t" + name)
}

// 使用以下两种方式将函数赋值给变量
val say = sayHello _
val say2 = sayHello(_)

// 直接调用即可
//    say("hadoop")
//    say2("hadoop")

// 匿名函数
// x: Int) => x + 2
{ (x: Int) => x + 2 }