scala

scalac编译器将把源文件编译成java的class文件的，即在JVM上运行的字节码的
优雅API 开发整合的kafka，Spark

 object   helloWorld{   def  main(args:Array[String]){         println("hello  World")}}scalac  helloworld.scalascala  helloworld###拓展：scalac是如何指定环境变量的ClassPath，如果修改了spark的某个代码的话，代码依赖于spark源码的其他的一些东西的，单单编译某个类的话是编译不过的，必须要把ClassPath加进来才行的，修改spark源码中的一行代码整个编译台痛苦了，用scalac把那个类编译一下的，编译出来的class文件放在src里面就可以了， 值和变量的 val一旦初始化了就不可以改变了   error  reassignment  to  val var 类型推导 常用基本数据类型： Byte/char/Short/Int/Long/Float/Double/Boolean/String val  money:Float=4.4f val  i=10.asInstanceOf[Double] i:Double=10.0 asInstanceOf是用于强制类型转换的 isInstanceOf[Int]是用于判断是不是某种类型的 4.4.isInstanceOf[Int] 4.4.isInstanceOf[Double]lazy特性：当真正需要的时候才会去计算的lazy  var  a=1a:Int=<lazy>a第一次使用该变量的时候才会真正的去计算的，适用于IO的层面的额import  scala.io.Source._lazy  val logs=fromFile("/home/hadoop").mkString()mkString用于转化成字符串的println(logs)lazy的过程即使是有错误的也不会报错的额，只有等到计算的时候才会报错的额，tab键解决下拉问题的     函数方法：def  function_name(x:Int,y:Int):Int={     //括号内的叫做方法体的      return  ""     }def   add(x:Int,y:Int):Int={       x+y}def  four()=1+3def  sayHello(){  println("hello:")}val  x=1if(x>0) true  else false    循环表达式 to range until1  to   101.to(10)Range(1,10)  左闭右开的Range(1,10,0)死循环的，没有出口的 step  cannot  be 0 源码中的错误信息的，报错的时候一定要跟进来源码中的额，1.until(10)def   until(end:Int):Range=Range(self,end)var(num,sum)=(100,0)while(num>0){  sum=sum+num  num=num-1}Array("hadoop","hive","HBase","Spaerk").foreach(element=>println(element+“ ”))for(i<- 1  to  10){println(i)}for(i<- 1  to   10  if  i%2==0){println(i)}def  sayName(name:String="zhangsan"):Unit={    println(name)}def  sayHello():Unit={  println("hello")}当调用无参的方法时候，可以默认不写括号的：def  loadConf(conf:String="spark-default.conf"):Unit={     println(conf);}命名参数def speed(distance:Float,time:Float):Float=distance/time;println(speed(100,25))println(speed(distance=100,time=25))println(speed(time=25,distance=100)) 方法调用的时候可以根据方法的名称来指定的，就无所谓顺序了变长参数def  sum(nums:Int*)={   var results=0   for(num<- nums){    result+num}   result}sum(1,2,3,4,5)sum(1 to  5:_*)def printCourses(course:String*)={ course.foreach(ele=>println(ele))}printCourses("hadoop","hive","hbase","spark") 打印数组里面的东西： val array=Array("hadoop","hive","hbase","spark")  printCourses(array:_*) 快学scala http://twitter.github.io/scala_school/zh_cn

面向对象编程OOP
封装：属性，方法
继承:父子Override
多态：父类的引用指向子类的对象的
Code->Reformat code
类 属性 方法
class Person{
var name:String=””
var name:String=_ 高级一点的占位符的
val age:Int=10
var d:Double=_ 本地变量初始化的
var i:Int=_
var s:String=_ null
var info=_不知道怎么推导的，一定要加上类型的
var info:String=_

private[this] val gender=”male” //用private[this]修饰的变量，外部是不可以使用的，private[this]可以修饰变量也可以修饰方法的
def printInfo():Unit={
println(“gender “+gender)
}
Spark1.x中的Logging
Spark2.x中的Logging

def eat():String={
name+”eat……”
}
def watchFootball(teamName:String):String={
name+” is watching match of “+teamName
}
}

object People{
//代码的入口点的 object的
def main(args:Array[String]){
val people=new People
people.name=”Messi”
println(people.name+ “,”+peopel.age)
println(people.eat())
println(people.watchFootball(“AC”))

}

}

class ConstructorDemo{}class  Person(val  name:String,val  age:Int){     println("Person  Constructor  enter......")      val school="ustc"      var  gender:String=_      def  this(name:String,age:Int,gender:String){      //this修饰的叫做附属构造器的      每一个附属构造器的第一行必须调用已经存在的主构造器或者其他的附属构造器的  否则Wrong  top   statement  declartion           this(name,age)           this.gender=gender}      println("Person   Constructor   leave......")}object  ConstructorDemo{   def  main(args:Array[String]){    val  person=new Person("huhu",20)    println(person.name)    val  person2=new Person("huhuhu",20,"female")    println(person2.name+","+person2.age+","+person2.gender)}}

class   ExtendsDemo{}class  Student(name:String,age:Int,major:String)   extends  Person(name,age){  println("Student  Constructor  enter....") override  def   toString()="Student  toString" override  val school="peking" 子类重写父类的方法或者是属性的时候一定要使用override修饰的 SparkEnv的源码：  println("Student   Constructor  leave.....")}object ExtendsDemo{  def  main(args:Array[String]){    val student=new Student("huhuhu",21,"bigdata")    println(student.toString)    println(student.school)}}

class  AbstractDemo{}abstract  class  Person2{抽象类中的一个或者多个方法是没有完整实现的，只有定义的，没有方法的使用abstract修饰类  def  speark  val name:String  val age:Int}class  Student2   extends  Person2{    def  speark():Unit={          println("speark....")   } val name="zhangsan"     val  age=20}object AbstractDemo{  def  main(args:Array[String]){        val  s=new Student2        println(s.age+s.name)         s.speark()}}abstract  class  Job DayJob  extends  Job HourJob  extends  Job MinuteJob   extends  Job

class修饰的和object修饰的叫做伴生对象的class  ObjectDemo{   var  count=0   def    printInfo():Unit={      println(count)}def  apply()={   println("class   apply  enter .......")}def   incr={   count=count+1}}object  ObjectDemo{   println("object  enter .......")   def  apply()={   //apply方法是伴生对象中一个非常重要的方法   //通常在伴生对象的apply方法中，实现伴生类的构造功能   //在创建伴生对象的时候，通常是不使用new的，而是object（）来进行调用new的，底层是隐式调用apply方法完成构造的      println("object  apply  enter........")      new  ObjectDemo}  var  count=0 def  incr={   count=count+1}  println("object  leave........")}object   AppDemo{     def  main(args:Array[String]){            val  a =new ObjectDemo()     // a放在栈区的            println(a)            println(ObjectDemo())    类名的（）===》调用的是Object中的apply方法的           a()  //对象的（）===》调用的是Class中的apply方法的println(a)    //  new出来的都是地址的val   b=ObjectDemo()    // 类名()====》调用的是Object中的apply的方法的// 对象()======>调用的是class 中的apply的方法的println(b.incr)//  new出来的Class等于object的构造器的//  new  class=object()      for(i<-  1  to   10){         ObjectDemo.incr             //class声明的一定要new出来的，但是object可以直接使用名字的         val  demo=new ObjectDemo()   //class是互不相干的类的，        demo.incr        println(demo.count+"=====")}             println(demo.count)       println(ObjectDemo.count)     //object是单例的对象，只有一个实例的，可以操作的,是同一个Object的对象的，同一个对象的}}

object  CaseClass{      def main(args:Array[String]){         Dog("wangcai")}  }case  class   Dog(name:String)trait    Logging   实现类是Log4j的作业：trait对应于java中的interface

val  a=new  Array[String](5)val  a=new   Array[Int](5)val  a=Array("aa","bb"，"cc")val  c=Array(2,3,4,5,6,7,8,9,10)c.sum    c.min     c.max      c.mkString   c.mkString(",")      c.mkString(" and  ")  分隔符c.mkString("<","，"，“>”)测试的情况下可以使用的Array定长数组         scala.collection.immutableArrayBuffer变长数组   scala.collection.mutableimport  scala.collection.mutable.ArrayBufferval  c=ArrayBuffer[String]()val c =ArrayBuffer[Int]()+=     ++=   insertc+=1  c+=2    c+=(3,4,5,8)c++=Array(6,7,8)   加数组的话，用++=   加普通的数用+=c.insert(0,0)在第0的位置放置一个0的，c.remove(1)c.remove(0,3) 从第0个位置开始移掉3个数的c.trimEnd(2)从后面去掉2个数的c.toArray   将ArrayBuffer变长数组变成定长数组的c.sum         c.max                c.minfor(ele <-  c)println(ele)

List面试的时候:ArrayList  Vector    LinkedList    HashMap的底层实现的，重复不重复，必然引出equals和hashCode的方法的Nil  是一种List的val  l=List(1,2,3,4,5)底层中调用的是apply的方法的l.headl.tailval  l2=1::Nil    ::是将head和tail加在一起的构成了List的val  l3=2::l2  head在前的，tail在后的 val  l4=1::2::3::Nilval  l5=scala.collection.mutable.ListBuffer[Int]()l5+=2l5+=(3,4,5)l5++=List(6,7,8)l5+=2l5-=2l5-=(2,4)l5--=List(5,6,7)l5.toList    将ListBuffer转成List的l5.toArray for(ele  <-  l5){println(ele)}l5.isEmptyl5.headl5.taill5.tail.head作业：Set测试的

 object MapApp{   def  main(args:Array[String]){      val  a=Map("huhuhu"->21,"feiji"->44)       a("huhuhu")       a("feiji")for((key,value)<- a){  println(key+":"+value)}for(key<- a.keySet){    println(key+":"+a.getOrElse(key,0))}for((key,_)<- a){   println(key+":"+a.getOrElse(key,0))}//  Array/List/Map是不可变的//  ArrayBuffer/ListBufferval  b=scala.collection.mutable.Map("huhuhu"->21,"feiji"->44)b("feiji")=444b("chunge")    NoSuchException:key  not foundb+=("chunge"->20,"tangtang"->18)b("qianxi")=24b-="feiji"val  c =scala.collection.mutable.HashMap[String,Int]()c["chunge"]=3println(c)c.get("chunge")c.getOrElse("huhuhu",4)    //取不到的key给一个默认的值getOrElse("主url"，“副url”)Option=None+Some 查看子类 ctrl+Tabstract  class Optioncase  class Somecase  object None}}

object  OptionApp{ def  main(args:Array[String]){    val  m=Map(1->2)    println(m(1))    println(m.get(1)+":"+m.get(1).get())    println(m.get(2)+":"+m.get(2).getOrElse(0))  Tuple是用（）括起来的，  val  a=(1,2,3,4,5,"huhuhu")  a._1    a._2    a._3   a._4   (hello,3)   (world,2)   map(x=>(x._2,x._1))   "a"->"b"SparkEnv    TaskScheduler   SparkContext    createTaskScheduler作业：使用scala读取Mysql数据表的普通的方式数据库连接池完成的}}

模式匹配Java：Switch  case值Scala：match  case值/类型/集合match  {  case  =>code1  case  =>code2  case  _=>code3}object  MatchApp{  def  main(args:Array[String]){      val  array=Array("Akiho  Yoshizawa","YuiHatano","Aoi  Sola) var name=Array(Random.nextInt(array.length))name  match {case   "Akiho  Yoshizawa" =>println("季老师")case  "YuiHatano"=>println("laoshi")case _=>println("什么")}def  judgeGrade(grade:String):Unit={  grade match  {       case  "A"=>println("Excellent........")       case  "B"=>println("good")       case   "C"=>println("Just  so  so  ")       case   _  =>println("Worse")  }def judgeGrade(name:String,grade:String):Unit={    grade  match  {         case  "A" => println("Excellent")         case  "B"=>println("Good.....")         case   "C"=>println("Just  soso ....")         case  _ if  name=="qianxi" =>println("niubiable")         case _ =>println("Worse")}}def  greeting(array:Array[String]):Unit={  array  match  {    case    Array("zhangsan")=>println("Hi:zhangsan")    case    Array(x,y)=>println("HI:"+x+","+y)    case     Array("zhangsan",_*)=>println("Hi:zhangsan  and  others")    case  _=>println("Hi  everyone")}}//数组集合的匹配的def  greeting(array:List[String]):Unit={  array  match  {       case  "zhangsan"::Nil =>println("Hi::zhangsan")       case   x::y::Nil =>println("Hi:"+x+","+y)       case   "zhangsan"::tail=>println("HI :zhangsna  and  others")       case  _=>println("Hi  everyone")}}数值的类型的匹配的Any是最顶层的类型的def  matchType(obj:Any):Unit={   obj  match  {    case  x:Int=>println("Int")    case  s:String=>println("String")    case   m:Map[_,_]=>m.foreach(println)     case  _=>println("other  type")}}//  Map("name"->"zhangsan")//匹配的常用场景在于异常的处理try{ val i=1/0}catch{  case e:ArithmeticException =>throw  new  RuntimeException("除数不为0的")  case e:Exception=>println(e.getMessage())}finally{    //finally一定是会被执行的，常用于资源的释放的    // IO的流关掉的，连接关掉的}def  judgeIdentify(human:Human):Unit={  human  match  {        case  CTO(name,floor)=>println("CTO name  is "+name+",") case   Employee(name,floor)=>println("Employee  name is "+name +",floor  is"+floor)  case  _=>println("others  first  to  register")   }}val  inputs=Array(CheckTimeOutTask,HeartBeat(1000),SubmitTask("001","task-001"))inputs(Random.nextInt(inputs.length))  match {     case  SubmitTask(id,name)=>println("SubmitTask:"+id+",name:"+name)case  HearBeat(time)=>println("SubmitTask:"+time)case  CheckTimeOutTask(id)=>println("CheckTimeOutTask") case  _ =>println("other ")}val grades=Map("zhangsan"->"A","lisi"->"B","huhuhu"->"C")def  getGrade(name:String):Unit={   val  grade=grades.get(name)   grade   match  {      case  Some(grade)=>println("grade is"+grade)  优雅不      case  None=>println("Sorry.....")          //Some是有get的方法的，}}}}}

class  Humancase class  CTO(name:String,floor:String)  extends  Humancase  class  Employee(name:String,floor:String) extends Humancase  class  Other(name:String,floor:String) extends Humancase  class  SubmitTask(id:String,name:String)case  class  HeartBeat(time:Long)case  class  CheckTimeOutTask(id:String)

object StringApp{    def  main(args:Array[String]){      val  name="KaKa"      println("name  is"+name)      //String  Interpolation      println(s"name  is  $name")  小写的s加$      val team="Ac  Milan"      println(s"name is  $name,welcome  to    $team")val  b="""|这是一个多行字符串的|hello|ruozedata""".stripMarginprintln(b)}}

object OtherApp{   def  main(args:Array[String]){      val sayHelloFunc=sayHello  _   有参函数必须要带上括号或者是下划线的额，将函数赋值给变量/值      sayHelloFunc("ruozedata")val sayHelloFunc=(name:String)=>println(s"hello,$name")匿名函数：(x:Int)=>x+1   (参数名:参数类型)=>函数体x:Int=>x+1     不行的{x:Int=>x+1}    行的没有{},()是必须有{}，()是可以去掉的def  add=(x:Int,y:Int)=>x+ydef  add(x:Int,y:Int){x+y}}def sayHello(name:String):Unit={  println(s"Hello :$name")}}

 object SuperFunctionApp{   def  main(args:Array[String]){     val l=List(1,2,3,4,5,6,7,8,9)     l.map((x:Int)=>x*2)     l.map((x)=>x*2)     l.map(_*2).filter(_>8)     l.reduce(_+_)  相邻的俩个元素相加的     l.reduce(_+_)     l.reduceLeft(_+_)     l.reduceLeft(_-_)  不理解的要把中间的过程打印出来的     l.reduceLeft((a,b)=>{      println(a+","+b+":"+(a-b))      a-b})  l.reduceRight(a-b)  l.fold  l.foldLeft()  l.foldRight()  l.sum()  l.max()  l.min()  l.count(_>3)  logs.flatMap(_.split("\t")).map((_,1))       val  a=List(1,2,3,4,5) val  b=List("A","B","C","D","E") a.zip(b)val  f=List(List(1,2),List(3,4),List(5,6))f.flattenf.flatMap(_.map(_*2))map:是对每个元素进行某个操作的flatMap：先压扁到一起的，在做map操作的f.map(_.map(_*2))val  txt1=scala.io.Source.fromFile("/home/hadoop/data/data.txt").mkStringval  txt2=scala.io.Source.fromFile("/home/hadoop/data/x.txt").mkStringval  line=List(txt1,txt2)val  line=List(txt1)line.flatMap(_.split("\t")).map((_,1)).reduce(_+_)line.flatMap(_.split("\t")).map((_,1)).groupBy(_._1).reduce(_+_)line.flatMap(_.split("\t")).map((_,1)).map(_._2).reduce(_+_)Spark:map    filter    reduceScala:map    filter     reduceSpark和Scala是无缝对接的，还是在开发单机的Scala程序，但是能够完成分布式的计算功能 }}

偏函数：PartialFunction[A,B]A:入参类型B：出参类型常用于输入模式匹配的object  PartialFunctionApp{  def  main(args:Array[String]){}  def  sayChineseName2:PartialFunction[String,String]={        case  "Akihoh  Yoshizawa"=>"jilaoshi"        case   "YuiHatano"=>"laoshi"        case    _=>"sjlhaso"  }  //PartialFunction中输入输出的参数，不能有println的打印的  def  sayChineseName(name:String)={  name match  {       case  "Akiho Yoshizawa"=>println("季老师")       case  "YuiHatano"=>println("老四")       case  _=>println("真不知道说什么")}   }}

object  FileApp{   def  main(args:Array[String]){     val  file=Source.fromFile("D://file.txt")     def  readLine():Unit={       for(line<-file.getLines()){            println(line)}}   readLine()def  readChar():Unit={     for(c<- file){         println(c)}}readChar() def   readNet():Unit={    val  f=Source.fromURL("https://www.baidu.com")     for(line<-f.getLines()){      println(line)}}readNet()//Scala操作文件，作业是处理xml文件的读和写，attribute//<xml>      <ruoze>      <book  id="">        <author  value="" />        <title   value="" />       </book>       </ruoze> </xml>}}

隐式转换：implicit目的是偷偷摸摸/隐式/悄无声息的对方法进行了增强的Java中如何对一个已经存在的类添加一个新方法，或者对方法进行增强的，代理模式的ProxySpring   interface   class  CGLib  给类添加一个功能或者是一个方法的object ImplicitApp{  def  main(args:Array[String]){}   //定义隐式转换函数即可的，Scala会自动使用隐式转换函数的   implicit  def  man2superman(man:Man):SuperMan=   new SuperMan(man.name)val  man=new Man("huhuhu")man.fly()给File类中增加一个read的方法的implicit  def  file2RichFile(file:File)=new RichFile(file)val  file=new File("d:/file.txt")val content=file.read()println(content)}File中是没有read的方法的，通过隐式转换，将File类进行增强的，使的有read的方法的class  RichFile(val file:File){   def  read()=Source.fromFile(file.getPath).mkString}class  Man(val  name:String)class  SuperMan(val name:String){  def  fly():Unit={     println(s"Superman:$name   fly.....")}}

object  ImplicitAspect{implicit  def  file2RichFile(file:File)=new RichFile(file)所有的隐式转换的方法进行封装起来的所有的隐式转换都放到这里面进行的}class  RichFile(val file:File){   def  read()=Source.fromFile(file.getPath).mkString}

object  ImplicitApp{  def main(args:Array[String]){     import  ImplicitAspect.file2RichFile     val  file=new File("d:/file.txt")     val  content=file.read()     println(content)    隐式转换的核心是定义隐式转换函数的，implicit  conversion  function的}}

隐式参数的object  ImplicitParams{   implicit  val test="test"  def  main(args:Array[String]){    def  testParams(implicit  name:String):Unit={     println(name+"......")}testParams("huhuhu")implicit  val name="implicit_name"  用了一系列的隐式转换的testParamsimplicit   val s1="s1"implicit   val  s2="s2"testParams//ambiguous  implicit  values}}

object ImplicitClassApp{   def  main(args:Array[String]){  // 隐式类是对类进行增强的，对类添加implicit的，                    //隐式类，对Int增强了，添加了add的方法的      implicit  class  Calculator(x:Int){        def  add(a:Int)=a+x   }println(2.add(3))println("2".add(3))//implicit  modifier  cannot  be used  for  top-level  //    objects}}