Scala

Scala

面向对象、函数式编程、更高层的并发模型—里面包含编译器、类库

它不存在成员变量，经过object（单例）取代

函数处理：能够吧函数化成一个参数传过去

Object：入口类关键字-项目入口 相似于Java中的main方法

Def:函数声明—定义一个方法/函数

Val:常量声明

Any:公共超类型 scala中父类

Unit：返回值为空—Java中的void（）

伴生对象：object修饰的对象，其中存放的是静态方法、属性  --对象声明

伴生类：class修饰的类，存放的非静态方法、属性     类声明

 

Scala中无任何操做符，全部操做符运算都是对方法的调用？？？？？

For(i<-1 to/until 10) 表示1—10（to表示包含10/until表示不包含10）

特质：Function2 有两个参数的函数  （两个参数一个返回值）

函数式对象，方法（成员）不是对象

方法经过methodname转化成函数，当吧方法做为参数传递的时候，scala会自动把方法转成函数

递归方法须要指定返回值类型

Head：头    tail：出去头之外的其余元素序列

Init：除最后一个，全部元素

函数体在{}中，但没有前面的=号，那么返回值类型是unit，这样的函数叫过程

调用它是为了使用它的反作用，好比：打印图案

.mkstring  打印集合中内容，以字符串显示

.filter（）   过滤掉参数中为false的元素

 

Scala集合

特质：就是Java中的接口

在scala中[ ] 表示泛型

输入=>输出

元素拼接集合   ：：

集合拼接集合   ：：：  两个集合是list类型

：+ 在尾部追加元素     + ：在头部

++   链接两个集合

Flateen  平坦化  List(list(1,2,3),List(12,23))-àList(1,2,3,12,23)

将嵌套的结构展开，将里面的每一个list去掉

 

Map

Groupby:就是把一个东西变成map

List.apply()  建立一个list对象，通常apply（）省略不写

Seq(相似于list集合)  有前后次序的序列    indexedseq

Set  不可重复，可是无序的集合，list是可重复，有序的集合

Map 存放，keyvalue键值对构成的对偶的映射，sortedMap  map中能够嵌套集合

Scala全部集合都扩展了iterable特质

Foreach() 遍历   提交任务

 

Scala可变集合

1. 数组 Array（1,2,3）长度固定，数值可变
2. ListBuffer（相似于Java中的ArrayList） 添加+=   删除  remove
3. Hashmap  更新/添加   +=（”k1”->”k2”）

List中的一些方法

.distinct 去重

.sortwith 以字典序排序

.intersect 交集

 

Scala隐士转换

 

scala隐式转换

背景：设计模式中有代理模式，能够加强一个类的功能。

java中有静态代理和动态代理。但实现起来繁琐。

scala中的隐式转换能够方便的实现代理。

 

定义：

当被代理类调用了一个不存在方法或者值的时候，scala编译器会查看调用上线文，查找是否存在该方法或者值。若是有则会隐式的将被代理类转换成代理类。继而执行方法或者值。

 

实例：

scala中的Int 有不少方法，都是经过将Int 隐式转换为RichInt来实现。

 

关键字：

implicit(隐式地)

 

使用：

三大隐式转换：隐式类，隐式函数，隐式参数

 

代码：

object ImplicitDemo {

  class Dog{

    def sing={

      println("wang wang wang")

    }

  }

  //定义隐式函数须要须要加上implicit关键字

  implicit def dogToString(dog: Dog)="dog"

  //定义隐式类须要须要加上implicit关键字

  implicit class RichDog(dog: Dog){

    def singOpera={

      println("bei jing opera")

    }

    //定义隐式值须要须要加上implicit关键字

    def say(implicit a:Int)=println(a)

  }

  def main(args: Array[String]): Unit = {

      new Dog().sing

    //隐式类转换

      new Dog().singOpera

    //隐式函数转换

      println(new Dog()+"abc")

    //隐式值

      implicit val a=1;

      new Dog().say

  }

}

 

注意：

若是隐式类跟被代理类不在同一个包中，须要导入隐式类所在的包。

 

 

不修改原有代码，扩展功能  实现代理

当被代理类调用一个其没有的方法和属性时，不会直接报错，scala编译器

会先查看上下文，查找是否有该方法或者属性，则会隐士的将代理类（含有该

或属性的类转化成代理类）

 

隐士类  implicit  class 类名（参数）

隐士函数  implicit  def  函数名（参数）

隐士属性  implicit  val  参数名=值 

上面的参数：表示要被转换的对象

 

Import  spark.implicit._

隐士类与被代理类不在同一个包中，须要导入隐士类所在的包

 

Scala模式类和模式匹配

背景：在开发中须要定义pojo类来封装业务对象。一个pojo是有一系列字段以及set，get方法组成的。在java中，须要经过IDE帮咱们生成set get 构造 toString 等方法，相对繁琐。scala简化了pojo代码的编写。

至关于Java中的pojo  （case class）

定义模式类

Case class  类名（字段1：类型，a:String）

使用模式类

直接  new  类名（参数1，参数。。。。）

模式匹配

def myPrint(any: Any)={

    any match{

      case 1=>println("this is num "+any)

      case string:String=>println("this is string "+any)

      case int:Int=>println("this is int "+any)

      case Dog("luck",12)=>new Student().run

      case Dog("jack",12)=>new Student().run("jack")

      case Dog(name,age)=>new Student().sing()

      case _=>println("default")

    }

  }

值、类型、对象

 

Scala与Java互相调用

类型只有一个String一致

 

在Java中不能使用scala集合，不可高级函数的调用，可将scala集合放在Java方法中

Scala调用Java API（集合、io、网络、第三方依赖）只需遵循 scala的规范便可

Java集合转成scala集合  .asScala

Scala集合转成Java集合  .asJava

Scala集合比Java集合强大，通常不调用

 

Scala--IO

flatMap=flattent+map

map 对集合的转换

foreach  遍历集合，适用于io

读取文本文件  source.fromFile（“”）.mkstring