Scala(四)

Scala_Day04

---

ListBuffer的一些操作

package com.shujia

import scala.collection.mutable.ListBuffer

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

    /**
     * ListBuffer：可变的List
     * 有序、元素不唯一
     */

    val lb01: ListBuffer[Int] = ListBuffer[Int](1, 2, 3, 4, 4, 4, 5, 6)
    println(lb01)

    // 增加元素
    lb01.append(1, 2, 3, 4, 5) // 默认将元素加载后面
    println(lb01)

    lb01.insertAll(6, List(1, 2, 3))
    lb01.insert(4, 5, 5, 5)
    lb01 += 1

    println(lb01)

    // 删除元素
    lb01.-=(2)
    lb01.remove(3, 3) // 5 表示索引位置 3表示删除元素的个数
    println(lb01)

    // 更新元素
    lb01.update(3, 44)
    println(lb01)
    lb01(4) = 444
    println(lb01)

    lb01.clear() // 清空
    println(lb01)

  }
}

• 增加元素
  • append
  • +=
  • insertAll
  • insert
• 删除元素
  • -=
  • remove
• 更新元素
  • update
• 清空元素
  • clear

---

Map的一些操作

package com.shujia

import scala.collection.mutable

object Demo15Map {
  def main(args: Array[String]): Unit = {
    /**
     * Map散列：每个元素都是KV格式
     * 一般用于查询的场景，通过K可以快速地获取V
     * 默认是在immutable包里的所以也是不可变的
     * K是不能重复的，后面的KV会覆盖前面定义的KV
     * 无序的
     */

    val map01: Map[String, Int] = Map[String, Int](("k1", 1), Tuple2("k2", 2), "k3" -> 2, "k1" -> 11)
    println(map01)

    /**
     * 除了sort相关的那几个操作之外，基本的方法都有
     * map、flatMap、filter、foreach、groupBy
     */
    println(map01.keys)
    println(map01.values)
    println(map01.map(kv => kv._2))

    // 按照value进行分组
    map01.groupBy(kv => kv._2).map(kv => kv)

    // 通过key获取value
    println(map01("k2"))
    //    println(map01("kk2")) // 如果Key不存在则直接报错

    /**
     * Option类型：抽象地，有两个子类
     * 有值的时候会返回Some类型
     * 值不存在的时候会返回None类型
     * 如果在Scala中调用了某个方法返回值类型为Option
     * 那么在调用之后一定要处理有值以及没有值的两种情况
     *
     * 可以借助match来处理
     */
    println(map01.get("k2")) // 存在则返回Some(v)
    println(map01.get("kk2")) // 不存在则返回None
    val key: String = "kk3"
    map01.get(key) match {
      case Some(v) =>
        println(v + 100)
      case None =>
        println("Key不存在")
    }

    println(map01.getOrElse("k2", 0)) // 实际上调用的还是get方法，只不过自动加上了match进行处理
    println(map01.getOrElse("kk2", 0)) // 不存在则返回默认值

    /**
     * HashMap/mutable.Map：可变的Map
     */
    val map02: mutable.Map[String, Double] = mutable.Map[String, Double]("k1" -> 1.1, "k2" -> 2.2)
    // 增加KV键值对
    map02.+=("k3" -> 3.3)
    map02("k4") = 4.4
    map02.put("k5", 5.5)
    println(map02)

    // 移除KV
    map02.-=("k4")
    println(map02)
    map02.remove("k2")
    println(map02)

    // 修改V
    map02("k1") = 1.11
    println(map02)
    map02.update("k3", 3.333)
    println(map02)

  }
}

---

Set的一些操作

package com.shujia

import scala.collection.mutable

object Demo16Set {
  def main(args: Array[String]): Unit = {
    /**
     * Set集合：元素不能够重复，会自动进行去重，默认也是不可变的
     * 无序的
     */

    val set01: Set[Int] = Set[Int](1, 2, 2, 3, 4, 2, 1, 6, 5, 8)
    println(set01)

    /**
     * 集合的运算：交集、并集、差集......
     */

    val s1: Set[Int] = Set[Int](1, 2, 3, 4, 5)
    val s2: Set[Int] = Set[Int](3, 4, 5, 6, 7)

    println(s1.intersect(s2))
    println(s1 & s2)
    println(s1.union(s2))
    println(s1 | s2)
    println(s1.diff(s2))
    println(s2.diff(s1))
    println(s1 -- s2)
    println(s2 -- s1)

    /**
     * 可变的集合：mutable.Set / HashSet
     */

    val mSet01: mutable.Set[Int] = mutable.Set[Int](1, 2, 2, 3, 4, 7, 6, 5)
    println(mSet01)
    mSet01 += 1
    mSet01 += 11
    mSet01 += 18
    mSet01 += 9
    println(mSet01)

    mSet01.add(2)
    mSet01.add(22)
    println(mSet01)

    mSet01 -= 1
    mSet01 -= 22
    mSet01 -= 18
    mSet01 -= 11
    mSet01.remove(9)
    println(mSet01)

    // 修改：需要先移除再添加即可
    mSet01.remove(5)
    mSet01.add(55)
    println(mSet01)
  }
}

---

隐式类型转换

• 隐式转换函数

package com.shujia

object Demo17Implicit01 {
  // 1、隐式转换函数
  def func01(int: Int): Unit = {
    println(int + 100)
  }

  //  def str2Int(s: String): Int = {
  //    s.toInt
  //  }

  implicit def str2IntAuto(s: String): Int = {
    Integer.parseInt(s)
  }

  implicit def str2MyClass(name: String): MyClass = {
    new MyClass("01", name, 18)
  }

  def main(args: Array[String]): Unit = {
    /**
     * 隐式转换：动态给“对象”（函数、变量、类）增加方法
     */

    func01(10)
    func01(20)

    val str: String = "123"
    //    func01(str) // 由于func01需要接收一个Int类型的参数，直接传字符串，类型不匹配
    //    func01(str.toInt) // 手动调用toInt方法进行类型的转换
    //    func01(str2Int(str)) // 通过调用自定义的字符串转Int类型方法实现调用
    func01(str2IntAuto(str))
    func01(str) // 通过隐式转换自动调用
  }

}

• 隐式转换变量或者叫参数

package com.shujia

object Demo18Implicit02 {
  def main(args: Array[String]): Unit = {
    implicit val defaultPrefix:String = "giegie"
    // 2、隐式转换变量
    def addPrefix(word: String)(implicit prefix: String = " default prefix"): String = {
      word + "-" + prefix
    }

    println(addPrefix("Hadoop")("大象"))
    println(addPrefix("Hive")("蜂象"))
    println(addPrefix("HBase")("鲸鱼"))
    println(addPrefix("Spark")("火花"))
    println(addPrefix("moumoumou")())
    println(addPrefix("moumoumou"))
  }
}

• 隐式转换类

package com.shujia

import scala.io.{BufferedSource, Source}

object Demo19Implicit03 {
  /**
   * 如果class声明为隐式转换类，则构造方法只能接收一个参数p
   * 可以动态的给参数p对应的类型 所有的变量增加类中定义方法以及属性
   */
  implicit class Demo19Implicit03(path: String) {
    var list:List[String] = _
    def readFileFromPath(): List[String] = {
      val bs: BufferedSource = Source
        .fromFile(path)
      val resList: List[String] = bs.getLines().toList

      bs.close()

      resList
    }

    def printFile():Unit = {
      list = readFileFromPath()
      list.foreach(println)
    }
  }

  def main(args: Array[String]): Unit = {
    // 3、隐式转换类

    // 加载students.txt数据
    new Demo19Implicit03("scala/data/stu/students.txt").readFileFromPath().foreach(println)
    new Demo19Implicit03("scala/data/stu/score.txt").readFileFromPath().foreach(println)
    new Demo19Implicit03("scala/data/stu/subject.txt").readFileFromPath().foreach(println)

    "scala/data/stu/subject.txt".readFileFromPath().foreach(println)
    "scala/data/stu/subject.txt".printFile()
  }
}

---

模式匹配

package com.shujia

import com.shujia.Demo11CaseClass.CaseStu

object Demo20Match {
  def main(args: Array[String]): Unit = {
    // 1、匹配基本数据类型
    val i: Int = 2

    val returnV: Int = i match {
      case 0 =>
        println(i)
        0 * i
      case 1 =>
        println(i)
        1 * i
      case 2 =>
        println(i)
        2 * i
      case _ => // 相当于Java中的default
        println(i)
        -1
    }

    println(returnV)

    // 2、匹配字符串
    val str: String = "oneffff"
    val r: Int = str match {
      case "one" =>
        1
      case "two" =>
        2
      case "three" =>
        3
      case _ =>
        -1
    }

    println(r)

    // 3、匹配枚举
    val friday: Week.Value = Week.Friday
    friday match {
      case Week.Friday =>
        println("可以愉快度过周末了")
      case Week.Monday =>
        println("可以愉快地摸鱼了")
      case _ =>
        println("其他打工的日子")
    }

    // 4、匹配类型
    val any: Any = 1
    any match {
      case i: Int =>
        println(s"any变量是Int类型，值为$i")
      case s: String =>
        println(s"any变量是String类型，值为$s")
      case _ =>
        println("其他类型")

    }

    val list: List[(String, (String, (Int, (String, String))))] = List[(String, (String, (Int, (String, String))))](
      ("001", ("zs", (20, ("男", "文科一班"))))
      , ("002", ("ls", (21, ("女", "文科二班"))))
      , ("003", ("ww", (20, ("男", "文科三班"))))
    )
    // 提取层层嵌套的数据 最终转换成字符串进行输出
    list.map(t2 => {
        val id: String = t2._1
        val name: String = t2._2._1
        val age: Int = t2._2._2._1
        val gender: String = t2._2._2._2._1
        val clazz: String = t2._2._2._2._2
        s"$id,$name,$age,$gender,$clazz"
      })
      .foreach(println)

    // 借助模式匹配 简化提取嵌套数据的过程
    list.map {
      case (id: String, (name: String, (age: Int, (gender: String, clazz: String)))) =>
        s"$id,$name,$age,$gender,$clazz"
    }.foreach(println)

    // 5、匹配样例类对象
    val zs: CaseStu = CaseStu("001", "zs", 20, "男", "一班")

    zs match {
      case CaseStu("001", "zs", 20, "男", "一班") =>
        println("这是zs")
      case CaseStu("001", "zs", 20, "女", "一班") =>
        println("这是女的zs")
      case CaseStu("002", "ls", 20, "男", "一班") =>
        println("这是ls")
      case _ =>
        println("不知道是谁")
    }
  }
}

// 定义枚举
object Week extends Enumeration {
  val Monday: Week.Value = Value("Mon.")
  val TuesDay: Week.Value = Value("Tue.")
  val Wednesday: Week.Value = Value("Wed.")
  val Thursday: Week.Value = Value("Thur.")
  val Friday: Week.Value = Value("Fri.")
  val Saturday: Week.Value = Value("Sat.")
  val Sunday: Week.Value = Value("Sun.")
}