未来之歌

package com.yl.scalaobject ListTest { def main(args: Array[String]){ //ListBuffer实战 import scala.collection.mutable.ListBuffer val listBuffer = new ListBuffer[Int] listBuffer += 1

package com.yl.Scalapackage spark{ package navigation{ private[spark] class Navigator{ //private[spark]表示可见度在spark内部 protected[navigation] def useStarChart(){} //protected

实战代码示例：package com.yl.Scalaimport scala.io.Sourceimport java.io.PrintWriterimport java.io.Fileobject ScalaFileTest { def main(args: Array[String]){ //读取文件 val file = Source.fromFile("C:\\Les

Scala类之单例对象、伴生对象、Apply方法单例对象：Scala不能定义静态成员，而是代之定义单例对象(singleton object)。 以object关键字定义，对象定义了某个类的单个实例。伴生对象：当单例对象与某个类共享同一个名称时，它就被称为是这个类的伴生对象(companion object)。 这个类可以访问伴生对象的所有成员。代码示例：class University{

package com.yl.scalaobject Test { def main(args : Array[String]){ val data = List(1,2,3,4,5) var sum = 0 data.foreach(sum += _) println("sum:" + sum) def addFunction(more: Int) = (x

package com.yl.Scalaobject ScalaTest { def main(args: Array[String]){ val aList = List(1, 3, 5, 7, 9) aList.foreach { x => print(x) } println aList.foreach { print(_)} //“_”不是单个参数的占位符，

1、Scala模式匹配入门package com.yl.Scalaobject ScalaTest { def main(args: Array[String]){ val number = 3 number match{ //match关键字 case 1 => println("It is 1.")

package com.yl.Scalaobject Curry { def main(args: Array[String]){ //curry化的函数被应用了多个参数列表，而不是仅仅一个。 //普通函数定义 def mutiple(x : Int, y : Int) = x * y println("mutiple(2, 6) = " + mutip

简单来说，Scala的case class就是在普通的类定义前加case关键字，然后你可以对这些类来模式匹配。 case class带来的最大的好处是它们支持模式匹配。简单的case class 模式匹配代码示例：package com.yl.Scalaabstract class Person //定义抽象类Personcase class Student(age: Int) extends

package com.yl.Scalaobject ListTest { def main(args: Array[String]){ //声明方式1 val bigData = List("Hadoop", "Spark") val data = List(1,2,3) //声明方式2 val bigData2 = "Hadoop" :: ("Spark

package com.yl.Scalaobject ListTest { def main(args : Array[String]){ //List连接案例，符号“:::”完成 val cList = List(1,2,3,4) ::: List(5,6) ::: List(7,8) println(cList) println(cList.length) //

package com.yl.Scalaobject ListMap { def main(args : Array[String]){ //map操作 println(List(1,2,3,4,6) map (_ + 1)) //各元素加1，生成新列表 List(2, 3, 4, 5, 7) val data = List("Scala", "Hadoop", "Spark

Scala 继承代码示例：class Father(val name: String, val age: Int){ println("Father is here.") val school = "CSU" def sleepTime = "8 hours" //重定义已有方法，加上override override def toString = "Father."}//子类Son

//Find the last but one element of a list.//List列表中找出倒数第二个元素package com.yl.problemobject Pro02 { //01、内置方法解决 def method01[A](ls: List[A]): A = { if (ls.isEmpty) throw new NoSuchElementExceptio

Scala多重继承Scala多重继承实战代码示例：class Human{ println("Human")}//定义teacher特性trait TTeacher extends Human{ println("TTeacher") def teach}//定义piano player特性trait PianoPlayer extends Human{ println("P

Scala 数组实用操作实战import scala.collextion.mutable.ArrayBufferobject ArrayTest{ def main(args: Array[String]): Unit = {//-----------------------1、Scala数组基本操作------------------------- val nums1 = ne

package com.yl.Scalaobject sortList { def main(args: Array[String]){ def combineSort[T] (less: (T, T) => Boolean) (input: List[T]): List[T] = { /** * @param xList 要合并的有序列表

package com.yl.scalaimport scala.collection.mutableimport scala.collection.mutable.TreeSetimport scala.collection.immutable.TreeMapobject MapSet { def main(args: Array[String]){ //Set实战 val

package com.yl.scalaabstract class Stack[A]{ //'A'是Stack类及其子类的类型参数。 def push(x: A): Stack[A] = new NonEmptyStack[A](x, this) def isEmpty: Boolean def top: A def pop: Stack[A]}class Em

1、Scala解释器的使用   下载地址：http://www.scala-lang.org/downloads.   Scala的交互式shell就叫做scala。命令提示符输入scala就行（需配置好Java环境变量）：   以下是cmd内容： Microsoft Windows [版本 6.1.7601] 版权所有 (c) 2009 Microsoft Corpor

1、使用类型参数化数组【Array】Scala使用new实例化对象或类实例。 当在Scala里实例化对象，可以使用值和类型把它参数化：parameterize。 参数化的意思是在你创建实例的时候”设置”它。例如，实例化一个新的java.math.BigInteger并使用值”12345”参数化：val big = new java.math.BigInteger("12345") 一个完整实例：

1、类，字段和方法类的定义及创建对象：class ChecksumAccumulator { ...//类定义里，可以放置字段和方法，这些被笼统地称为成员：member。} 创建ChecksumAccumulator对象：new CheckSumAccumulator 又：class ChecksumAccumulator { var sum = 0} val a

Scala允许用指令式风格编程，但是鼓励采用一种更函数式的风格。学习用函数式风格编程将不仅让你变成更好的Scala程序员，而且还能拓展你的视野并使你变成通常意义上好的程序员。指令式和函数式编程差异： 如果代码包含了任何var变量，那它大概就是指令式的风格。 如果代码根本就没有var--就是说仅仅包含val--那它大概是函数式的风格。 因此向函数式风格推进的一个方式，就是尝试不用任何

Scala函数定义及流程控制：可运行完整代码示例：object ScalaFucBasic { def main(args: Array[String]): Unit = //Unit代表函数返回值为空，即void { println("----函数使用示例----") //分号可要可不要 println("Scala流程控制之dowhile循环:") dowhi

1、Scala的Tuple入门示例程序：object TupleTest { def main(args: Array[String]): Unit = { val triple = (100, "Scala", "Spark", "难免有错") println(triple._1) println(triple._2) println(triple._3)

Scala中for常用实例for(i <- 1 to 3; j <- 1 to 3) print((1000*i + j) + "\t") //结果为：1001 1002 1003 2001 2002 2003 3001 3002 3003for(i <- 1 to 3; j <- 1 to 3 if i

Scala类的属性 和 对象私有字段class Person{ //默认public private var age = 0 //必须赋予初值 def increment() { age += 1 } def current = age //无参数方法可省略“()”}class Student{ //对象私有字段 private[this] v

Map构建不可变Mapval map = Map("book" -> 10, "gun" -> 18, "ipad" -> 1000) for((k ,v) <- map) yield(k, v * 0.9)//res1: scala.collection.immutable.Map[String,Double] = Map(book -> 9.0, gun -> 16.2, ipad -> 9

// Scala：Find the last element of a list.// Scala：找出列表中最后一个元素// 示例:// scala> last(List(1, 1, 2, 3, 5, 8))// res0: Int = 8package com.yl.problemobject Problem01 { def main(args