Spark体系

  • Spark体系
    • 语言区别
    • 使用scala
    • 语法学习
      • Object_Class
      • IF_WHILE_FOR
      • Functions
      • Collections
      • 高级
        • trait
        • case_class
        • match
        • PartialFunction
        • Implicit

Spark体系

语言区别

语言分类：编译型，解释型
1.编译型：C
2.解释型：Python
3.Java是啥
1.需要编译 字节码
2.解释执行、直接执行

C：可移植 代码对应不同平台，各自编译
Java：可移动性，一次编译，到处运行 JVM是核心！

编译器！：编译型，解释型根本区别在哪？
是否是强类型，什么是类型：宽度

SCALA on JVM 一定有一个编译

JAVA / SCALA
编译器 / 编译器 =>思考一个问题：scala代码和java不一样（编译器做了很多事情）
JVM

再聊语言：模型：
1. 面向过程的 第一类值：基本类型 +指针
2. 面向对象的 第一类值：基本类型 + 对象类型
3. 函数式的 第一类值：基本类型 + 对象类型 + 函数

SCALA 面向对象的函数式编程语言

int a;
a=33;
1.明文给出 推断
2.传参 很难发生推断

var a = 1
a=“sdfsdf”
var b = “1”
var c = ‘1’
xx(a) {} //推断不出来
推断不代表糊弄,防止运行期报错

使用scala

  1. 开发 jdk sdk（编译器）
  2. 运行 jdk jre

V： spark 2.3.x > scala 2.11 > jre/jdk 1.8.uxxx
https://www.oracle.com/technetwork/java/javase/archive-139210.html

--------------coder-------------

主流：使用 集成工具 ： IDE

1.  IDEA  +plugin  +编译器   》创建scala项目了！
2.  启动屏幕：configure-》；plugins

官方文档

main,class,object

主方法只能写在 object定义的文件中
object和class啥区别：
回顾一个问题：java中有一个知识点 静态
分号可有可无
scala是包级别区分，类名可以和文件名不一致

语法学习

Object_Class


//约等于  static  单例对象
//static
//单例  new    scala的编译器很人性化   让你人少写了很多代码
object ooxx {//  private val xo:xxoo = new xxoo()private val xo = new ooxx(11)//  Integer num = 0;//  var/val   var:变量  val常量 取代了final/* var a=3a=4val b=4b=5*/private val name = "object:zhangsan"println("ooxx....up")def main(args: Array[String]): Unit = {println("hello from ooxx")xo.printMsg()}println("ooxx....down")}//类里，裸露的代码是默认构造中的。有默认构造
//个性化构造！！
//类名构造器中的参数就是类的成员属性，且默认是val类型，且默认是private
//只有在类名构造其中的参数可以设置成var，其他方法函数中的参数都是val类型的，且不允许设置成var类型
class ooxx(sex: String) {var name = "class:zhangsan"def this(xname: Int) {//必须调用默认构造this("abc")}var a: Int = 3//  private val value = new ooxx()println(s"ooxx....up$a....")def printMsg(): Unit = {println(s"sex: ${ooxx.name}")}println(s"ooxx....up${a + 4}")
}

IF_WHILE_FOR

import scala.collection.immutableobject Lesson01_IF_WHILE_FOR {//自己特征：class  object//流控def main(args: Array[String]): Unit = {/*ifwhilefor*/var a=0if(a <= 0){println(s"$a<0")}else{println(s"$a>=0")}var  aa=0while(aa <10){println(aa)aa=aa+1}println("-----------------------------")//for//    for(i=0;i<10;i++)
//    for( P x : xs)val seqs = 1 until  10println(seqs)//循环逻辑，业务逻辑for( i <-  seqs if(i%2==0)){println(i)}println("----------------------")
//    for(i <- 1 to 9){//      for (j <- 1 to 9){//        if(j<=i) print(s"$i * $j = ${i*j}\t")
//        if(j == i ) println()
//      }
//    }var num = 0for(i <- 1 to 9;j <- 1 to 9 if(j<=i)){num+=1if(j<=i) print(s"$i * $j = ${i*j}\t")if(j == i ) println()}println(num)val seqss: immutable.IndexedSeq[Int] = for ( i <- 1 to 10) yield {var x = 8i + x}
//    println(seqss)for(i <-seqss){println(i)}}}

Functions

import java.util
import java.util.Dateobject Lesson02_Functions {//成员方法def ooxx(): Unit ={println("hello object")}def main(args: Array[String]): Unit = {//  方法  函数println("-------1.basic----------")//返回值，参数，函数体def fun01() {println("hello world")}fun01()var x = 3var y = fun01()println(y)//想有返回//    public void sdfsd(){}//    public String sdfsdf(){}//有return必须给出返回类型def fun02() = {new util.LinkedList[String]()}//参数：必须给出类型，是val//class 构造，是var，valdef fun03(a: Int): Unit = {println(a)}fun03(33)println("-------2.递归函数----------")//递归先写触底！  触发什么报错呀def fun04(num: Int): Int = {if (num == 1) {num} else {num * fun04(num - 1)}}val i: Int = fun04(4)println(i)println("-------3.默认值函数----------")def fun05(a: Int = 8, b: String = "abc"): Unit = {println(s"$a\t$b")}//    fun05(9,"def")fun05(22)fun05(b = "ooxx")println("-------4.匿名函数----------")//函数是第一类值//函数：//1，签名 ：(Int,Int)=>Int ：  （参数类型列表）=> 返回值类型//2，匿名函数： (a:Int,b:Int) => { a+b }  ：（参数实现列表）=> 函数体var xx: Int = 3var yy: (Int, Int) => Int = (a: Int, b: Int) => {a + b}val w: Int = yy(3, 4)println(w)println("--------5.嵌套函数---------")def fun06(a: String): Unit = {def fun05(): Unit = {println(a)}fun05()}fun06("hello")println("--------6.偏应用函数---------")def fun07(date: Date, tp: String, msg: String): Unit = {println(s"$date\t$tp\t$msg")}fun07(new Date(), "info", "ok")var info = fun07(_: Date, "info", _: String)var error = fun07(_: Date, "error", _: String)info(new Date, "ok")error(new Date, "error...")println("--------7.可变参数---------")def fun08(a: Int*): Unit = {for (e <- a) {println(e)}//      def foreach[U](f: A => U): Unit//      a.foreach(   (x:Int)=>{println(x)}   )//      a.foreach(   println(_)   )a.foreach(println)}fun08(2)fun08(1, 2, 3, 4, 5, 6)println("--------8.高阶函数---------")//函数作为参数，函数作为返回值//函数作为参数def computer(a: Int, b: Int, f: (Int, Int) => Int): Unit = {val res: Int = f(a, b)println(res)}computer(3, 8, (x: Int, y: Int) => {x + y})computer(3, 8, (x: Int, y: Int) => {x * y})computer(3, 8, _ * _)//函数作为返回值：def factory(i: String): (Int, Int) => Int = {def plus(x: Int, y: Int): Int = {x + y}if (i.equals("+")) {plus} else {(x: Int, y: Int) => {x * y}}}computer(3, 8, factory("-"))println("--------9.柯里化---------")def fun09(a: Int)(b: Int)(c: String): Unit = {println(s"$a\t$b\t$c")}fun09(3)(8)("sdfsdf")def fun10(a: Int*)(b: String*): Unit = {a.foreach(println)b.foreach(println)}fun10(1, 2, 3)("sdfs", "sss")println("--------*.方法---------")//方法不想执行，赋值给一个引用  方法名+空格+下划线val funa = ooxxprintln(funa)val func = ooxx _func()//语法 ->  编译器  ->  字节码   <-  jvm规则//编译器，衔接 人  机器//java 中 +： 关键字//scala中+： 方法/函数//scala语法中，没有基本类型，所以你写一个数字  3  编辑器/语法，其实是把 3 看待成Int这个对象
//    3 + 2
//    3.+(2)
//    3:Int}/*学习scala就是为了多学一门语言吧？感觉不如python，不仅学了语言，也学了工具。理解有哪些偏差？ 老师？？编译型  C   《   贼快解释型  python   《   慢  贼慢JAVA：其实不值钱，最值钱的是JVMJAVA：  解释型，编译过程，类型   比 python 快JVM：为什么值钱  是C写的， 【字节码（二进制） >JVM（堆/堆外（二进制））<  kernel（mmap，sendfile） 】  更快！！*/}

Collections

import java.utilimport scala.collection.mutable
import scala.collection.mutable.ListBufferobject Lesson03_Collections {def main(args: Array[String]): Unit = {//你是一个javacoderval listJava = new util.LinkedList[String]()listJava.add("hello")//scala还有自己的collections//1.数组//Java中泛型是<>  scala中是[]，所以数组用（n）//  val 约等于 final  不可变描述的是val指定的引用的值（值：字面值，地址）val arr01 = Array[Int](1,2,3,4)
//    arr01=Array(1,2,3,3,3,3)arr01(1)=99println(   arr01(0)  )for (elem <- arr01) {println(elem)}//遍历元素，需要函数接收元素arr01.foreach(println)println("--------------list-------------")//2.链表//scala中collections中有个2个包：immutable，mutable  默认的是不可变的immutableval list01 = List(1,2,3,4,5,4,3,2,1)for (elem <- list01) {println(elem)}list01.foreach(println)
//    list01.+=(22)val list02 = new ListBuffer[Int]()list02.+=(33)list02.+=(34)list02.+=(35)//TODO:学习  scala数据集中的  ++ +=  ++：  ：++list02.foreach(println)println("--------------Set-------------")val set01: Set[Int] = Set(1,2,3,4,2,1)for (elem <- set01) {println(elem)}set01.foreach(println)import scala.collection.mutable.Setval set02: mutable.Set[Int] = Set(11,22,33,44,11)set02.add(88)set02.foreach(println)val set03: Predef.Set[Int] = scala.collection.immutable.Set(33,44,22,11)
//    set03.addprintln("--------------tuple-------------")//    val t2 = new Tuple2(11,"sdfsdf")  //2元素的Tuple2  在scala描绘的是K,Vval t2 = (11,"sdfsdf")  //2元素的Tuple2  在scala描绘的是K,Vval t3 = Tuple3(22,"sdfsdf",'s')val t4: (Int, Int, Int, Int) = (1,2,3,4)val t22: ((Int, Int) => Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int) = ( (a:Int,b:Int)=>a+b+8   ,2,3,4,5,6,7,8,9,1,2,3,4,5,6,7,8,9,1,2,3,4)println(t2._1)println(t4._3)
//    val i: Int = t22._1(8)
//    println(i)println(t22._1)val tIter: Iterator[Any] = t22.productIteratorwhile(tIter.hasNext){println(tIter.next())}println("--------------map-------------")val map01: Map[String, Int] = Map( ("a",33) ,  "b"->22  ,("c",3434),("a",3333)  )val keys: Iterable[String] = map01.keys//option: none  someprintln(map01.get("a").get)
//    println(map01.get("w").get)println(map01.get("a").getOrElse("hello world"))println(map01.get("w").getOrElse("hello world"))for (elem <- keys) {println(s"key: $elem   value: ${map01.get(elem).get}")}//    keys.foreach()val map02: mutable.Map[String, Int] = scala.collection.mutable.Map(("a",11),("b",22))map02.put("c",22)println("--------------艺术-------------")val list = List(1,2,3,4,5,6)list.foreach(println)val listMap: List[Int] = list.map( (x:Int) => x+10  )listMap.foreach(println)val listMap02: List[Int] = list.map(  _*10 )list.foreach(println)listMap02.foreach(println)println("--------------艺术-升华------------")val listStr = List("hello world","hello msb","good idea")
//        val listStr = Array(
//      "hello world",
//      "hello msb",
//      "good idea"
//    )
//        val listStr = Set(
//      "hello world",
//      "hello msb",
//      "good idea"
//    )val flatMap= listStr.flatMap(  (x:String)=> x.split(" ") )flatMap.foreach(println)val mapList = flatMap.map( (_,1) )mapList.foreach(println)//以上代码有什么问题吗？  内存扩大了N倍，每一步计算内存都留有对象数据；有没有什么现成的技术解决数据计算中间状态占用内存这一问题~？//iterator！！！！！println("--------------艺术-再-升华------------")//基于迭代器的原码分析val iter: Iterator[String] = listStr.iterator  //什么是迭代器，为什么会有迭代器模式？  迭代器里不存数据！val iterFlatMap= iter.flatMap(  (x:String)=> x.split(" ") )
//    iterFlatMap.foreach(println)val iterMapList = iterFlatMap.map( (_,1) )while(iterMapList.hasNext){val tuple: (String, Int) = iterMapList.next()println(tuple)}//    iterMapList.foreach(println)//1.listStr真正的数据集，有数据的//2.iter.flatMap  没有发生计算，返回了一个新的迭代器}}

  1. iterMapList想要值发现没有，从iterFlatMap中拿
  2. iteratorFlatMap发现没有值，从listStr中拿取
  3. 拿到后hasNext有值了，加载到cur中，hello world，根据也去分割后返回hello给iterMapList
  4. 调用next方法，打印，继续拿world。
  5. 当hello world拿完后，再向iterFlatMap中拿，iterFlatMap向listStr中拿

有点像双亲委派机制，但又不是。这是迭代器的好处，在中间维护一个指针索引位置，一个cur元素大小即可，不需要多个内容保存在缓存中，占用空间。

高级

trait

多继承


trait  God{def say(): Unit ={println("god...say")}
}trait Mg{def ku(): Unit ={println("mg...say")}def haiRen():Unit
}class Person(name:String)  extends   God with Mg{def hello(): Unit ={println(s"$name say hello")}override def haiRen(): Unit = {println("ziji shixian ....")}
}object Lesson04_trait {def main(args: Array[String]): Unit = {val p = new Person("zhangsan")p.hello()p.say()p.ku()p.haiRen()}
}

case_class

样例类

case class Dog(name:String,age:Int){}object Lesson05_case_class {def main(args: Array[String]): Unit = {val dog1 =  Dog("hsq",18)val dog2 =  Dog("hsq",18)println(dog1.equals(dog2))println(dog1 == dog2)}}

match

匹配

object Lesson06_match {def main(args: Array[String]): Unit = {val tup: (Double, Int, String, Boolean, Int) = (1.0,88,"abc",false,44)val iter: Iterator[Any] = tup.productIteratorval res: Iterator[Unit] = iter.map((x) => {x match {case 1 => println(s"$x...is 1")case 88 => println(s"$x ...is 88")case false => println(s"$x...is false")case w: Int if w > 50 => println(s"$w...is  > 50")case _ => println("wo ye bu zhi dao sha lei xing ")}})while(res.hasNext)  println(res.next())}}

PartialFunction

偏移函数

object Lesson07_PartialFunction {def main(args: Array[String]): Unit = {def xxx:PartialFunction[  Any,String] ={case "hello"  => "val is hello"case x:Int => s"$x...is int"case _ => "none"}println(xxx(44))println(xxx("hello"))println(xxx("hi"))}}

Implicit

隐式转换

扩展

import java.utilobject Lesson08_implicit {def main(args: Array[String]): Unit = {val listLinked = new util.LinkedList[Int]()listLinked.add(1)listLinked.add(2)listLinked.add(3)val listArray = new util.ArrayList[Int]()listArray.add(1)listArray.add(2)listArray.add(3)//    list.foreach(println)   //3个东西：  list数据集  foreach 遍历行为  println 处理函数//    def foreach[T](list:util.LinkedList[T], f:(T)=>Unit): Unit ={//      val iter: util.Iterator[T] = list.iterator()
//      while(iter.hasNext) f(iter.next())
//    }//    foreach(list,println)//    val xx = new XXX(list)
//    xx.foreach(println)//隐式转换：  隐式转换方法implicit def sdfsdf[T](list:util.LinkedList[T]) ={val iter: util.Iterator[T] = list.iterator()new XXX(iter)}implicit def sldkfjskldfj[T](list:java.util.ArrayList[T]) ={val iter: util.Iterator[T] = list.iterator()new XXX(iter)}listLinked.foreach(println)listArray.foreach(println)//spark  RDD N方法 scala//隐式转换类
//    implicit  class KKK[T](list:util.LinkedList[T]){//      def foreach( f:(T)=>Unit): Unit ={//        val iter: util.Iterator[T] = list.iterator()
//        while(iter.hasNext) f(iter.next())
//      }
//    }
//    list.foreach(println) //必须先承认一件事情：  list有foreach方法吗？  肯定是没有的~！ 在java里这么写肯定报错。。//这些代码最终交给的是scala的编译器！/*1,scala编译器发现 list.foreach(println)  有bug2,去寻找有没有implicit  定义的方法，且方法的参数正好是list的类型！！！3,编译期：完成你曾经人类：//    val xx = new XXX(list)
//    xx.foreach(println)*，编译器帮你把代码改写了。。。！*/implicit val sdfsdfsd:String = "werwe"
//    implicit val sdfsdfs:String = "wangwu"implicit val sssss:Int = 88def ooxx(age:Int)(implicit name:String ): Unit ={println(name+" "+age)}//    def sdfsf(name:String = "wangwu")//    ooxx("zhangsan")ooxx(66)("jkljkl")ooxx(66)}
}class XXX[T](list:util.Iterator[T]){def foreach( f:(T)=>Unit): Unit ={while(list.hasNext) f(list.next())}}//class XXX[T](list:util.LinkedList[T]){//
//  def foreach( f:(T)=>Unit): Unit ={//    val iter: util.Iterator[T] = list.iterator()
//    while(iter.hasNext) f(iter.next())
//  }
//
//}

Spark-和java的区别，语法和高级特性学习相关推荐

  1. 华为架构师撰写的Netty核心笔记，从Java NIO到Netty的高级特性

    众所周知,Netty 作为当前流行的 NIO 框架,操作省时.省事还安全,在云计算.大数据通讯,电商.游戏等领域都有广泛的应用.如果是一个大型网站,内部接口非常多的情况下,好处很明显--首先就是长链接 ...

  2. Java核心技术卷2 高级特性 学习笔记（5）

    参考:Java核心技术卷2 高级特性  第九章 Java技术提供了三种确保安全的机制: 语言设计特性(对数组的边界进行检查,无不受检查的类型转换,无指针算法等). 访问控制机制,用于控制代码能够执行的 ...

  3. redis高级特性学习(慢查询、Pipeline、事务、Lua)（上）

    Redis高级特性和应用(慢查询.Pipeline.事务.Lua) Redis的慢查询 许多存储系统(例如 MySQL)提供慢查询日志帮助开发和运维人员定位系统存在的慢操作.所谓慢查询日志就是系统在命 ...

  4. java 类型不可视_jvm高级特性(5)(1)（原子性,可见性,有序性，volatile，概述)

    简介: 阿姆达尔定律(Amdahl):该定律通过系统中并行化与串行化的比重来描述多处理器系统能获得的运算加速能力. 摩尔定律(Moore):该定律用于描述处理器晶体管数量与运行效率间的发展关系. 当价 ...

  5. Java多线程与并发库高级应用 学习笔记 1-9课

    来源XXX,免得打广告嫌疑. http://www.cnblogs.com/whgw/archive/2011/10/03/2198506.html 今天看了文章才发现创建线程最佳方式为实现Runna ...

  6. redis java根据value排序_Redis高级特性——排序

    排序 对于排序的场景,在业务中会大量使用到,对于Redis,如果使用了有序集合,那么排序问题很容易解决,并且得分可以根据实际的业务,由时间.点赞.费用.排行等等进行转化,支持的业务范围也比较广泛. 除 ...

  7. JAVA攻城狮:JAVA核心第11版 卷1基础知识，卷2高级特性+JAVA编思第4版(中)

    <JAVA核心技术第11版卷1,2> Java核心技术与Thinking in Java(Java编程思想)齐名的 Core Java.2018年9月才出版的英文原版,包括了Java9,J ...

  8. 《Java核心技术 卷Ⅱ　高级特性（原书第10版）》一导读

    前 言 致读者 本书是按照Java SE 8完全更新后的<Java核心技术 卷Ⅱ 高级特性(原书第10版)>.卷Ⅰ主要介绍了Java语言的一些关键特性:而本卷主要介绍编程人员进行专业软件开 ...

  9. java与javaScript 语法的区别

    目录 前言 一.java和javaScript是什么?有何不同? 1.java简介 2.javaScript简介 二,语法区别 -1.语法基础 java语言基础 Js语法基础 -2.数据类型 java ...

最新文章

  1. Windows中报错：Fatal error in launcher: Unable to create process using ‘“‘ 的解决方案
  2. svn 主干和分支项目代码更新与同步
  3. 那些年，我在西安的“遇见”（一）
  4. php导出数据库的指定表数据,MYSQL教程mysql数据库导出指定表数据的方法
  5. firefox是什么浏览器_Selenium Firefox驱动程序：使用Firefox浏览器自动进行测试
  6. 设备树中#address-cells和#size-cells作用
  7. 被360整的体无完肤，我真的怒了！
  8. c语言123 u0010%10,mbsrtowcs_s
  9. 如何使用Aimersoft Video Suite Mac将 DVD 刻录到 ISO/DVD 文件夹
  10. asp.net 后台方法和js方法互动
  11. 秋名山直播php源码,【斗鱼直播源】浏览器抓取真实直播源地址(纯前端JS PHP解析源码)...
  12. 在FL Studio中如何使用Patcher插件
  13. 计算机基础知识刷题app,计算机考试刷题app
  14. VMware Tools手动安装
  15. 轨迹跟踪——二维轨迹跟踪
  16. EMI、EMS以及EMC的区别
  17. PHP前一页 后一页 切换
  18. 爆火的Web3.0背后，百度营销如何抓住流量密码？
  19. zynq PS端通过EMIO访问PL资源
  20. nestjs[typeorm学习之一对一表关系探究与使用]

热门文章

  1. Android 多线程-----AsyncTask详解（康小岱已读）
  2. 区块链100讲：Hyperledger Fabric 区块链多机部署
  3. pythonturtle绘图代码 独角兽_Python刮擦给了独角兽
  4. java 最少货币单元组合换钱_动态规划. 换钱的最少货币数和最多方法数
  5. 给女朋友讲 : Java线程池的内部原理
  6. 羡慕大劳星空顶？不如跟我一起使用 Jetpack compose 绘制一个星空背景（带流星动画）
  7. 关心房价的朋友看看，或许有些道理
  8. apex英雄机器人探路者怎么玩_apex英雄探路者机器人玩法攻略详解
  9. 对DW（数仓）的理解
  10. 【计算机视觉】Mip-nerf 论文精读记录