class Person{
var name : String = _ //会生成getter和setter方法
val age = 10 //只会生成getter方法
private[this] val gender = "male"
}
object Basic2 {
def main(args: Array[String]): Unit ={
val p = new Person //括号可省略
p.name = "Jack"
println(p.name + ":" + p.age)
}
}
----------------------------------------------------------
类（class）
声明类（一个源文件中可以包含很多类，并且都是public级别）
getter和setter
构造函数（primary constructor & auxiliary constructor）
继承（extends）
重写父类方法（override def）
重写字段（override val，override var）
实例3
class Basic2{
}
class Person{
var name : String = _ //会生成getter和setter方法
val age = 10 //只会生成getter方法
private[this] val gender = "male"
}
object Basic2 {
def main(args: Array[String]): Unit ={
val p = new Person //括号可省略
p.name = "Jack"
println(p.name + ":" + p.age)
}
}
实例4
class Basic2{
}
//1、主构造器直接跟在类名后面，主构造器中的参数，最后会被编译成字段
//2、主构造器执行的时候，会执行类中的所有语句
//3、假设参数声明时不带val和var，那么相当于private(this)!!!
class Person(var name:String,val age:Int){
/* var name : String = _ //会生成getter和setter方法
val age = 10 //只会生成getter方法
private[this] val gender = "male"*/
println("this is the primary constructor!")
}
object Basic2 {
def main(args: Array[String]): Unit ={
/* val p = new Person
p.name = "Jack"
println(p.name + ":" + p.age)*/
val p = new Person("Jack",20)
println(p.name + ":" + p.age)
}
}
--------------------------------------------------------------------
抽象类(abstract class)
类的一个或者多个方法没有没完整的定义
声明抽象方法不需要加abstract关键字，只需要不写方法体
子类重写父类的抽象方法时不需要加override
父类可以声明抽象字段（没有初始值的字段）
子类重写父类的抽象字段时不需要加override
class Basic3{
}
abstract class Person1{
def speak
val name : String
var age : Int
}
abstract Student1 extends Persion1{
def speak{
print("speak!!!")
}
val name = "AAA"
var age = 100
}
trait Logger{
def log(msg : String){
println("log" + msg)
}
}
class Test extends Logger{
def test{
log("xxx")
}
}
case class Book(name : String,author : String)
object Basic5 extends App{
val value = 1
value match{
case 1 => "one"
case 2 => "two"
case _ => "some other number"
}
val result = value match{
case i if i == 1 => "one"
case i if i == 2 => "two"
case _ => "some other number"
}
println("result of match is :" + result)
println("result2 of match is :" + result2)
def t(obj:Any) = obj match{
case x : Int => println("Int")
case s : String => println("String")
case _ => println("unknow type")
}
t("1")
t(1)
t(1L)
val macTalk = Book("MacTalk","CJQ")
macTalk match{
case Book(name,author) => println("this is book")
case _ =>println("unknown")
}
}
---case class(多用在模式匹配中)
构造器中的每一个类型都为val，不建议用var
不用new就可以直接生产对象（为什么？apply方法）
-----------------------------
高阶函数
匿名函数 val double = (x: Int)=> 2 * x
函数作为参数
参数类型推断
常用高阶函数
map、filter、reduce等等
----------------------------
集合
List
Set
Tuple
Map
----------------
集合操作
foreach（类似于map，但是没有返回值）
map（迭代）
filter（过滤）
zip（聚合）
partition（列表分割）
flatten（扁平化）
flatMap（map + flatten）
------------------------
泛型
泛型类
class Pair[T,S](val first:T,val second:S)
泛型方法
def computer[T](list : List[T])= ...
------------------------
class Basic6{
}
class A{
}
class Rich(a : A){
def rich{
println("rich...")
}
}
object Basic6 extends App{
implicit def a2Rich(a : A) = new Rich(a)
val a = new A
a.rich
deftestParam(implicit name : String){
println(name)
}
implicit val name = "implicit!!!"
testParam
implicit class Calculator(x : Int){
def add(a : Int) : Int = a + 1
}
println(1.add(1))
}
---------------Spark概述与编程模型---------------------
Spark的快只是因为内存？
内存计算
DAG
支持三种语言的API：Scala、Python、Java
有四种运行模式：local（）
--------------集群配置-----------------------------------------
spark-env.sh
export JAVA_HOME=
export SPARK_MASTER_IP=
export SPARK_WORKER_CORES=
export SPARK_WORKER_INSTANCES=
export SPARK_WORKER_MEMORY=
export SPARK_MASTER_PORT=
export SPAEK_JAVA_OPTS="-verbose:gc -XX:-PrintGCDetails -XX:+PrintGCTimeStamps"
val conf = new SparkConf()
conf.setMaster("spark://master:8080")
.setSparkHome("/usr/hadoop/spark-1.6.0-cdh5.7.1")
.setAppName("analysis")
.setJar(jars)
.set("spark.executor.memory","2g")
val sc = new SparkContext(conf)
val data = sc.textFile(args(1))
val rdd1 = sc.textFile("hdfs://192.168.1.198:8020/spark/SogouQ1.txt")
rdd1.toDebugString
val words=rdd1.flatMap(_.split(" "))
val wordscount=words.map(x=>(x,1)).reduceByKey(_+_)
wordscount.collect
wordscount.toDebugString
val rdd1 = sc.textFile("hdfs://192.168.1.198:8020/spark/test.txt",9)
val rdd2=rdd1.map(_.split("\t")).filter(_.length==6)
val rdd3=rdd2.filter(_(3).toInt==1).filter(_(4).toInt==2)
rdd3.count()
