莫等闲

scala中一切皆为对象，对象皆有方法--变量val 不可变变量，类似java中的finalvar 可变变量scala> val result=2+10result: Int = 12scala> result=13 --val类型的变量，第二次赋值时出错:8: error: reassignment to val result=13

implicit def function在编写程序的时候，被scala自动地在上下文使用，scala会根据隐式函数的签名,在程序运行时使用隐式转换函数将接收的参数类型对象定义的将自动转换成隐式转换后的对象。package com.lhj.scalaobject Test { def main(args: Array[String]): Unit = { new Per

package com.lhj.scalaobject Test { def main(args: Array[String]): Unit = { getStudentInfo("Spark")(8) getStudentInfo("Spark") --相当于age有一个默认值 } implicit val age = 6 def get

--导入隐式类之后，可以用类中的所有方法package com.lhj.scalaimport java.io.Fileimport scala.io.Sourceobject Test { def main(args: Array[String]): Unit = { import Test1._ --将整个object导进来 printl

package com.lhj.scalaimport java.io.Fileimport scala.io.Sourceobject Test { abstract class A[T] { def add(x:T,y:T):T } abstract class B[T] extends A[T]{ def unit:T }

package com.lhj.scalaimport java.io.Fileimport scala.io.Sourceobject Test { def main(args: Array[String]): Unit = { def bigger[T](a: T,b: T)(implicit c:T => Ordered[T]) = if (a > b)

java--thread:共享全局变量的加锁机制，不可避免造成死锁scala--actor在做分布式的时候一定不要有共享全局的变量，更不能做加锁机制。每个actor都和公司的一个员工一样，都有自己的循环器，每天循环自己的邮箱查看邮件，回复邮件作出应答。！：异步的，给actor发完信息后不会继续等回答，会继续往下执行！？：给actor发完信息后会等对方回答，没有回答就一直等待hu

scala中的case非常强大，既可以匹配值，匹配类型，匹配集合，匹配class，匹配object。--case匹配值scala> def bigData(data: String){ | data match{ | case "Spark" => println("Wow!") | case "Hadoop" => println("Ok"

topN算法基础topN分组topN--基础topN--aaa.txt425971647把这些字符转换成map(x=>(x.toInt,x))，利用int类型的比较进行排序。package com.lhj.wwwimport org.apache.spark.{SparkContext, SparkConf}object Test { def m

柯里化函数一个函数有2个参数，可以转换成2个函数，第一个函数接收第一个参数，第二个函数接收第二个参数。scala> //////////////////////////////scala> def sum(x:Int,y:Int) = x+y ----定义成sum2()两个参数，一个括号sum: (x: Int, y: Int)Intscala> sum(1,2)res17

--函数返回函数scala> def fun1(name1:String) = (name2:String) => println(name1+" "+name2)fun1: (name1: String)String => Unit--等号=左边是函数，右边返回值是匿名函数。函数返回函数scala> val fun1_v = fun1("Spark") --接收name1参数

scala> //-------------array--------------------scala> val arr=new Array[Int](5) --arr的index不可变，值可以变arr: Array[Int] = Array(0, 0, 0, 0, 0)scala> arr(3)res0: Int = 0scala> arr(2)=8sca

scala> import scala.collection.mutable.ArrayBufferimport scala.collection.mutable.ArrayBufferscala> val arrBuffer=ArrayBuffer[Int]()arrBuffer: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuff

scala> scala.util.Sorting.quickSort(arr2)scala> arr2res42: Array[Int] = Array(1, 1, 3, 4, 10, 11, 100)scala> arr2.mkStringres43: String = 11341011100scala> arr2.mkString(",")res44: String = 1

scala> ///////////////////////scala> class Person{ | var varName = "Spark" | private var priName = "GreenPlum" | private[this] var prithisName = "Oracle" | | def get

与类名放在一起的（方法）是默认构造器class SparkContext(config: SparkConf) extends Logging with ExecutorAllocationClient {...def this() = this(new SparkConf())}java中构造方法：class Person(name String,age Int){thi

object：半生对象object中的构造器在第一次调用执行一次，以后调用的话不会多次执行。object会有自己的构造方法，默认是没有参数的构造方法object放一些静态的成员或方法如SparkContext同时有类和object半生类和半生对象放在同一个文件夹中半生对象中有一个apply方法构造类的时候一般不用new Person（）而是不用newclass Perso

scala中变量和函数一视同仁，都是平等地位。变量可以等于函数，函数也可以等于变量。scala> //----------def--------------scala> def f2=printlnf2: Unitscala> def f2=println _f2: () => Unitscala> var f2=printlnf2: Unit = ()scala>

如果一个函数的参数是函数，这个函数就叫高阶函数。高阶函数是java和scala的最大不同点。scala> ////////function//////////////scala> def fun1(name:String){print(name)} --最常见的显式定义行数fun1: (name: String)Unitscala> val fun1_v = fun1 _

scala 实现自定义排序算法--数据aaa.txt：4 13 28 72 34 32 1package com.lhj.wwwclass KeyPair(val first:Int,val second:Int) extends Ordered[KeyPair] with Serializable{ def compare(other: KeyPair): In