Movle

val rdd1 = sc.parallelize(List(1,2,3,4,5,8,34,100,79))

val rdd2 = rdd1.map(_*2)

rdd2.collect

rdd2.sortBy(x=>x,true)

rdd2.sortBy(x=>x,true).collect

rdd2.sortBy(x=>x,false).collect

rdd2.filter(_>20).collect

val rdd4 = sc.parallelize(Array("a b c","d e f","x y z"))

val rdd5 = rdd4.flatMap(_.split(" "))

rdd5.collect

val rdd6 = sc.parallelize(List(5,6,7,8,9,10))

val rdd7 = sc.parallelize(List(1,2,3,4,5,6))

val rdd8 = rdd6.union(rdd7)

rdd8.collect

rdd8.distinct.collect

val rdd9 = rdd6.intersection(rdd7)

rdd9.collect

val rdd1 = sc.parallelize(List(("Tom",1000),("Jerry",3000),("Mary",2000)))

val rdd2 = sc.parallelize(List(("Jerry",1000),("Tom",3000),("Mike",2000)))

val rdd3 = rdd1 union rdd2

rdd3.collect

val rdd4 = rdd3.groupByKey

rdd4.collect

rdd3.reduceByKey(_+_).collect

val rdd1 = sc.parallelize(List(("Tom",1),("Tom",2),("jerry",1),("Mike",2)))

val rdd2 = sc.parallelize(List(("jerry",2),("Tom",1),("Bob",2)))

val rdd3 = rdd1.cogroup(rdd2)

rdd3.collect

val rdd1 = sc.parallelize(List(1,2,3,4,5))

val rdd2 = rdd1.reduce(_+_)

val rdd1 = sc.parallelize(List(("tom",1),("jerry",1),("kitty",2),("bob",1)))

val rdd2 = sc.parallelize(List(("jerry",2),("tom",3),("kitty",5),("bob",2)))

val rdd3 = rdd1 union(rdd2)

val rdd4 = rdd3.reduceByKey(_+_)

rdd4.collect

val rdd5 = rdd4.map(t => (t._2,t._1)).sortByKey(false).map(t=>(t._2,t._1))

rdd5.collect

//通过并行化生成rdd
val rdd1 = sc.parallelize(List(5, 6, 4, 7, 3, 8, 2, 9, 1, 10))
//对rdd1里的每一个元素乘2然后排序
val rdd2 = rdd1.map(_ * 2).sortBy(x => x, true)
//过滤出大于等于十的元素
val rdd3 = rdd2.filter(_ >= 10)
//将元素以数组的方式在客户端显示
rdd3.collect

val rdd1 = sc.parallelize(Array("a b c", "d e f", "h i j"))
//将rdd1里面的每一个元素先切分在压平
val rdd2 = rdd1.flatMap(_.split(' '))
rdd2.collect

val rdd1 = sc.parallelize(List(5, 6, 4, 3))
val rdd2 = sc.parallelize(List(1, 2, 3, 4))
//求并集
val rdd3 = rdd1.union(rdd2)
//求交集
val rdd4 = rdd1.intersection(rdd2)
//去重
rdd3.distinct.collect
rdd4.collect

val rdd1 = sc.parallelize(List(("tom", 1), ("jerry", 3), ("kitty", 2)))
val rdd2 = sc.parallelize(List(("jerry", 2), ("tom", 1), ("shuke", 2)))
//求jion
val rdd3 = rdd1.join(rdd2)
rdd3.collect
//求并集
val rdd4 = rdd1 union rdd2
//按key进行分组
rdd4.groupByKey
rdd4.collect

val rdd1 = sc.parallelize(List(("tom", 1), ("tom", 2), ("jerry", 3), ("kitty", 2)))
val rdd2 = sc.parallelize(List(("jerry", 2), ("tom", 1), ("shuke", 2)))
//cogroup
val rdd3 = rdd1.cogroup(rdd2)
//注意cogroup与groupByKey的区别
rdd3.collect

val rdd1 = sc.parallelize(List(1, 2, 3, 4, 5))
//reduce聚合
val rdd2 = rdd1.reduce(_ + _)
rdd2.collect

val rdd1 = sc.parallelize(List(("tom", 1), ("jerry", 3), ("kitty", 2),  ("shuke", 1)))
val rdd2 = sc.parallelize(List(("jerry", 2), ("tom", 3), ("shuke", 2), ("kitty", 5)))
val rdd3 = rdd1.union(rdd2)
//按key进行聚合
val rdd4 = rdd3.reduceByKey(_ + _)
rdd4.collect
//按value的降序排序
val rdd5 = rdd4.map(t => (t._2, t._1)).sortByKey(false).map(t => (t._2, t._1))
rdd5.collect

import scala.reflect.ClassTag

def mkIntArray(elems:Int*) = Array[Int](elems:_*)

mkIntArray(1,2,3,100)

def mkStringArray(elems:String*) = Array[String](elems:_*)

mkStringArray("Mike","Tom","Mary")

def mkArray[T:ClassTag](elems:T*) = Array[T](elems:_*)

mkArray(1,2,3,5,8)

mkArray("Tom","Marry")

def addTwoString[T<:String](x:T,y:T) = x + " **** " + y

addTwoString("Hello","123")

addTwoString(1,2)

addTwoString(1.toString,2.toString)

implicit def int2String(n:Int):String = {n.toString}

def testParam(name:String) = println("The value is " + name)

def testParam(implicit name:String) = println("The value is " + name)

implicit val name:String = "AAAAAA"

testParam("dfsfdsdf")

testParam

package Test01

import akka.actor.{Actor, ActorSystem, Props}

class HelloActor extends Actor{
  def receive = {
    /**
     * 使用 case 来处理不同类型的信息
     */
    case "Hello" => println("你好！")
    case _ => println("你是？")
  }
}
object DemoActor {

  def main(args: Array[String]): Unit = {
    //新建一个ActorSystem
    val system = ActorSystem("HelloSystem")

    val helloActor = system.actorOf(Props( new HelloActor),name="helloactor")

    //给 helloactor 发送消息

    helloActor ! "Hello123123123"
  }
}

import akka.actor._
/**
  *
  * 两个Actor 相互发消息
  *
  * Ping   Pong
  */
//定义消息类型
case object PongMessage
case object PingMessage
case object StopMessage
case object StartMessage

class Pong(ping:ActorRef) extends Actor{
  var count = 0
  def incrementAndPrint { count += 1; println("count + 1 and pong")}
  def receive = {
  case PingMessage =>
    if (count > 9){
      sender ! StopMessage
      println("count > 9")
      context.stop(self)
    } else {
      println("Receive PingMessage")
      incrementAndPrint
      sender ! PongMessage

    }

  case StartMessage =>
    println("Receive StartMessage")
      //发送一个消息
      ping ! PongMessage
  }
}


class Ping extends Actor{
  def receive = {
    case PongMessage =>
      println("Receive PongMessage")
      //回复一个消息
      sender ! PingMessage
    case StopMessage =>
      println("Stop Message")
      context.stop(self)
      //context.system.finalize()
  }
}
object Demo2 {
  def main(args: Array[String]): Unit = {
    //pong ! StartMessage
    val system = ActorSystem("PingPongSystem")
    val ping = system.actorOf(Props[Ping],name="ping")
    val pong = system.actorOf(Props(new Pong(ping)),name="pong")
    pong ! StartMessage
  }
}

//不可变的集合
val math = scala.collection.immutable.Map("Alice"->80,"Bob"->90,"Mary"->85)

//可变的集合
val english = scala.collection.mutable.Map("Alice"->80,"Bob"->90,"Mary"->85)
val chinese = scala.collection.mutable.Map("Alice"->80,"Bob"->90,"Mary"->85)

chinese.get("Bob")

chinese.get("Tomdfsdfd")

chinese("Bob")

chinese.getOrElse("Tomsdlkfjlskdjfls",-1)

chinese("Tomdfsdfd")

chinese

chinese("Bob")=0

chinese

math

math("Bob")=0

chinese += "Tom"->85

//不可变列表：List
//字符串列表
val namelist = List("Bob","Mary","Mike")
//整数列表
val intList = List(1,2,3,4,5)
//空列表
val nullList:List[Nothing] = List()
//二维列表
val dim:List[List[Int]] = List(List(1,2,3),List(4,5,6))

//输出列表中的值：head,tail,isEmpty
println("第一个人的名字："+namelist.head)

println(namelist.tail)

println("列表是否为空："+namelist.isEmpty)

//可变列表：
val myList = scala.collection.mutable.LinkedList(1,2,3,4,5)
//操作：将上面可变列表中的每个值乘以2
//列名 elem
//定义一个指针指向列表的开始
var cur = myList

//Nil:代表Scala中的null
while(cur != Nil){
  cur.elem = cur.elem*2
  //将指针指向下一个元素
  cur = cur.next
}
//查看结果
println(myList)

myList

myList.map(_*2)

myList.drop(2)

myList.dropWhile(_%2!=0)

//Vector:为了提高list列表随机存取的效率而引入的新的集合类型
//支持快速的查找和更新
val v= Vector(1,2,3,4,5,6)

//返回的是第一个满足条件的元素
v.find(_>3)
v.updated(2,1000)

//Range：有序的通过空格分割的Int序列
//以下几个例子Range是一样

Range(0,5)
println("第一种写法："+Range(0,5))
println("第二种写法："+(0 until 5))
println("第三种写法："+(0 to 4))

//两个range可以相加
('0' to '9')++('A' to 'Z')

//可以将Range转换为List
1 to 5 toList

//a.**创建一个Set**
var s1 = Set(2,0,1)

//往s1中添加一个重复元素
s1+1

//往s1中添加一个不重复元素
s1+100

//创建一个LinkedHashSet,一定要先import下面这个，否则会保错
import collection.mutable
var weeksday = mutable.LinkedHashSet("星期一","星期二","星期三","星期四")

//创建一个排序的集
var s2 = mutable.SortedSet(1,2,3,10,4)

weeksday+"星期五"

weeksday contains("星期二")

Set("星期二","星期四","星期日") subsetOf(weeksday)

var set1=Set(1,2,3,4,5)

var set2=Set(5,6,7,8,9,10)
//并集：集合相加，去掉重复元素
set1 union set2
//intersect交集
set1 intersect set2
//差集
set1 diff set2

//更好的switch
var sign =0

var ch1 = '-'

ch1 match{
  case '+' => sign = 1
  case '-' =>sign = -1
  case _ =>sign = 0
}
println(sign)

//scala的守卫：匹配某种类型的所有值
var ch2='6'
var digit:Int = -1
ch2 match{
  case '+' => println("这是一个+")
  case '-' => println("这是一个-")
  case _ if Character.isDigit(ch2) => digit = Character.digit(ch2,10)
 case _ => println("其他类型")
}

println("Digit:"+digit)

//模式匹配的变量
var str3 = "Hello World"

str3(7) match{
  case '+' => println("这是一个+")
  case '-' => println("这是一个+")
  case ch => println("这是字符："+ch)
}

//类型模式
var v4:Any =100
v4 match{
  case x:Int => println("这是一个整数："+x)
  case s:String => println("这是一个字符串："+s)
  case _ => println("这是其他类型")
}

//匹配数组和列表
var myArray = Array(1,2,3)
myArray match{
  case Array(0) => println("0")
  case Array(x,y) =>println("这是数组包含的两个元素，和是："+(x+y))
  case Array(x,y,z) => println("这是数组包含的三个元素，乘积是："+(x*y*z))
  case Array(x,_*) => println("这是一个数组")
}

var myList = List(1,2,3)
myList match{
  case List(0) => println("0")
  case List(x,y) =>println("这是列表包含的两个元素，和是："+(x+y))
  case List(x,y,z) =>println("这是列表包含的三个元素，乘积是："+(x*y*z))
  case List(x,_*) => println("这个列表包含多个元素")
}

var result = sc.textFile("hdfs://....").flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_).collect

//普通函数
def fun1(x:Int):Int = x*3

//匿名函数
(x:Int)=>x*3

//map
//在列表中的每个元素上计算一个函数，并且返回一个包含相同数目元素的列表
val numbers = List(1,2,3,4,5,6,7,8,9,10)

numbers.map((i:Int)=>i*2)

numbers.map(_*2)

//map函数不改变numbers值
numbers

_ 相当于循环变量 i
_*2 与 (i:Int)=>i*2 功能相同
_+_ 与 (i:Int,j:Int)=>i+j

//foreach
//foreach和map相似，只不过它没有返回值，foreach主要是为了对参数进行作用
numbers.foreach((i:Int) => i * 2)

numbers.foreach(_*2)

numbers

numbers.foreach(println(_))

numbers.map(_*2).foreach(println)

//filter
//移除任何使得传入的函数返回false的元素

numbers.filter((i:Int) =>i%2==0)

//zip
//zip把两个列表的原色合成一个由元素对组成的列表
List(1,2,3).zip(List(4,5,6))

List(1,2,3).zip(List(4,5))

List(3).zip(List(4,5))

//partition
//partition根据断言函数的返回值对列表进行拆分
numbers.partition((i:Int)=>i%2==0)

//find
//find返回集合里第一个匹配断言函数的元素
numbers.find(_ % 3==0)

//flatten
//flatten可以把嵌套的结构展开
List(List(1,2,3),List(4,5,6)).flatten

//flatMap
//flatMap是一个常用的combinator，它结合了map和flatten的功能
val myList = List(List(2,4,6,8,10),List(1,3,5,7,9))

myList.flatMap(x=>x.map(_*2))

1.将List(2,4,6,8,10)和List(1,3,5,7,9)调用了x=>x.map(_*2)  这里x代表某个List
List(4, 8, 12, 16, 20)  和 List(2, 6, 10, 14, 18)

2.合并成一个List
List(4, 8, 12, 16, 20, 2, 6, 10, 14, 18)

class Counter{
  private var value =0;
  
  def increment() { value +=1};
  def current() = value;

}

//scala中类的定义
class Student1{
    //定义属性
    private var stuName:String = "Tom"
    private var stuAge:Int = 20
    //成员方法
    def getStuName():String = stuName
    def setStuName(newName:String) = this.stuName=newName
    def getStuAge():Int = stuAge
    def setStuAge(newAge:Int) = this.stuAge=newAge
}

/**
  * 测试student1类，创建main函数
  *
  * 注意：object和class名字可以不一样的
  * 如果oject和class的名字相同，object成为该class的 伴生对象
  *
  */
//创建Student1的伴生对象
object Student1{

    def main(args:Array[String]){
        
    //创建一个学生对象
    var s1 = new Student1

    //访问属性并输出
    println(s1.getStuName() + "\t" + s1.getStuAge())

    //访问set方法
    s1.setStuName("Mary")
    s1.setStuAge(22)
    println(s1.getStuName() + "\t" + s1.getStuAge())

    /**
      * 直接访问私有属性
      *
      * 上面定义中，属性都是private的
      * 如果属性是private的，在类的外部，是不能访问的
      *
      */
    println("------------直接访问私有属性-----------")
    println(s1.stuId +"\t"+ s1.stuName +"\t"+ s1.age)

    /**
      * 注意：我们可以直接访问类的私有成员，为什么？
      * s1.stuId +"\t"+ s1.stuName +"\t"+ s1.age
      * 使用 . 方式访问的
      *
      * scala中属性的get set 方法：
      *
      * 1、当一个属性是private的时候，scala会自动为其生成对应的get set 方法
      * s1.stuId 访问的是scala中，自动为stuId生成的get方法，并且该方法的名字为stuId
      *
      * 2、如果值希望scala生成get方法，不生成set方法，可以将其定义为常量
      * 因为常量的值不可改变
      *
      * 3、如果希望属性，不能被外部访问（希望scala不要生成set get 方法），使用 private [this] 关键字
      *
      */
    }
}

private var stuName:String = "Tom"

import scala.collection.mutable.ArrayBuffer
//嵌套类，内部类
class Student3{
    //定义一个内部类，记录学生选修的课程信息
    class Course(val courseName:String,val credit:Int){
      //定义方法
    }

    //属性
    private var stuName:String = "Tom"
    private var stuAge:Int = 20
    //定义一个ArrayBuffer记录该学生选修的所有课程
    private var courseList = new ArrayBuffer[Course]()

    //定义方法往学生信息中添加新的课程
    def addNewCourse(cname:String,credit:Int){
        //创建新的课程
        var c = new Course(cname,credit)

        //将课程加入list
        courseList +=c
    }
}

Object Student3{
    def main(args:Array[String]){
        //创建学生对象
        var s3 = new Student3

        //给该学生添加新的课程
        s3.addNewCourse("Chinese",2)
        s3.addNewCourse("English",3)
        s3.addNewCourse("Math",4)    

        //输出
        println(s3.stuName+"\t"+s3.stuAge)
        println("********选修的课程********")

        for(s <- s3.courseList) println(s.courseName+"\t"+s.credit)
    }
}

class Student4(val stuName:String,val stuAge:Int){
}

object Student4{
    def main(args:Array[String]){
        //创建Student4的一个对象
        var s4 = new Student4("Tom",20)

        println(s4.stuName+"\t"+s4.stuAge)        //调用了主构造器
    }
}

class Student4(val stuName:String,val stuAge:Int){
    //定义辅助构造器
    def this(age:Int){
        //调用主构造器
        this("no name",age)
    }
}
object Student4{
    def main(args:Array[String]){

        //创建一个新的Student4对象，并调用辅助构造器
        var s42 = new Student4(25)

        println(s42.stuName+"\t"+s42.stuAge)
    }
}

class Student3(var stuName : String , var age:Int) {
  //属性
  private var gender:Int = 1

  //定义一个辅助构造器，辅助构造器可以有多个
  //辅助构造器就是一个函数，只不过这个函数的名字叫 this

  def this (age : Int){
    this("Mike",age) // new Student3("Mike",age)
    println("这是辅助构造器")
  }

  def this (){
    this(10)// new Student3("Mike",10)
    println("这是辅助构造器2")
  }

}

object  Student3{
  def main(args: Array[String]): Unit = {
    //使用主构造器 创建学生对象
    var s1 = new Student3("Tom",20)
    println(s1.stuName+"\t"+s1.age)

    //使用辅助构造器
    var s2 = new Student3(20)
    s2.gender = 0
    s2.stuName = "have name"
    println(s2.stuName+"\t"+s2.age+"\t"+s2.gender)
  }
}

static{
    try{
        Class.forName(driver);
    } catch(ClassNotFoundException e){
          throw new ExceptionInInitializerError(e);
    }
}

//利用object对象实现单例模式
object CreditCard{

    //变量保存信用卡号
    private [this] var creditCardNumber:Long = 0

    //产生新的卡号
    def generateNewCCNumber():Long = {
        creditCardNumber += 1
        creditCardNumber
    }

    //测试程序
    def main(args:Array[String]){
        //产生新的卡号
        println(CreditCard.generateNewCCNumber())
        println(CreditCard.generateNewCCNumber())
        println(CreditCard.generateNewCCNumber())
        println(CreditCard.generateNewCCNumber())
    }
}

//使用应用程序对象：可以省略main方法
object HelloWorld extends App{

//    def main(args:Array[String]){
//        
//    }
//这里的main可以不写，相当于下面的代码是在main方法中执行的

    println("Hello World")

    //如何取得命令行的参数
    if(args.length>0){
        println(args(0))
    }else{
        println("no argument")
    }
}

Object(参数1,参数2,......,参数N)

var marry = Array(1,2,3)
//这里没有用new关键字，其实就是用了apply方法

//object的apply方法
class Student5(val stuName:String){

}

object Student5{
    def apply(stuName:String) = {
        println("******Apply in Object***********")
    }

    def main(args:Array[String]){
        //创建一个Student5的对象
        var s51 = new Student5("Tom")
        println(s51.stuName)
        
        //创建一个Student5的对象
        var s52 = new Student5("Tom")
        println(s52.stuName)
    }
}

import com.my.io.XXX     //可以不写XXX的全路径
import com.my.io._       //引用import com.my.io下所有的类型
import com.my.io.XXX._   //引用import com.my.io.XXX的所有成员

def method(fruit :Fruit){
    import fruit._
    println(name)
}

var list = List("LiMing","May","Mike")

println("for循环的第一种写法")
for(s<-list) println(s)

println("for循环的第二种写法")
for{
  s <-list
  if(s.length >3)
}println(s)

println("for循环的第三种写法")
for(s <- list if s.length < 3) println(s)

println("for循环的第四种写法")
var newList = for{
  s <- list
  s1=s.toUpperCase()
}yield(s1)
for(s1<-newList) println(s1)

var list = List("LiMing","May","Mike")

println("******while循环******")
var i=0
println("while循环")
while(i<list.length){
  println(list(i))
  i+=1
}

println("******dowhile循环******")
var j=0
do{
  println(list(i))
  j+=1
}while(j<list.length)

val list = List("LiMing","XiaoHong","PengPeng")

list.foreach(println)   //相当于for(s<-list) println(s )

//定长数组
val a = new Array[Int](10)

val b = new Array[String](5)

val c = Array("Tom","Marry","Mike")

//一定要先导包
import scala.collection.mutable.ArrayBuffer
val d = ArrayBuffer[Int]()
//在变长数组种添加元素
d+=1
d+=2
d+=3
//在变长数组中添加多个元素
d+=(10,12,13)

//将ArrayBuffer转换为Array
d.toArray

//遍历数组
var a =Array("aa","bb","cc")
//使用for循环进行遍历
for(s <-a) println(s)

//对数组进行转换，新生成一个数组yield
val b = for{
  s<-a
  s1=s.toUpperCase
}yield(s1)

//使用foreach进行循环输出
a.foreach(println)

import scala.collection.mutable.ArrayBuffer

val myArray = Array(1,10,2,3,5,4)

//最大值
myArray.max
//最小值
myArray.min
//求和
myArray.sum
//定义一个变长数组
var myArray1= ArrayBuffer(1,10,2,3,5,4)

//排序
myArray1.sortWith(_>_)
//升序
myArray1.sortWith(_<_)

//定义一个固定长度的二维数组

val matrix = Array.ofDim[Int](3,4)

matrix(1)(2)=10

matrix

//定义一个二维数组，其中每个元素是一个一维数组，其长度不固定
val triangle = new Array[Array[Int]](10)

for(i<-0 until triangle.length)
  triangle(i)=new Array[Int](i+1)

triangle

val scores = Map("Alice" -> 10,"Bob" -> 3,"Cindy" -> 8)

//不可变的Map
val math = scala.collection.immutable.Map("Alice"->80,"Bob"->95,"Mary"->70)

//可变的Map
val english = scala.collection.mutable.Map("Alice"->80,"Bob"->95,"Mary"->70)

val chinese = scala.collection.mutable.Map(("Alice",80),("Bob",95),("Mary",70))

//获取Map中的值
chinese("Bob")


//需要判定是否存在才能够获得该映射的值
if(chinese.contains("Alice")){
  chinese("Alice")
}else{
  -1
}

chineses.getOrElse("To123123m",-1)

chineses.get("dlfsjldkfjlsk")

chineses.get("Tom")

//更新Map中的值
chinese("Bob")=100

chinese

//往Map中添加新的元素
chinese +="Tom"->85

//移除Map中的元素
chinese -="Bob"

//迭代Map:使用for或者foreach
for(s <-chinese) println(s)

chinese.foreach(println)

val t = (1, 3.14, "Fred") // 类型为Tuple3[Int, Double, java.lang.String]

val t1 = Tuple3(1,0.3,"Hello")

//定义tuple
val t1 = (1,2,"Tom")

val t2 = new Tuple4("Marry",3.14,100,"Hello")

//访问tuple中的组员
t2._1
t2._2
t2._3
t2._4

//遍历Tuple：foreach
t2.productIterator.foreach(println)

def main(args: Array[String]): Unit = {
    //读取行
    val source = fromFile("/users/macbook/TestInfo/student.txt")

    /**
     * 1、将整个文件作为字符串输出
     */
    println("--------mkString---------")
    println(source.mkString)
}

def main(args: Array[String]): Unit = {
    //读取行
    val source = fromFile("/users/macbook/TestInfo/student.txt")

    /**
     * 2、将文件的每一行读入 java BufferedReader readLine方法类似
     */
    println("--------lines---------")
    val lines = source.getLines()
    lines.foreach(println)
}