第一章.模式匹配

1.匹配元组

  1. package com.atguigu.chapter08
  3. import com.atguigu.chapter07.$07_Tuple.{Region, School, Student}
  5. object $07_MatchTuple {
  6.   /**
  7.    * 匹配元组的时候,变量是几元元组,匹配条件就只能是几元元组
  8.    */
  9.   def main(args: Array[String]): Unit = {
  10.     val t1:(Any,Any,Any) = ("zhangsan",20,"shenzhen")
  11.     t1 match{
  12.       case (x:String, y:Int, z:Int) =>println(s"1x=${x} y=${y} z=${z}")
  13.       case (x,y,z)=>println(s"2x=${x} y=${y} z=${z}")
  14.     }
  15.     val list3 = List(
  16.       new Region("宝安区1",new School("宝安中学1",new Student("张三1",21))),
  17.       new Region("宝安区2",new School("宝安中学2",new Student("张三2",22))),
  18.       new Region("宝安区3",new School("宝安中学3",new Student("张三3",23))),
  19.       new Region("宝安区4",new School("宝安中学4",new Student("张三4",24)))
  20.     )
  21.     val list4 = for (elem <- list3) yield {
  22.       (elem.name, (elem.school.name, (elem.school.student.name, elem.school.student.age)))
  23.     }
  24.     list4.foreach(x=>{
  25.       x match{
  26.         case(regionName,(schoolName,(stuName,age)))=> println(stuName)
  27.       }
  28.     })
  29.   }
  31. }

2.匹配对象与样例类

  1. package com.atguigu.chapter08
  3. object MatchClass {
  4.   /**
  5.    * 样例类,其实就是伴生类和伴生对象的封装
  6.    *    语法: case class 类名([val/var] 属性名:类型,.....)
  7.    *    属性不用val/var修饰的默认就是val修饰的
  8.    *    创建对象: 类名(值,....)
  9.    *    样例对象: case object object 名称
  10.    *
  11.    * 普通类默认不能直接用于模式匹配,如果想用模式匹配需要在伴生对象中定义unapply方法,unapply方法就是将对象解构成属性
  12.    */
  13.   case class Person(val name:String,var age:Int,address:String)
  14.   abstract class Sex
  15.   //样例对象
  16.   case object Man extends Sex
  17.   case object Woman extends Sex
  18.   def xx(sex:Sex)={
  19.     println(sex)
  20.   }
  21.   def main(args: Array[String]): Unit = {
  22.      val person = Person("lisi",20,"shenzhen")
  23.     println(person.address)
  24.     println(person.name)
  25.     println(person.age)
  26.     person.age=100
  27.     val student = Student("zhangsan",20,"beijing")
  28.     println(student.name)
  29.     println(student.address)
  30.     println(student.age)
  31.     xx(Man)
  33.     person match {
  34.       case Person(x,_,z)=> println(s"name=${x} address=${z}")
  35.     }
  36.     val stu:Student = new Student("lisi",20,"zz")
  37.     stu match{
  38.       case Student(x,y,z)=> println(s"${x} ${y} ${z}")
  39.     }
  40.   }
  42.   class Student(val name:String,var age:Int, val address:String)
  43.   object Student{
  44.     def apply(name:String,age:Int,address:String)=new Student(name,age,address)
  45.     def unapply(stu:Student):Option[(String,Int,String)]={
  46.       if(stu == null) None
  47.       else Some((stu.name,stu.age,stu.address))
  48.     }
  49.   }
  51. }

3.变量声明与for循环的模式匹配

  1. package com.atguigu.chapter08
  3. object $09_MatchParam {
  4.   def main(args: Array[String]): Unit = {
  5.     val t =("zhangsan",20,"shenzhen")
  6.     println(t._1)
  7.     val (name,age,address)=("zhangsan",20,"shenzhen")
  8.     println(name)
  9.     val List(x,_*)=List(1,2,3,4,45,4)
  10.     println(x)
  11.     val Array(y,z)=Array("hello",1)
  12.     println(y,z)
  13.     val map = Map[String,Int]("aa"->1,"bb"->2)
  14.     for ((k,v)<- map) {
  15.       println(k)
  16.       println(v)
  17.     }
  18.   }
  20. }

4.偏函数

  1. package com.atguigu.chapter08
  2. import com.atguigu.chapter07.$07_Tuple.{Region, School, Student}
  3. import scala.io.StdIn
  5. object $10_PartitalFunction {
  6.   /**
  7.    * 偏函数: 没有match关键字的模式匹配称之为偏函数
  8.    *    语法: val 函数名:PartialFunction[IN,OUT]={
  9.    *      case 条件=> ...
  10.    *      case 条件=> ...
  11.    *      case 条件=> ...
  12.    *      ....
  13.    *    }
  14.    */
  15.   def main(args: Array[String]): Unit = {
  16.     val func:PartialFunction[String,Int]={
  17.       case "hadoop"=>{
  18.         println("hadoop..")
  19.         10
  20.       }
  21.       case "spark"=>{
  22.         println("spark..")
  23.         20
  24.       }
  25.       case _ =>{
  26.         println("其他..")
  27.         30
  28.       }
  29.     }
  30.     val wc = StdIn.readLine("请输入一个单词:")
  31.     println(func(wc))
  32.     val list = List("hello","spark","hadoop","flume")
  33.     val func2:PartialFunction[String,Int]={
  34.        case x =>x.length
  35.     }
  36.     //list.map(x=>x.length)
  37.     println(list.map{
  38.       case x => x.length
  39.     })
  41.     val list3 = List(
  42.       ("宝安区1",("宝安中学1",("张三1",21))),
  43.       ("宝安区2",("宝安中学2",("张三2",22))),
  44.       ("宝安区3",("宝安中学3",("张三3",23))),
  45.       ("宝安区4",("宝安中学4",("张三4",24)))
  46.     )
  47.     list3.foreach(x=>x match{
  48.       case(regionName,(schoolName,(stuName,age)))=> println(stuName)
  49.     })
  50.     //偏函数的使用场景
  51.     val func3:PartialFunction[(String,(String,(String,Int))),Unit]={
  52.       case(regionName,(schoolName,(stuName,age)))=> println(stuName)
  53.     }
  54.     list3.foreach{
  55.       case(regionName,(schoolName,(stuName,age)))=> println(stuName)
  56.     }
  57.   }
  59. }

第二章.异常

  1. package com.atguigu.chapter09
  3. import scala.util.Try
  5. object $01_Exception {
  6.   /**
  7.    * java的异常处理方式
  8.    *      1.捕获异常: try{...}catch(Exception e){...}.. finally{...}
  9.    *      2.抛出异常: throw new XXException[必须在方法名后面通过throws声明异常]
  10.    *
  11.    *
  12.    * scala的异常处理方式
  13.    *      1.捕获异常
  14.    *          a.try{...}catch{case e:Exception => ...} finally{...}<一般用于获取外部资源链接的时候使用,可以通过finally关闭资源链接>
  15.    *          b.Try(代码块).getOrElse(默认值)<常用>
  16.    *              Try有两个子类:
  17.    *                Success: 代表代码执行成功,代码执行结果封装在Success中
  18.    *                Failture: 代表代码执行失败
  19.    *              Try(代码块).getOrElse(默认值)  [此时如果代码执行成功,则返回执行结果,如果代码执行失败则返回默认值]
  20.    *      2.抛出异常:throw new XXException [不需要在方法后面通过throws关键字声明异常]<不用>
  21.    */
  22.   def main(args: Array[String]): Unit = {
  23.     //println(m1(10, 2))
  24.     //println(m1(10, 0))
  25.     println(m2(10, 0))
  26.     val list= List("1 zhangsan 20 beijing","2  30 shenzhen","3 lisi  tianjin")
  27.     val list2 = list.map(x=>{
  28.       val arr = x.split(" ")
  29.       val age = Try(arr(2).toInt).getOrElse(0)
  30.       (arr.head,arr(1),age,arr(3))
  31.     })
  32.     println(list2)
  34.   }
  37.   //抛异常
  38.   def m1(x:Int,y:Int):Int={
  39.     if(y==0) throw new Exception("被除数不能为0")
  40.     else x/y
  41.   }
  42.   //捕获异常
  43.   def m2(x:Int,y:Int):Int={
  44.     try{
  45.       x/y
  46.     }catch{
  47.       case e:Exception =>
  48.         println(e.getMessage)
  49.         -1
  50.     }
  51.   }
  53. }

第三章.隐式转换

1.隐式转换方法

  1. package com.atguigu.chapter10
  3. import java.io.File
  4. import scala.io.{BufferedSource, Source}
  7. class BB{
  8.   //隐式转换方法
  9.   implicit def double2Int(d:Double):Int={
  10.     println(s"-------->${d}")
  11.     d.toInt
  12.   }
  13.   //隐式转换方法
  14.   implicit def file2SourceBuffer(file:File):BufferedSource={
  15.     Source.fromFile(file,"utf-8")
  16.   }
  17. }
  19. object $01_ImplicitMethod {
  20.   /**
  21.    * 隐式转换分为三类:
  22.    *    1.隐式转换方法:悄悄的将一个类型转成另一个类型
  23.    *      语法: implicit def 方法名(参数名:待转换类型):目标类型={....}
  24.    *      隐式转换方法的调用时机:
  25.    *        1.当前类型与目标类型不一致的时候,会自动调用隐式转换方法
  26.    *        2.当对象使用了不属于自身的属性和方法的时候,会自动调用隐式转换方法
  27.    *    2.隐式参数
  28.    *    3.隐式类
  29.    * 隐式转换的解析
  30.    *    首先会从当前作用域和父作用域查找是否有符合条件的隐式转换,如果有直接使用,如果没有则报错
  31.    *    如果隐式转换定义在其他的object/class中,使用的时候需要导入
  32.    *        1.隐式转换定义在object中,此时可以通过import object名称._ \ import object名称.隐式转换名称
  33.    *        2.隐式转换定义在class中,此时可以通过 import 对象名._ /import 对象名.隐式转换名称 导入
  34.    *    如果有多个隐式转换都符合要求,需要明确指定需要使用哪一个隐式转换
  35.    */
  36.   def main(args: Array[String]): Unit = {
  37.     val bb = new BB
  38.     import bb._
  39.     import bb.double2Int
  40.     val a:Int=2.5
  41.     val file = new File("C:\\Users\\admin\\IdeaProjects\\atguigu\\scala-study\\datas\\wc.txt")
  42.     file.getLines().foreach(println(_))
  43.   }
  47. }

2.隐式参数

  1. package com.atguigu.chapter10
  3. object $02_ImplicitParam {
  4.   /**
  5.    * 隐式参数:调用方法的时候自动传参
  6.    *   语法:
  7.    *    1.在定义方法的时候,指定哪个参数后续会自动传值:
  8.    *      def 方法名(参数名:类型,..)(implicit 参数名:类型)={...}
  9.    *    2.定义隐式参数的值:
  10.    *      implicit val 参数名:类型 = 值
  11.    */
  12.   def main(args: Array[String]): Unit = {
  13.      import com.atguigu.chapter10.AA.z1
  14.     println(m1(10, 20)(50))
  15.     println(m2)
  16.   }
  17.   def m1(x:Int,y:Int)(implicit z:Int)=x+y+z
  18.   def m2(implicit z:Int)=z
  20. }

3.隐式类

  1. package com.atguigu.chapter10
  3. import java.io.File
  5. object $03_ImplicitClass {
  6.   /**
  7.    * 隐式类:
  8.    *    语法: implicit class 目标类名称(属性名:待转换类型){...}
  9.    * 隐式类其实就是一种特殊形式的隐式转换方法
  10.    * 隐式类不能置于最顶层,必须放在object/class中
  11.    * 隐式类其实就是自动调用主构造器进行类型的转换
  12.    */
  13.   implicit class RichFile(file:File){
  14.     def m1(x:Int,y:Int)=x+y
  15.     val name = "zhansan"
  16.   }
  18.   def main(args: Array[String]): Unit = {
  19.     val file = new File("C:\\Users\\admin\\IdeaProjects\\atguigu\\scala-study\\datas\\wc.txt")
  20.     println(file.m1(20, 30))
  21.   }
  22. /*  implicit def file2RichFile( file:File ):RichFile = {
  23.     new RichFile
  24.   }*/
  25. }

第四章.泛型

1.泛型方法

  1. package com.atguigu.chapter11
  3. object $01_GenericMethod {
  4.   /**
  5.    * 泛型方法:
  6.    *    语法: def 方法名[T,U,...](参数名:T):U={...}
  7.    */
  8.   def main(args: Array[String]): Unit = {
  9.     m1[String](Array("aa","bb"))
  10.   }
  11.   def m1[T](x:Array[T])={
  12.     println(x.length)
  13.   }
  14. }

2.泛型类

  1. package com.atguigu.chapter11
  3. import java.beans.BeanProperty
  5. object $02_GenericClass {
  6.   /**
  7.    * 泛型类语法:
  8.    *      class 类名[T,U,...](属性名:T,...){
  9.    *          def 方法名(x:T):U=..
  10.    *      }
  11.    * @param args
  12.    */
  13.   class Person[T,U](@BeanProperty var name:T, @BeanProperty var age:U)
  14.   def main(args: Array[String]): Unit = {
  15.     val person = new Person[String,Int]("lisi",20)
  16.     println(person.getName)
  17.   }
  19. }

3.非变,逆变,协变

  1. package com.atguigu.chapter11
  3. /**
  4.  * 非变[T]:同一个类,如果泛型不一样创建出来的对象没有任何关系
  5.  * 协变[+T]:同一个类,如果泛型之间有父子关系,创建出来的对象继承了泛型的父子关系
  6.  * 逆变[-T]:同一个类,如果泛型之间有父子关系,创建出来的对象颠倒了泛型的父子关系
  7.  */
  9. object $03_GenericChange {
  10.   class Animal
  11.   class Dog extends Animal
  12.   //非变
  13.   class Parent[T]
  14.   //逆变
  15.   class Parent2[+T]
  16.   //协变
  17.   class Parent3[-T]
  19.   def main(args: Array[String]): Unit = {
  20.     var list1 = List[Animal](new Animal,new Animal)
  21.     println(list1)
  22.     var list2 = List[Dog](new Dog,new Dog)
  23.     list1 = list2
  24.     println(list1)
  26.     //非变
  27.     var b1 = new Parent[Animal]
  28.     var b2 = new Parent[Dog]
  29.     //b1 = b2
  30.     //协变
  31.     var b3 = new Parent2[Animal]
  32.     var b4 = new Parent2[Dog]
  33.     b3 = b4
  34.     println(b3)
  35.     //逆变
  36.     var b5 = new  Parent3[Animal]
  37.     var b6 = new  Parent3[Dog]
  38.     b6 = b5
  39.     println(b6)
  41.   }
  43. }

4.上下限

  1. package com.atguigu.chapter11
  3. object $04_GenericLowHight {
  4.   class Parent
  5.   class Sub1 extends Parent
  6.   class Sub2 extends Sub1
  7.   class Sub3 extends Sub2
  9.   /**
  10.    * 上限[T<:类型]:要求传入的类型必须是指定类型或者是其子类
  11.    * 下限[T>:类型]:要求传入的类型必须是指定类型或者是其父类
  12.    */
  13.   //上限
  14.   def m1[T<:Sub1](t:T)={
  15.     println(t)
  16.   }
  17.   //下限
  18.   def m2[T>:Sub1](t:T)={
  19.     println(t)
  20.   }
  22.   def main(args: Array[String]): Unit = {
  23.     //上限
  24.     //m1(new Parent)
  25.     m1(new Sub3)
  26.     //下限
  27.     m2(new Parent)
  28.     val p:Any = new Sub3
  29.     m2(p)
  30.     val x:Any = 10
  31.     m2(x)
  32.   }
  34. }

5.上下文

  1. package com.atguigu.chapter11
  3. import java.beans.BeanProperty
  5. object $05_GenericContext {
  6.   /**
  7.    * 上下文:
  8.    *     语法: T:类型
  9.    */
  10.   class Person[T]{
  11.     @BeanProperty var name:T=_
  12.   }
  13.   def main(args: Array[String]): Unit = {
  14.     implicit val p:Person[String] = new Person[String]
  15.     val person = m1[Int](10)(new Person[Int])
  16.     val person2 = m1[String]("zhangsan")
  17.     println(person.getName)
  18.     println(person2.getName)
  19.     val person3 = m2[String]("wangwu")
  20.     println(person3.getName)
  21.   }
  22.   def m1[U](x:U)(implicit p:Person[U])={
  23.     p.setName(x)
  24.     p
  25.   }
  26.   def m2[U:Person](x:U)={
  27.     val person =implicitly[Person[U]]
  28.     person.setName(x)
  29.     person
  30.   }
  32. }