scala基础-04

复习老师讲课的内容，复制讲课的代码到工作空间，无法运行。注意：需要修改包名

匹配match case，样例类case

object ScalaDemo06 {
  def main(args: Array[String]): Unit = {
//    val list = List(1,2,3,4,5,6)
    val num = 10
    matchVal(num)
    
    val list = List(1,2,3,45,9)
    list.foreach { matchVal }
    
    val ppp1 = new PPP("Angelababy",29)
    val ppp2 = PPP("Dilireba",26)
    val ppp3 = PPP("zhangxinyi",22)
    val ppp4 = PPP("fanbingbing",20)
    val ppp5 = PPP("liuyan",28)
    val pppList = List(ppp1,ppp2,ppp3,ppp4,ppp5)
    
    pppList.foreach { x => x match {
      case PPP("zhangxinyi",22) => println("value match" + x.toString())
      case p:PPP => println("type match" + p.toString()) 
      case _ => println(x.toString())
    }}
    
  }
  
  /**
   * 在scala中 match 既可以进行值匹配  又可以类型匹配
   * 在scala中 match根据顺序从上往下去匹配，一旦匹配成功就不再继续往下匹配了
   */
  def matchVal(num:Any) = {
    num match {
      case 10 => println(10) 
      case 9 => println(9)
      case i:Int => println("Int:" + i)
      case _ => println("default")
    }
  }
}

/**
 * 样例类(case classes)
 * 使用了case关键字的类定义就是样例类(case classes)，样例类是种特殊的类
 * 特点：
 *         1、样例类默认帮你实现了toString,equals，copy和hashCode、apply等方法
 *         2、样例类可以new, 也可以不用new
 */
case class PPP(name:String,age:Int) {
  
}

set集合，trait，元组

object ScalaDemo05 {
  def main(args: Array[String]): Unit = {
    //set集合    去重数据
    val set1 = Set(1, 2, 3, 4, 4)
    val set2 = Set(1, 2, 5)
    //遍历 注意：set会自动去重
    set1.foreach { println }
    for (s <- set1) {
      println(s)
    }
    //交集    .& = intersect
    val set3 = set1.intersect(set2)
    set3.foreach { println }
    val set4 = set1.&(set2)
    set4.foreach { println }
    println("*******")
    //差集  diff = &~
    set1.diff(set2).foreach { println }
    set1.&~(set2).foreach { println }
    //子集
    println(set1.subsetOf(set2))

    //最大值
    println(set1.max)
    //最小值
    println(set1.min)
    println("****")
    //1  2  3  4
    println(set1.mkString("\t"))

    //(2,"shsxt")这是一个二元组类型    用一堆小括号组织起来的元素，
    //Option类型有两个子类型   Some None   如果通过key能够获取到value此时返回的是Some  否则返回的是None
    //getOrElse如果能获取到值，那么将值返回，否则返回的是默认值  get  getOrElse
    val map = Map(1 -> "bjsfanbingbingxt", (2, "shsxt"), "5" -> "sasxt")
    println(map.get("5").getOrElse("no result"))
    map.foreach((x: (Any, String)) => {
      println(x._2)
    })

    val map1 = Map(
      (1, "a"),
      (2, "b"),
      (3, "c"))
    val map2 = Map(
      (1, "aa"),
      (2, "bb"),
      (2, 90),
      (4, 22),
      (4, "dd"))
    map1.++:(map2).foreach(println)

    println(map.contains(6))

    println(map.exists(x => x._2.contains("fanbingbing")))

    /**
     * 元组
     * 1.元组定义
     * 与列表不同的是元组可以包含不同类型的元素。元祖对象是通过一对小括号包裹起来组成的
     */
    val t2 = Tuple2(1, "libingbing")
    val tt2 = (1, "lichen")
    val t3 = t2.swap
    println(t3._1 + "===" + t3._2)

    /**
     * trait    特性
     * 1.概念理解
     * Scala Trait(特征) 相当于 Java 的接口，实际上它比接口还功能强大。
     * 与接口不同的是，它还可以定义属性和方法的实现。
     * 一般情况下Scala的类可以继承多个Trait，从结果来看就是实现了多重继承。Trait(特征) 定义的方式与类类似，但它使用的关键字是 trait。
     * 2.举例：trait中带属性带方法实现
     * 注意：
     * 继承的多个trait中如果有同名的方法和属性，必须要在类中使用“override”重新定义。
     * trait中不可以传参数
     */

    val p = new Person1
    p.read("Fenger")
    p.listen("Fenger Love you")

    val p1 = new Point(2, 2)
    val p2 = new Point(1, 3)
    println(p1.isEqule(p2))
    println(p1.isNotEqule(p2))
  }
}

trait Read {
  val readType = "Read"
  val gender = "m"
  def read(name: String) {
    println(name + " is reading")
  }
}

trait Listen {
  val listenType = "Listen"
  val gender = "m"
  def listen(name: String) {
    println(name + " is listenning")
  }
}

class Person1() extends Read with Listen  {
  override val gender = "f"
}

trait Equle {
  def isEqule(x: Any): Boolean
  def isNotEqule(x: Any) = {
    !isEqule(x)
  }
}

class Point(x: Int, y: Int) extends Equle {
  val xx = x
  val yy = y

  def isEqule(p: Any) = {
    p.isInstanceOf[Point] && p.asInstanceOf[Point].xx == xx
  }

}

隐式转换系统，隐式值，隐式视图，隐式类（减少代码量）

/**
 * Scala的隐式转换系统
 *     隐式转换，在编写程序的时候可以尽量少的去编写代码，
 *     让编译器去尝试在编译期间自动推导出这些信息来，
 *     这种特性可以极大的减少代码量，提高代码质量
 * 包含：
 *     隐式值
 *     隐式视图(隐式方法)
 *     隐式类
 */
object ScalaDemo07 {
  def main(args: Array[String]): Unit = {

    /**
     * 隐式值
     * 隐式转换必须满足无歧义规则
     *
     * 声明隐式参数的类型最好是自定义的数据类型，不要使用Int,String这些常用类型，防止碰巧冲突
     */
    implicit val num1 = 1000
    //    implicit val num2 = 2000
    add

    /**
     * type mismatch; found : String("1000") required: Int
     * 工作原理：
     *         在调用sayNum的时候传入的是字符串  与sayNum定义的参数不一致
     *         此时他会在作用域内寻找隐式视图，发现了stringToInt(参数是string，输出是Int)
     *         stringToInt("1000") = 1000
     *         sayNum(1000)
     */
    implicit def stringToInt(numStr: String) = Integer.parseInt(numStr)
    sayNum("1000")

    val s1 = new Student1()
    val s2 = new Student2()
    implicit def s2Tos1(s: Student2) = new Student1()
    s2.sayStudent("Anagelababy")

    /**
     * 隐式类
     * 工作原理：
     *         "abc"这个字符串在调用getLength方法的时候，发现没有这个方法，此时会在作用域内寻找隐式视图或者隐式类
     *         StringUtil隐式类,构造函数是String类型并且就一个参数，此时会将会创建StringUtil这个类的对象，将"abc"
     *         传入给StringUtil构造函数====StringUtil类型的对象，getLength方法
     */
    implicit class StringUtil(str: String) {
      def getLength() = str.length()
    }
    println("abc".getLength)
  }

  def add(implicit num: Int) = {
    println(num + 1000)
  }

  /**
   * 隐式视图
   *     隐式转换为目标类型：把一种类型自动转换到另一种类型
   */
  def sayNum(num: Int) = {
    println("say num:" + num)
  }
}

class Student1 {
  def sayStudent(name: String) = {
    println(name)
  }
}
class Student2 {

}

猜你喜欢