需求：类Mysql------>insert 开发完之后发现缺少方法
解决方法：1.修改源码（重新修改mysql）
2.动态混入（OCP）
3.隐式转换（OCP）
object Scala_List3 { def main(args: Array[String]): Unit = { implicit def addDeletedMethod(mysql: Mysql): DBUtils ={ new DBUtils } var mysql = new Mysql() mysql.insert() mysql.delete() } } class Mysql{ def insert(): Unit = { println("删除数据。。。") } } class DBUtils{ def delete(): Unit = { println("插入数据。。。") } }隐式转换函数：能帮助我们进行类型转换（隐式：无法直观看到数据类型）。
为什么要引入隐式转换：OCP（开闭原则）
为什么不直接修改源码：在任何一个程序里，类可能存在继承体系，如果直接修改源码的话，可能会给其他的类带来副作用
如果当前对象发现调用的方法不存在，那么会在作用域内进行搜索（隐式转换函数）、查询，看看是否有一个转换后的数据类型存在这个方法。
scala好处：编码简洁 缺点：源码难以理解
案例一：
def main(args: Array[String]): Unit = { test1("lizi") //lizi... test1() //huge... test1 //huge... //函数形参用implicit修饰了，调用函数的时候可以不写小括号，默认用的就是隐式函数（形参） def test1(implicit name:String="huge"):Unit={ println(name+"...") } }案例二：
def main(args: Array[String]): Unit = { implicit var username1:String = "zhou" //隐式参数 //函数形参用implicit修饰了，调用函数的时候可以不写小括号，默认用的就是隐式函数（形参） def test1(implicit name:String="huge"):Unit={ println(name+"...") } def test(implicit name:String="guo"):Unit={ println(name+"...") } test1() //huge test1 //zhou test() //guo test //zhou }如果当前调用的函数没有用implicit隐式转换关键字，就是调用方法，使用的就是形参
调用函数的时候，虽然使用了隐式转换关键词implicit修饰了形参，调用函数的时候使用了小括号，使用的就是自己的形参；调用函数的时候没有用小括号优先调用隐式参数，注意隐式参数要和形参类型一致，如果没有隐式参数就用自己的形参。
如果调用的函数，没有用implicit隐式转换关键词（关键字）,就是调用方法、使用的是形参。
def main(args: Array[String]): Unit = { implicit var username1:String = "zhou" //函数形参用implicit修饰了，调用函数的时候可以不写小括号，默认用的就是隐式函数（形参） def test1(implicit name:String):Unit={ println(name+"...") } test1("hh") //hh... test1 //zhou }隐式参数注释，test1会报错。
案例一：
隐式类（特质、类（混入、继承））：扩展类功能
def main(args: Array[String]): Unit = { var user:User1 = new User1 user.sayHello() user.printInfo() implicit class NewUser(u:User1){//隐式类 def printInfo(): Unit ={ println("打印信息。。。") } } } } class User1{ def sayHello(): Unit ={ println("hello...") }user1只有sayhello方法，没有其他方法，开发师不可能想的很全面，一定会进行程序的迭代（类：属性、方法修改、增加其他类和特质）
解决方案：1修改源码；2动态混入；3底层增加一个类（研发人员角度）、调用层（用户角度）、添加隐式函数；4用户层添加隐式类
注意：构造函数参数只能有一个；隐式类必须在类、伴生对象、包对象中，不能在顶级类中
补充说明： 隐式转换时机 1）函数中参数 和 调用不一样（触发参数） 2）对象调用的方法在自己的类中不存在（隐式函数、隐式类）
案例二：
def main(args: Array[String]): Unit = { var user: User01 = new User01() user.sayHello() user.printInfo() user.name //隐式类中可以有属性 implicit class NUser(u:User01){ var name : String = "hello world" def printInfo(): Unit ={ println("我在打印信息......") } }//隐式类 } } class User01{ def sayHello(): Unit ={ println("user sayhello ......") } }案例三：隐式转换复杂操作
隐式转换机制（2种方案）： 首先代码的作用域没查找隐式实体（隐式方法、隐式类、隐式对象） 如果第一条检索失败了、会继续查找、隐式参数类型的作用域（object内）开始查找
class A extends B with C（从左向右），常从伴生对象里找
object Scala_List { def main(args: Array[String]): Unit = { var user: User01 = new User01() user.sayHello() user.printInfo() user.name // implicit class Nuser(u:User01){ // var name : String = "hello world" // def printInfo(): Unit ={ // println("我在打印信息......") // } // } } } class User01 extends T1{ def sayHello(): Unit ={ println("user sayhello ......") } } object User01{ implicit class Nuser(u:User01){ var name : String = "hello world" def printInfo(): Unit ={ println("1......") println("我在打印信息......") } } } trait T1{ // implicit class Nuser(u:User01){ // var name : String = "hello world" // def printInfo(): Unit ={ // println("我在打印信息......") // } // }//隐式类 } object T1{ implicit class Nuser(u:User01){ var name : String = "hello world" def printInfo(): Unit ={ println("0......") println("我在打印信息......") } } }隐式转换最终注意事项
隐式转换前提：1.不能存在二义性 2.不能嵌套使用
def main(args: Array[String]): Unit = { //函数签名相同，出错 implicit def f1(d:Double): Int ={ var num:Int =3.5 d.toInt } implicit def f2(d:Double): Int ={ d.toInt } }set不能存储重复元素，不能保留顺序、默认用的是哈希
默认情况下scala使用的是不可变集合，在scala里有可变的也有不可变的set
def main(args: Array[String]): Unit = { //不可变 var set1 = Set(1,2,3) println(set1) //可变 var set2 = mutable.Set(1,2,3) println(set2) }案例：集合操作------添加数据
def main(args: Array[String]): Unit = { var set1 = Set(1,2,3,"aa")//不可变集合一般没有add这种方法 set1.+=(5) set1+=6 println(set1) //Set(5, 1, 6, 2, 3, aa) var set2 = mutable.Set(1,2,3,"aa")//可变 set2.add(5) set2.+=(6) set2+=8 println(set2) //Set(aa, 1, 5, 2, 6, 3, 8) }案例：集合操作------删除数据
def main(args: Array[String]): Unit = { var set1 = Set(1,2,3,"aa") val set:Set[Any]=set1.drop(2) println(set) //Set(3, aa) var set2 = mutable.Set(1,2,3,"aa") set2.remove("aa") set2-=(3) println(set2) //Set(1, 2) }元组可以理解为一个容器、这个容器可以存放不同的数据类型、可以承载很多元素数据、对数据没有过多的约束。
案例一：元组的基本使用
def main(args: Array[String]): Unit = { //tuple把无关的数据当成一个整体使用,构建元组最多22个值，但可以放list增加数据量 val tuple1:Tuple4[String,Int,String,Boolean] = ("lizi",30,"xianggang",true) val tuple2:(String,Int,String,Boolean) = ("lizi",30,"xianggang",true) val tuple3:Tuple3[String,Int,String] = ("lizi",30,"xianggang") //访问元素 println(tuple3._1) //lizi println(tuple3._2) //30 //遍历 for(elem<-tuple3.productIterator){ println(elem) //lizi 30 xianggang } }案例：scala：可变：无序 | 不可变：有序
def main(args: Array[String]): Unit = { //有序 var map1 = Map("jiangjingwen"->40,"zhangting"->20,"linruiyang"->30) println(map1) //Map(jiangjingwen -> 40, zhangting -> 20, linruiyang -> 30) //无序 var map2 = mutable.Map("jiangjingwen"->40,"zhangting"->20,"linruiyang"->30) println(map2) //Map(linruiyang -> 30, jiangjingwen -> 40, zhangting -> 20) } def main(args: Array[String]): Unit = { var map:mutable.Map[String,Int] = mutable.Map(("A",1),("B",2),("C",3),("D",4)) println(map("B")) //2 //println(map("E")) //java里访问不存在的key会返回null，scala里访问不存在的key会报错 //mutable.Map[String,Int] //构建一个空的map }案例：Map 增删改查
def f2(): Unit ={ var map:mutable.Map[String,Int] = mutable.Map(("A",1),("B",2),("C",3),("D",4)) if (map.contains("E")){ println("执行存在逻辑") }else{ println("执行不存在逻辑") } } def f3(): Unit ={ var map:mutable.Map[String,Int] = mutable.Map(("A",1),("B",2),("C",3),("D",4)) println(map.get("A"))//存在：Some println(map.get("R"))//不存在：None } def f4(): Unit ={ var map:mutable.Map[String,Int] = mutable.Map(("A",1),("B",2),("C",3),("D",4)) println(map.getOrElse("A","默认值"))//如存在返回value值，不存在返回默认值 1 println(map.getOrElse("X","默认值")) //默认值 } def f5(): Unit ={ var map:mutable.Map[String,Int] = mutable.Map(("A",1),("B",2),("C",3),("D",4)) map += ("F"->7) //key不存在增加键值对 Map(D -> 4, A -> 1, C -> 3, F -> 7, B -> 2) println(map) map += ("C"->7) //key存在会覆盖 Map(D -> 4, A -> 1, C -> 7, F -> 7, B -> 2) println(map) } def f6(): Unit ={ var map:mutable.Map[String,Int] = mutable.Map(("A",1),("B",2),("C",3),("D",4)) var map2=map + ("G"->1,"H"->2) //返回的是新的对象 println(map) //Map(D -> 4, A -> 1, C -> 3, B -> 2) println(map2) //Map(D -> 4, G -> 1, A -> 1, C -> 3, H -> 2, B -> 2) map += ("GG"->1,"HH"->2) println(map) //Map(D -> 4, GG -> 1, A -> 1, C -> 3, HH -> 2, B -> 2) } def f7(): Unit ={ var map:mutable.Map[String,Int] = mutable.Map(("A",1),("B",2),("C",3),("D",4)) map -= ("A","B") println(map) //Map(D -> 4, C -> 3) } def f8(): Unit ={ var map:mutable.Map[String,Int] = mutable.Map(("A",1),("B",2),("C",3),("D",4)) //map.foreach(print) for(v<-map){ //java编程套路 println(v+" ") } for((k,v)<-map){ println(k+" "+v) } for (v<-map.keys){ map.values } }集合基本方法
var list = List(1,2,3,4) //求和 println("sum = "+list.sum) //求最大值 println("max = "+list.max) //求最小值 println("min = "+list.min) //求乘积 println("product = "+list.product) //反转 println("reverse = "+list.reverse)1.了解每个高阶函数功能
补充：确定的内容底层封装了（封装：什么内容需要底层实现，什么内容提交给用户实现），底层不确定的（行为参数化）
2.每个高级函数变化的东西是什么（需要用户层给高阶函数传递什么规则，才能让当前的高阶函数正常的执行）
高阶函数需要的函数（规则）----》输入的一般是当前集合的每个元素，但是返回值要特殊记忆一下
def f2(): Unit ={ var list = List(1,2,3,4) val inttoints:Map[Int,List[Int]] = list.groupBy(t=>t) inttoints.foreach(t=>print(t._1+"--"+t._2+":")) //2--List(2):4--List(4):1--List(1):3--List(3): }按首字母分组：
def f2(): Unit ={ var list:List[String] = List("11","12","33","34") val chartostr:Map[Char,List[String]] = list.groupBy(e=>e.charAt(0)) val strtostr:Map[String,List[String]] = list.groupBy(e=>e.substring(0,1)) chartostr.foreach(t=>print(t._1+"--"+t._2))//1--List(11, 12)3--List(33, 34) strtostr.foreach(t=>print(t._1+"--"+t._2))//1--List(11, 12)3--List(33, 34) }按奇偶数分组
def f2(): Unit ={ var list:List[Int] = List(1,2,3,4) val booleantoInT:Map[Boolean,List[Int]]=list.groupBy(i=>i%2==0) booleantoInT.foreach(t=>print(t._1+"--"+t._2)) //false--List(1, 3)true--List(2, 4) }sortWith高阶函数（指定规则排序）：
def f2(): Unit ={ var list:List[Int] = List(5,6,1,2,3,4) //输入什么就按照什么排序 var ints:List[Int] = list.sortBy(x=>x) println(ints.mkString("|"))//1|2|3|4|5|6 println(ints.reverse.mkString("|"))//6|5|4|3|2|1 //列表排序的：需要传递函数，输入列表中两个数值然后比较规则 //输入的形参的两个值，左边小于右边是升序，左边大于右边是降序 println(list.sortWith((x,y)=>x<y).mkString(","))//1,2,3,4,5,6 //首字母排序 var list1:List[String] = List("11","32","23","24") println(list1.sortWith((x,y)=>x.charAt(0)<y.charAt(0)).mkString(","))//11,23,24,32 //查看中间过程 list1.sortWith((x,y)=>{ print(x+" "+y) x.charAt(0)<y.charAt(0) }) //list迭代 for(elem<-list.iterator){ println(elem)//11322324 } }简易版本wordcount：
def f2(): Unit ={ var list:List[Int] = List(1,2,3,4,4) var tuples:List[(Int,Int)] = list.map(x=>(x,1)) //(1,1)|(2,1)|(3,1)|(4,1)|(4,1) println(tuples.mkString("|")) val intTotuples: Map[Int, List[(Int, Int)]] = tuples.groupBy(x=>x._1) println(intTotuples.mkString("|")) //2 -> List((2,1))|4 -> List((4,1), (4,1))|1 -> List((1,1))|3 -> List((3,1)) //统计次数 val intoint: Map[Int, Int]= intTotuples.map(t=>(t._1,t._2.size)) println(intoint.mkString("|"))//2 -> 1|4 -> 2|1 -> 1|3 -> 1 }单词出现次数最多的前3
def f2(): Unit ={ var wordList = List("hello","xuchun","hello","hello","jinboran", "sunyun","nini","jinboran","linyun","zhaoliyin","nini") //按单词分组 val groupbyRDD: Map[String, List[String]] = wordList.groupBy(word=>word) //单词计数 val mapRDD: Map[String, Int] = groupbyRDD.map(t=>(t._1,t._2.size)) println(mapRDD.mkString("|")) val sortRDD:List[(String, Int)] = mapRDD.toList.sortWith((x,y)=>x._2>y._2) println(sortRDD.mkString("|")) val result: List[(String, Int)] = sortRDD.take(3) println(result.mkString("|")) }flatmap / fliter / zip 等函数的使用
def f1(): Unit ={ //flatmap map关系 var wordlist: List[String] = List("hello guanx","hello guant","hello guanz") //扁平化（数组里的值作为泛型） val faltMap: List[String] = wordlist.flatMap(x=>x.split(" ")) val groupbyRDD: Map[String, List[String]] =faltMap.groupBy(word=>word) groupbyRDD.map(t=>(t._1,t._2.size)) // println(faltMap.mkString("|")) //hello|guanx|hello|guant|hello|guanz // val str: List[Array[String]] = wordlist.map(x=>x.split(" ")) // println(str.mkString("|")) //[Ljava.lang.String;@880ec60|[Ljava.lang.String;@3f3afe78|[Ljava.lang.String;@7f63425a } def f3(): Unit ={ val list = List(1,2,3,4) val filterRDD: List[Int] = list.filter(x => false) filterRDD.foreach(t=>print(t))//没有输出 val filterRDD1: List[Int] = list.filter(x => true) filterRDD1.foreach(t=>print(t))//1234 } def f4(): Unit ={ val list1 = List(1, 2, 3) val list2 = List(4, 5, 6,7) val tuple: List[(Int,Int)]=list1.zip(list2)//对位匹配 print(tuple.mkString("|")) //(1,4)|(2,5)|(3,6) } def f5(): Unit ={ val list1 = List(1, 2, 3) val list2 = List(1, 2, 4) val ints: List[Int] = list1.union(list2) //合并 val ints1: List[Int] = list1.intersect(list2) //交集 val ints2: List[Int] = list1.diff(list2)//差集 print(ints.mkString("|"))//1|2|3|1|2|4 print(ints1.mkString("|"))//1|2 print(ints2.mkString("|"))//3 }WordCount加强版：
def f6(): Unit ={ //hello 14 world 7 var linelist: List[(String, Int)] = List(("hello scala hello world",4), ("hello world",3),("hello hadoop",2),("hello hbase",1)) val flatmapRDD: List[(String,Int)] = linelist.flatMap(t=>{ var line:String = t._1 //"hello scala hello world" val word: Array[String] = line.split(" ") //"hello" "scala" "hello" "world" val mapRDD: Array[(String, Int)] = word.map(w=>(w,t._2)) //("hello",4),("scala",4).... mapRDD }) val groupRDD: Map[String, List[(String, Int)]] = flatmapRDD.groupBy(t=>t._1) val finalRDD: Map[String, Int] = groupRDD.map(t=>{ val countlist: List[Int] = t._2.map(tt => tt._2)//List(4,3) (t._1,countlist.sum) }) finalRDD.foreach(println) }输出： (world,7) (hadoop,2) (scala,4) (hello,14) (hbase,1)
