KongMingJue的博客

package ce.scala.zhong//6import scala.actors.Actorimport scala.actors.Actor._//用case class 或者case object作为消息来传递，有两个原因：//1.参数是val类型的，在传输过程中不会改变。2.接收消息时，模式匹配+case class，极大简化了代码的处理（比如下面的name和age可以

def main(args: Array[String]): Unit = { println((1 to 100).foldLeft(0)(_ + _)) //初始值为0，从1一直加到100 println(( 0 /: (1 to 100) ) (_ + _)) println((1 to 5).foldRight(100) (_ - _)) //初始值为

一、View Bounds代码实战class Pair_NotPerfect[T <% Comparable[T]] (val first : T, val second :T){ def bigger = if(first.compareTo(second) > 0) first else second}object View_Bounds_44 { def main(

一、partition、find、takeWhile、dropWhile实战 println(List(1,2,3,4,5) partition(_ % 2 == 0)) //把List分成两部分，偶数\奇数各一部分 println(List(1,2,3,4,5) find(_ % 2 == 0)) //找出List集合中第一个满足条件的元素，注意是第一个 print

一、对List的map、flatMap实战map：对List所有元素执行一个具体的函数flatMap：对List内部的成员进行map，结果为List，再对这个结果flat合并，产生合并后的集合 println(List(1,2,3,4,5) map(_ + 1)) //相当于map(item => item + 1) val data = List("scala

一、Scala中的类型变量Bounds代码实战//上界class Pair[T <: Comparable[T]] (val first : T, val second : T) { //Comparable[T]是父类 //若对T不做限定，则不确定first这个类型是否有compareTo这个方法。 //Comparable[T]是T的上界，T是Comparable[T]

package ce.scala.ppobject MergedSort { def main(args: Array[String]): Unit = { def mergedsort[T] (less : (T,T) => Boolean) (input : List[T]) : List[T] ={ //less指定元素排序的算法 input是指具体排序的对象

一、List的基本操作实战package ce.scala.ppobject HelloList { def main(args: Array[String]): Unit = { //7 val bigdata = List("Hadoop", "Spark") //调用了其伴生对象的apply() 把鼠标放在bigData上，显示 val bigData:Lis

Spark中链式调用的例子：sc.textFile(“hdfs://...”).flatMap(_.split(“ ”)).map(_, 1).reduceByKey(_ +_).map(x => (x._2, x._1)).sortByKey(false).map(x=> (x._2, x_1)).saveAsTextFile(“hdfs://…")class Anima

一、List的drop、take、splitAt、apply、indices、toString、mkString等实战把两个List组拼起来，列表和列表连接用三个冒号的连接操作符，元素和列表连接用两个冒号的连接操作符 println(List(1,2,3,4) ::: List(5,6,7) ::: List(8,9)) println(List(1,2,3,4) ::: (

一、Option中的sealed关键字解析sealed abstract class Option[+A] extends Product with Serializable {...} //注意这里的sealed关键字final case class Some[+A](x: A) extends Option[A] {...}case object None extends Opt

一、Scala中的泛型类代码实战sealed abstract class List[+A] extends AbstractSeq[A] with LinearSeq[A] with Product

一、List的继承体系分析和源码解读1.List类abstract class List[+A]  ...List是抽象的类，我们平时用List(1,2,3)来构建一个List对象，用的都是其伴生对象的apply方法2.List有两个子类Nil和::这两个子类都实现了其成员方法isEmpty、head、tail //* This class comes with two

一、Set、Map代码实战 import scala.collection.mutable val data = mutable.Set.empty[Int] data ++= List(1,2,3) //追加集合 data += 4 //追加元素 println(data) data --= List(2,3) //减少集合

函数在参数上是逆变的，但在返回值上是协变的。 默认是这样的。一个具体对象从操作结果看，既要求逆变，又要求协变，这是类型本身要保持不变。eg:Array[T] 由于scala数组不支持型变，所以Array[Worker]和Array[Person]不能互相转变。（Worker是Person的子类）若把Array[Worker]赋值给Array[Person]的话，那Array[P

一、Context Bounds代码 实战class Pair_Ordering[T : Ordering] (val first : T, val second : T){ //T是泛型/类型， Ordering是泛型类/泛型接口 def bigger(implicit ordered : Ordering[T]) = { //ordered是隐式值，可以认为我们并没有给bigge

class Outer{ //外部类 ，外部类不能访问内部类private级别的成员 private val x = 10 class Inner{ private val y = x + 10 //但是内部类可以访问外部类的私有成员。因为内部类隐含地持有外部类的实例。 }}object Path_Dependence_52 { def main(args: Arra

程序宏大时java并发编程变得非常复杂，java并发编程的理念是：基于共享数据和加锁java多线程同时访问一个加锁数据时易发生死锁scala的并发编程：actor。与java实现方式完全不同，actor不共享数据，依赖消息传递A传给B消息，B不停看收件箱。B看到邮件后处理。import scala.actors.Actorobject First_Actor e

package ce.scala.actorimport scala.actors.Actor._import scala.actors.Actorobject Actor_Message_67 { def main(args: Array[String]): Unit = { //匿名Actor val actor_Message = actor{ //Actor

package ce.scala.zhongclass Pair_Implicits[T:Ordering](val first:T, val second : T){ def bigger(implicit ordered:Ordering[T]) = { //存在一个隐式值ordered if(ordered.compare(first, second) > 0) firs

package ce.scala.zhongimport scala.io.Sourceimport java.io.Fileobject Context_Helper{ implicit class FileEnhancer(file : File){ //隐式类，只有File或其子类才可匹配 def read = Source.fromFile(file.getPath

隐式对象：implicit object xxxpackage ce.scala.zhongabstract class Template[T]{ //抽象类 T是泛型 def add(x : T, y : T) : T}abstract class SubTemplate[T] extends Template[T]{ def Unit : T}object

隐式砖混的内幕操作规则：1.必须有关键字implicit，可以修饰在类/对象/函数/参数或者变量前2.作用域规则。隐式转换在整个作用域中必须是单一的标志符。相当于id，是唯一的。3.隐式转换内容必须在不存在其他插入转换的前提下才能进行正常的隐式转换。import scala.io.Sourceimport java.io.Fileclass RicherFile(va

隐式转换的目的：增强类库功能在spark或者play框架中，到处可见。增强类库的方式：在Java或者C#中，用工具类或者继承在Scala中，用隐式转换或者隐式参数。import java.io.Fileimport scala.io.Sourceclass RichFile(val file : File){ //RichFile是增强的类。比如1 to 3 1是In

object Implicit_Conversions_with_Implicit_Parameters_61 { def main(args: Array[String]): Unit = { //泛型函数 柯里化 有两个参数列表 def bigger[T](a : T, b : T) (implicit ordered : T => Ordered[T]) =

隐式参数：函数/方法中参数前有implicit关键字//7object Context_Implicits{ implicit val default : String = "Java"}object Param{ //这里有两个参数列表，属于柯里化 def print(content : String)(implicit language : String){

抽象类型：在trait、class、abstract class中，定义的类型是抽象的。package ce.scala.zhongimport scala.io.BufferedSourceimport scala.io.Source//7trait Reader{ //可以对抽象类型进行复杂的类型限制 type In <: java.io.Serial

依赖注入：一个程序是由不同的组件构成，不同组件之间有依赖关系，需要协同工作。比如：Spring框架依赖注入很多时候要使用自身类型package ce.scala.zhong//7trait Logger {def log(msg : String)}trait Auth { auth : Logger => //通过自身类型，可以很好地限定类型和行为

自身类型的第一个用途：class Self { self => //self是this的别名，每个类都有个this指针，指向自己的实例。可以用除了this的其他任何名字。 val tmp = "scala" def foo = self.tmp + this.tmp}object Self_Types_56 {    def main(args: A

中值类型：允许带有2个参数的类型object Infix_Types_55 { def main(args: Array[String]): Unit = { //7 object Log {def >>: (data : String) : Log.type = {println(data); Log}} //<<: 是方法名，返回了Log实例的类型，使其可

A extends B with C with DA必须同时是B、C、D的类型。比如某个类既具有某种功能，又能序列化eg：可以规定List或者Array里的元素， 比如必须实现序列化接口又必须实现某个功能性接口trait Compound_Type1trait Compound_Type2class Compound_Type extends Compound_Type1

结构类型：指一组关于抽象的方法、字段或类型的规格说明，这些抽象方法、字段、类型是我们传进参数或者说要使用相关的对象必须具备的。在javascript或者Ruby中，只要看起来、走起来、叫起来像鸭子，我们就认为它是鸭子。在构建复杂表达式时，不想从类/接口去限制它，这种方式含有动态语言的灵活性和简洁性class Structural{ def open() = prin

eg: List[T] A:父类 B：子类  List[A]是否是List[B]的父类？ 是的话，可以进行型变（协变）协变：和具体类型的继承关系是一致的。比如A是B的父类，List[A]是List[B]的父类逆变：和具体类型的继承关系是相反的。比如A是B的父类，List[B]是List[A]的父类但是在Java中，String是Obejct的子类，List[String]并不是Li

A =:= B //表示A类型等同于B类型   A def main(args: Array[String]): Unit = { def rocky[T](i : T)(implicit ev : T <:< java.io.Serializable) { //传入隐式参数，规定T必须是Serializable的子类型 println("Li

有时候要表达一种类似于集合类型的元素，而元素本身的表示又是case class的实例，这时候就要用到嵌套eg：书店中有很多书，很多书可以构成集合，而书本身用case class表达，集合也用case class表达。这时候就用嵌套。package ce.scala.pp//7abstract class Itemcase class Book(description : S

一、多重继承的trait代码实战class Human { println("Human") }trait TTeacher extends Human { println("TTeacher") def teach}trait PianoPlayer extends Human { println("PianoPlayer") def playPian

trait Logger{ def log(msg : String) //没有花括号，抽象方法。 //在Java中，接口interface只能有抽象方法，但在scala的接口trait中，可以有抽象的方法，也可以有具体的方法。}class ConcreteLogger extends Logger{  override def

一、文件的读取、写入操作代码实战package ce.scala.ppimport scala.io.Sourceobject FileOps_18 { def main(args: Array[String]): Unit = { var file = Source.fromFile("F:\\liyanxia.txt") for(line <

一、Scala类的使用实战class Person{ private var age = 0 def increment() {age += 1} def current() = {age}} def main(args : Array[String]) : Unit = {    val p = new Person    p.increment()    pr

1.包、类、对象、成员访问权限实战package scala.ooppackage spark{ package navigation{ private[spark] class Navigator{ //private[spark]限定了这个类的可见度，可扩展到spark这个包里的所有类和对象（当然也包含其子包里的所有类和对象） protected