Spark(day01) -- Scala

一.Introduction

https://en.wikipedia.org/wiki/Scala_(programming_language)

二.Data Type

三.Example

1.functional orientation

object HelloScala extends App{

   //yield 关键字   生成新数组
    val z=for (i <- 1 to 3 ) yield i *10
    println(z)
  //把元组的元素加一，生成新数组 a
  val arr =Array(1,2,3)
  val a1=for (i <- arr) yield  i+1
  println(a1.toBuffer)

  //把奇数拿出来  生成新数组a2
  val arr1=Array(1,2,3,4,5,6,7,8,9)
  val a2=for (i <- arr1;if (i%2==1)) yield i
//  println(a2.toBuffer)
  val a3 =arr1.filter(_%2==0)
  println(a3.toBuffer)

  val lst=List(9,2,77,4,88,6,66,8,1)

  val a4= lst.map(_*10)
//  println(aarr24)
  //把list中偶数拿出，乘以3
  val a5= lst.filter(_%2==0).map(_*3)
//  println(a5)
  //对arr2进行排序
  val a6= lst.sorted
  println(a6)
  val a7 = lst.sorted.reverse
  println(a7)
//把list每四个进行分组
  val a8= lst.grouped(4)
 // println(a8.toList)
  val a9=a8.flatten
  //println(a9.toList)
  //压扁乘以10
  val a10=a8.flatten.toList.map(_*10)
  //println(a10)
  //flatMap=flatten+map
  //简化?
  val qq=List(List(1,2,3),List(4,5,6))
  //val a11=qq.flatMap(_*10)
//forech,map
  //map和foreach都是把里面的元素取出来做相应的操作
  //map会返回一个空的数组集合
  //foreach不会产生新的集合
 val arr3=Array(1,2,3,4)

  arr3.map(println(_))

  //arr3.foreach(x=>println(x))


}

ifDemo:

class IfDemo {

}
object IfDemo{
  def main(args: Array[String]): Unit = {
  val x=0
    val z={
      if (x<0){
        -1
      }else if(x>=1){
        1
      }
      else{
        "error"
      }
    }
    println(z)
  }
}

MethodDemo:

object MethodDemo extends App{
def m1(a:Int,b:Int):Int=a*b
  val res=m1(2,3)
  println(res)
}

FuncDemo:

object FuncDemo {
  def main(args: Array[String]): Unit = {
    val func=(x:Int,y:Int)=>x+y
    val res=func(2,3)
    println(res)
    //匿名函数：没有名字的函数


    //有名函数
    val r =1 to 10
    val f1=(x:Int)=>x*10
    val f2=(x:Int)=>x+1
    println(r.map(f1))
    println(r.map(f2))
    //匿名函数

    println(r.map((x:Int)=>x*100))
    println(r.map(x=>x+10))
    //注意map中的  _*1000   也是匿名函数
    println(r.map(_*1000))
  }
}

MethodAndFunc:

object MethodAndFunc {
  def main(args: Array[String]): Unit = {
    def m1(f:(Int,Int)=>Int)={f(2,3)}
    val f1=(x:Int,y:Int)=>x*y
    val f2=(x:Int,y:Int)=>x+y

    val a=m1(f1)
    println(a)
    val b=m1(f2)
    println(b)
  }
}

MutableList:

import scala.collection.mutable.ListBuffer
object MutableList {
  def main(args: Array[String]): Unit = {
    val lst0=ListBuffer[Int](1,2,3)
//    println(lst0)
    val lst1=new ListBuffer[Int]
    lst1+=4
    lst1+=5
//    println(lst1)
//    往list0里添加lst1
//    lst0++=lst1
//    println(lst0)
//    println(lst1)
    val lst2=lst0++lst1
    println(lst2)
//    往lst0里添加一个元素5 生成一个新的lst3
    val lst3=lst0:+5
    println(lst3)

  }
}

ImmutableList:

//不可变的list集合
object ImutableList {
  def main(args: Array[String]): Unit = {
    val lst1=List(1,2,3)
    val lst2=0::lst1
//    println(lst2)
    val lst3=lst1.::(0)
//    println(lst3)
    val lst4=0+:lst1
  //  println(lst4)
    val lst5=lst1.+:(7)
//    println(lst5)
//    将元素添加到后面
    val lst6=lst1:+7
//    println(lst6)
    val lst0=List(4,5,6)
    val lst7=lst1++lst0
    println(lst7)
    val lst8=lst0++:lst1
    println(lst8)
  }
}

MutableSet:

import scala.collection.mutable

object MutableSet {
  def main(args: Array[String]): Unit = {
    val set1=new mutable.HashSet[Int]()
    set1 += 2
//    println(set1)
    set1.add(4)
//    println(set1)
    set1++=Set(1,3,5)
//    println(set1)
    set1.remove(3)
//    println(set1)
    set1 -= 1
    println(set1)

  }
}

ImmutableSet:

import scala.collection.immutable.HashSet
object ImutableSet {
  def main(args: Array[String]): Unit = {
    val set1=new HashSet[Int]()
    val set2=set1+4
//    println(set2)
    val set3=set2++Set(5,6,7)
//    println(set3)
    val set0=Set(1,3,4)++set3
    println(set0)
  }
}

Array:

import scala.collection.mutable.ArrayBuffer

object ArrayDemo {
  def main(args: Array[String]): Unit = {
    val arr1=new Array[Int](8)
//    println(arr1.toBuffer)
    val arr2=Array[Int](8)
//    println(arr2.toBuffer)
    //Array下标从0开始
    val  arr3=Array("hadoop","spark","hive")
//    println(arr3(2))
//变长数组
    val ab=new ArrayBuffer[Int]()
    ab+=1

    ab+=(2,3,4,5)
    ab++=Array(6,7)
    ab++=ArrayBuffer(8,9)
    ab.insert(0,-1,0)
    ab.remove(9,2)
    println(ab)
    val arr=Array(("tom",2),("jerry",3),("jj",4))
    val newMap=arr.toMap
    println(newMap)
  }
}

MapDemo:

import scala.collection.mutable

object MapDemo {
  def main(args: Array[String]): Unit = {
    val map1=new mutable.HashMap[String,Int]()
    map1("spark")=1
//    println(map1)
    map1+=(("hadoop",2),("hive",3))
//    println(map1)
  map1.put("storm",4)

    map1.remove("storm")
    map1-="spark"
    map1("hadoop")=5
    println(map1)

    val map2=Map("jerry"->8,"tom"->9,"jj"->10)
    val map3=Map(("uu",3),("kk",4))

  }

}

Tuple:

object Tuple {
  def main(args: Array[String]): Unit = {
    val tup=("tom",3.14,5)
//    println(tup._1)
    val t,(a,b,c)=("jj",666,6.6)
    println(t)
    println(a)
    println(b)
    println(c)

  }
}

2.Object-Oriented

extend and trait: 

trait Listen{
  val name:String
  def listen()={
    println("your friend "+name+" is lietening.........")
  }
}
trait Read{
  val name:String
  def read()={
    println("your friend "+name+" is reading.........")
  }
}
trait Speak{
  val name:String
  def speak()={
    println("your friend "+name+" is speaking.........")
  }
}
class Human (val name:String) extends Read with Speak {
def listen()={
  println(name+"is listening..")
}
}
class Animal(val name:String="jj"){

  def eat()={
    println("eating")
  }
}
class Cat(override val name:String)extends Animal with Speak with Listen with Read {
  override def eat()={
    println("eating zhuzi")
}}
object Human{
  def main(args: Array[String]): Unit = {
    val scat=new Cat("tom")
    scat.eat()
    scat.listen()
    scat.read()
   // val f=new Listen ()  trait 不能实例化
    val h=new Human("jack")
    h.listen()
    h.read()
    h.speak()
  }
}

apply:

//apply  对象后面加对应的参数，这时就会在object中找参数一致的apply方法
class Human1 {

}
object Human1{
  def apply():Unit={
    println("apply方法已经被调用")
  }

  def apply(name:String):Unit={
    println(name)
  }

  def apply(age:Int):Unit={
    println(age)
  }
  def main(args: Array[String]): Unit = {
//  注意没有new

    val h=Human1(18)


  }
}

Option:

//偏函数
//scala中的option类用来表示可能存在的，也可能不存在的，他有两个子类  Some(一定有值)  None()
object Option {
  def main(args: Array[String]): Unit = {
    val a=Map(("tom",1),("jerry",2))
    val b=a.get("jj") match {
      case Some(i)  =>i
      case None=>0

        val c =a.getOrElse("tom",8)
        println(c)
    }
//    println(b)
  }
}

Person:

class Person {
  val id="5" //只有get
  var name="zhangsan"//有get，有set
  private val hobby ="LOL" //如果用private修饰一个变量，在类中可以访问
  private [this] val addr="beijing" //如果用private [this]修饰只能在class中访问
  private [day2m] val age=18   //如果用 private [包名] 修饰 可在包内访问
}
//伴生对象里面放的是一些静态的变量和方法
object Person {
  def main(args: Array[String]): Unit = {
//   实例化
    val p =new Person
    p.name="saner"

    println(p.name)
    println(p.hobby)
    println(p.id)
    println(p.age)
  }
}

Test:

//如果想调用类的方法，必须要进行实例化，new一个对象，由于object是静态的，所以直接 object名.方法名来调用

class Test1 {
val field="field"
  def doSomeTing=println("doSometing")
}
object Test1{
  val a="aString"
  def printSomeTing=println(a)

  def main(args: Array[String]): Unit = {
    Test1.printSomeTing
    val t=new Test1
    t.doSomeTing
  }

}

Student:

//sc:Int 如果这样定义相当于private[this]
class Student(val id:Int,var name:String,var addr:String="beijing",sc:Int) {


}
object Student {
  def main(args: Array[String]): Unit = {
    val stu =new Student(1,"jj","tieling",99)
    stu.name="jay"
    stu.addr="shanghai"
    println(stu.id)
    println(stu.name)
    println(stu.addr)

  }
}

People:

class People {
  val name="jack"
  println(name)
  def sayHi:Unit={
    println("hi~~~~~~~~~~")
  }
}
object People {
  def run:Unit={
    println("run~~~~~")
  }

  def main(args: Array[String]): Unit = {
    People.run
    val p=new People
    p.sayHi
  }
}