scala基础-04

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

   匹配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) {
     
   }

    

2. 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
     }
   
   }

    

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

   /**
    * 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 {
   
   }