大数据8_11_Scala泛型&正则表达式&分布式原理

14 泛型

泛型目的是为例增加类型的约束,提高程序的健壮性。

  • 泛型和类型的关系

image-20201120162503541

泛型和类型没有直接关系,但是类型标识对外部类型的数据约束。

泛型主要用于对内部数据类型的约束。

14.1 泛型不可变

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

        val test1 : Test[User] = new Test[User] // OK
        val test2 : Test[User] = new Test[Parent] // Error
        val test3 : Test[User] = new Test[SubUser]  // Error

    }
    class Test[T] {
    }
    class Parent {
    }
    class User extends Parent{
    }
    class SubUser extends User {
    }
}

14.2 泛型协变

能不能将类型和泛型当成一个整体来用?

​ 当成整体后,如果泛型为子类型也可以代替父类型,User -> Child

  • 泛型的协变 : 泛型前加 +
object ScalaGeneric {
    def main(args: Array[String]): Unit = {

        val test1 : Test[User] = new Test[User] // OK
        val test2 : Test[User] = new Test[Parent] // Error
        val test3 : Test[User] = new Test[SubUser]  // OK

    }
    class Test[+T] {
    }
    class Parent {
    }
    class User extends Parent{
    }
    class SubUser extends User {
    }
}

14.3 泛型逆变

泛型的逆变:父类可以代替子类型,Parent -> User

  • 泛型的逆变:泛型前加 -
object ScalaGeneric {
    def main(args: Array[String]): Unit = {

        val test1 : Test[User] = new Test[User] // OK
        val test2 : Test[User] = new Test[Parent] // OK
        val test3 : Test[User] = new Test[SubUser]  // Error

    }
    class Test[-T] {
    }
    class Parent {
    }
    class User extends Parent{
    }
    class SubUser extends User {
    }
}

14.4 泛型的上限

object ScalaGeneric {
    def main(args: Array[String]): Unit = {
        val parent : Parent = new Parent()
        val user : User = new User()
        val subuser : SubUser = new SubUser()
        test[Parent](parent) // Error
        test[User](user)   // OK
        test[SubUser](subuser) // OK
    }
    def  test[A<:User]( a : A ): Unit = {
        println(a)
    }
    class Parent {
    }
    class User extends Parent{
    }
    class SubUser extends User {
    }
}

14.5 泛型的下限

object ScalaGeneric {
    def main(args: Array[String]): Unit = {
        val parent : Parent = new Parent()
        val user : User = new User()
        val subuser : SubUser = new SubUser()
        test[Parent](parent) // OK
        test[User](user)   // OK
        test[SubUser](subuser) // Error
    }
    def  test[A>:User]( a : A ): Unit = {
        println(a)
    }
    class Parent {
    }
    class User extends Parent{
    }
    class SubUser extends User {
    }
}

14.6 上下文限定

上下文限定是将泛型和隐式转换的结合产物,以下两者功能相同,使用上下文限定[A : Ordering]之后,方法内无法使用隐式参数名调用隐式参数,需要通过implicitly[Ordering[A]]获取隐式变量,如果此时无法查找到对应类型的隐式变量,会发生出错误。

object ScalaGeneric {
    def main(args: Array[String]): Unit = {
        def f[A : Test](a: A) = println(a)
        implicit val test : Test[User] = new Test[User]
        f( new User() )
    }
    class Test[T] {
    }
    class Parent {
    }
    class User extends Parent{
    }
    class SubUser extends User {
    }
}

15 正则表达式

image-20201120203818235

image-20201120203826840

image-20201120203838166

15.1 基本语法

object ScalaRegex {
    def main(args: Array[String]): Unit = {
        // 构建正则表达式
        val pattern = "Scala".r
        val str = "Scala is Scalable Language"

        // 匹配字符串 - 第一个
        println(pattern findFirstIn str)

        // 匹配字符串 - 所有
        val iterator: Regex.MatchIterator = pattern findAllIn str
        while ( iterator.hasNext ) {
            println(iterator.next())
        }

        println("***************************")
        // 匹配规则:大写,小写都可
        val pattern1 = new Regex("(S|s)cala")
        val str1 = "Scala is scalable Language"
        println((pattern1 findAllIn str1).mkString(","))
    }
}

15.2 案例实操

  • 手机号正则表达式验证方法
object ScalaRegex {
    def main(args: Array[String]): Unit = {
        // 构建正则表达式
        println(isMobileNumber("18801234567"))
        println(isMobileNumber("11111111111"))
    }
    def isMobileNumber(number: String): Boolean ={
        val regex = "^((13[0-9])|(14[5,7,9])|(15[^4])|(18[0-9])|(17[0,1,3,5,6,7,8]))[0-9]{8}$".r
        val length = number.length
        regex.findFirstMatchIn(number.slice(length-11,length)) != None
    }
}
  • 提取邮件地址的域名部分
object ScalaRegex {
    def main(args: Array[String]): Unit = {
        // 构建正则表达式
        val r = """([_A-Za-z0-9-]+(?:\.[_A-Za-z0-9-\+]+)*)(@[A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)*(?:\.[A-Za-z]{2,})) ?""".r
        println(r.replaceAllIn("abc.edf+jianli@gmail.com   hello@gmail.com.cn", (m => "*****" + m.group(2))))
    }
}

16 分布式原理

image-20201120162706835

image-20201120162758397

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

最佳第六六六人

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值