Scala

Scala特性

1、跨平台性：因为Scala语言编译之后也是会生成.class文件所有可以用JVM进行执行，所以有跨平台性
2、类型推断：不用定义变量类型，直接写值，可以推断出是什么类型
3、并发性和分布式
4、抽象类和接口的融合
5、模式匹配，，在switch中可以判断类型
6、高阶函数：返回值类型和表达式都是函数

Scala语法

定义类

class TextScala(){
var a = “ssss”;
def eat(food:String):Unit={
println(food);
}
println(“这是类中的方法”)
}

创建类的对象

var a = new TextScala();

scala中的类里可以定义

1.方法
2.属性
3.语句

scala中类的构造器

scala中类是可以传参数的
编译器会给这个类一个和这个类的参数一样的构造器

scala重载构造器

def this(ss:String) {
//父类的构造器
this();
this.ss = ss;
}

Scala定义object

Object TextScala{
def main(args:Arrays[String]):Unit={

}
}

Scala的Object中能定义什么

1.定义变量
2.定义方法
3.定义类
4.定义语句

调用类中的属性

直接对象.属性名
a.name;

控制语句

if

和java的if语句不同之处在于在scala中的if语句可以有返回值返回值就是最后一行的值。

var a = 4;
     var b =if(a>0){
      println("是整数");
      99
    }

for

//格式：
for(i <- 1 to 10){
print(i);

}

哨位模式

for（i <- 1 to 10 if (i%2==0)）{
	print("这是个偶数")
}

集合

Array

创建Array

//初始化数组
var a = Array(12,44,23);
//初始化数组并规定泛型
var a = Array [int] (45,56,6);
//定长数组
var a =new Array[int] (3);
//数组赋值
a(0)=1;
//数组遍历
for(i <- a){
print(i);
}
a.foreach(x =>print(x)));
a.foreach(println(_));
//求数组的和
a.sum;
//求数组的最大值
a.max
//求数组的最小值
a.min
//对数组进行升序排序 
a.sorted
//对数组进行降序排序
a.sorted.revese

变长数组

//定义数组
var a =new ArrayBuffer[int]();
//向其中添加元素
a+=1
//数组合并
val ints: Array[Int] = Array[Int](12,44,88) 
val ints1: Array[Int] = Array[Int](99,11,22) 
println(ints1++=ints);
//插入元素（只能可变长数组）
a.insert;

List

特点：操作不改变本身的值
//创建List
var nums :List[int] = List(1,2,3,4)
//在该List的头部追加一个元素1，生成一个新的List
var nums2=nums.+:(1)
//在该List的尾部追加一个元素，生成一个新的List
var nums3=nums:+5
//合并List
var num4 = num2++:num3

可变List

//创建可初始化的可变List
val listBuffer = ListBuffer(1,2,3)
//创建不初始化的ListBuffer
var listBuffer = new ListBufferint;
//插入数据
listBuffer+=1；

Set

//定义set集合
    var a = Set(1,2,1,"84");
    //遍历set集合
    a.foreach(println(_));
    //输出首元素
    val head: Any = a.head
    //输出除首元素外的其他元素
    println(a.tail);
    //查看元素是否为空
    println(a.isEmpty);
    //连接两个set集合
    var b = Set(1,78,96,77);
    val set: Set[Any] = a++b;
    //输出set集合中的最大值
    println(set.max);
    //输出set集合中的最小值
    println(set.min);
    //输出两个集合的交集
    println(set.&(a));
    println(set.intersect(a));

map

//定义map集合
    var map1 = Map(1 -> "hello",2 -> "world",22->33);
    var map2 = Map((2,44),(3,"hello"),(4,"world"));
    var map3 = Map[Int,String]((2,"people"),(3,"dd"));
    //循环遍历map
    map1.foreach(println(_));
    val iterator: Iterator[(Int, Any)] = map1.iterator;
    while(iterator.hasNext){
      println(iterator.next());
    }
    //取key
    println(map1.keys);
    println(map1.keySet);
    //取value
    println(map1.values);
    //取数
    println(map1.get(1)); //取回来的数是option类型的如果取的key有value则返回Some(value),如果没有则返回None
    println(map1.toString());
    map1(1);
    //向map中添加元素
    map1+=((232,33));
    //对map减少元素
    map1-=1;

元组

 //定义元组,元组只能指定长度为小于21,且不能小于也不能大于，只能等于
       var tuple = Tuple2(1,5);
    //定义不定长元组（长度也必须小于21）
    var tuple1 = (1,5,4,8,7,5);
    //元组取值
    println(tuple._1);
    //元组倒叙
    println(tuple.swap);
    //输出元组
    val iterator1: Iterator[Any] = tuple.productIterator
    iterator1.foreach(println(_))

函数和方法

方法

 //正常函数
    def fun1(a:Int,b:Int):Int={
      a+b;
    }
    //递归函数(必须指明返回值类型)
    def fun2(a:Int):Int={
      if (a==1){
        a
      }else{
        a*fun2(a-1)
      }
    }

    println(fun2(3))
    //默认参数方法
    def fun3(a:Int=10,b:Int): Int ={
      a+b*a;
    }

    println(fun3(b = 33))
    //可变参数方法
    def fun4(a:Int*){
      var sum = 0 ;
      for (i <- a){
        sum+=i;
      }
      sum
    }
    print(fun4(12,48,7,6,9));
    //偏函数
    def logs(d:Date,l:String): Unit ={
      println(d+"====="+l)
    }
    var date = new Date();
    var log = logs(date,_:String);
    log("dd");

函数

//正常函数
      var fun5 = (a:Int,b:Int)=>{a*b}
      println(fun5(55,12))
    //方法转换成函数
      var fun6 = fun2 _;
     println(fun6(5))

高阶函数

//参数是函数的高阶函数
    def fun1(a:Int,b:(Int,Int)=>Int):Int={
        a+b(3,4);
    }

    println(fun1(2, (a: Int, b: Int) => {
      a + b
    }));//结果是9

//返回值是函数的高阶函数
    def fun2(s:Int,iu:Int):(Int,Int)=>Int={
      def fun3(a:Int,b:Int):Int={
        a+s+b
      }
      fun3
    }

    println(fun2(2, 3)(3,4))//结果是9

//返回值，参数是函数的高阶函数
    def fun4(a:Int,b:(Int,Int)=>Int):(Int,Int)=>Int={
      def fun5(c:Int,d:Int):Int={
        c*a+b(3,6)
      }
      fun5
    }

    println(fun4(3, (t: Int, y: Int) => {
      t-y
    })(7, 9))

match（模式匹配）

//值匹配
    val a = 3;
      a match {
        case 1 => println(a+" 是1")
        case 2 => println(a+" 是2")
        case _ => println(a+" 是默认的")
      }

//类型匹配
    val b= List(12,23.33,"lalala",'a',true)
    for( i<-b ){
      i match {
        case i:Int => println(i+"是Int类型")
        case i:Double => println(i+"是Double类型")
        case i:Boolean => println(i+"是boolean类型")
        case i:String => println(i+"是String类型")
        case i:Char => println(i+"是char类型")
        case _ =>println(i+"是默认类型")
      }
    }

//类型和值匹配（配型配型和值没有优先级，只有前后顺序）
    val tuple: (Int, Double, String, String, Boolean) = (12,45.333,"hello","world",true)
    for (i<-tuple.productIterator){
      i match {
                case i:Int => println(i+"是Int类型")
                case 12 => println("值为12")
                case i:Double => println(i+"是Double类型")
                case i:Boolean => println(i+"是boolean类型")
                case i:String => println(i+"是String类型")
                case i:Char => println(i+"是char类型")
                case _ =>println(i+"是默认类型")
              }
    }

//match哨位模式
    for (i <- 1 to 10){
        i match {
          case _ if (i%2==0) => println(i +" 是一个偶数")
          case _ => println(i+ " 是一个奇数")
        }
    }

异常捕获

//scala中的异常捕获机制
    try{
      val a = 10/0;
      //catch和java不同需要和模式匹配中的case连用
    }catch {
      case e:Exception => println(e.getMessage);
      case r:AbstractMethodError => println(r.getMessage)
    }finally {
      println("释放资源！！")
    }

特质类定义，应用

java中抽象类和接口中能 定义的东西在scala的特质类中都能 定义
特质类可以进行实例化
特质类的声明 关键字是trait
特质类在被动态继承的时候用with关键字
特质类在继承其他特质的时候也是用with关键字

def main(args: Array[String]): Unit = {
    //特质可以实例化
    var fly1 = new Flyable {
      override def fly(): Unit = {
        println("我能飞")
      }

      override val a: Int = 150
    }
        println(fly1.a);
        fly1.breath();
        fly1.fly()
        fly1.hight();
    //动态继承特质类
    var T1 = new t1(12) with Flyable {
      override val a: Int = 300

      override def fly(): Unit = {
        println("我最nb");
      }
    }
        T1.eat();
    //静态继承特质类
    val animals = new animal("老鹰")
    animals.Name
    animals.fly()
  }
}

//特质类定义
trait Flyable {
  val a: Int;

  def fly();

  def hight(): Unit = {
    println("能飞" + a + "米");
  }

  def breath(): Unit = {
    println("能呼吸");
  }
}

class t1(a: Int) {
  def eat(): Unit = {
    println("我能吃！！！");
  }
}

//静态继承特质类
class animal(name: String) extends t1(2) with Flyable {
  override val a: Int = 800

  override def fly(): Unit = {
    println("我用翅膀飞！！")
  }

  def Name: Unit = {
    println("我的名字叫" + name)
  }

消息传递模型

Actor模型

Acore模型特征

1、Actor模型是消息传递模型，基本特征就是消息传递
2、消息发送是异步的，非阻塞
3、消息一旦发送成功不能修改（报文不能修改）
4、Actor消息 传递时，是自己决定取检查消息而不是一直等待，是异步非阻塞的

Akka模型

Akka模型是Actor模型的封装 之后的产物，它简化了Actor模型
spark1.6之前就是用Akka模型在分布式节点之间传递消息
spark1.6之后就用netty传递

Actor模型传递消息代码

首先应该在pom.xml文件中添加包
包的版本根据自己的scala版本来判断

<dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-actors</artifactId>
            <version>2.11.8</version>
        </dependency>
        <dependency>
            <groupId>com.typesafe.akka</groupId>
            <artifactId>akka-actor_2.11</artifactId>
            <version>2.3.16</version>
        </dependency>

def main(args: Array[String]): Unit = {
     //创建一个服务端实例对象（客户端）
      var actor101 = new Actor101
    //启动客户端
      actor101.start()
    //向服务端发送数据
      actor101 !"hello"
    }
  }

  class Actor101 extends Actor {
    override def act(): Unit = {
      //服务端接收数据
      receive {
        //模式匹配接收的数据
        case "hello" => println("hello")
        case _ => println("default")
      }

    }

用Akka模型进行消息传递

def main(args: Array[String]): Unit = {
    //建立客户端工厂
    val factory = ActorSystem("factory")
      //创建客户端
    val akka: ActorRef = factory.actorOf(Props[akkas],"akka1")
    //发送消息
    akka !"hello!!!"
    akka !"hello"
  }
}
class akkas extends Actor{
  override def receive: Receive = {
    //接收消息
    case "hello" => println("hello");
    case _ =>println("default")
  }
}

case模板类

模板类是scala中特有的类，它在普通类的基础上封装，重载一些方法

def main(args: Array[String]): Unit = {
    //创建实例化对象
    val car1 = Car("benci",500000);
    val car2 = Car("aodi",300000);
    val car3 = Car("BMW",600000);
    val dog1 = dog("哈士奇",3000);
    //将对象装进list集合中
    val a = List(car1,car2,car3,dog1);
    //对list集合循环进行模式匹配
    for (i <- a){
      //模式匹配首先会匹配类型是否相同，用模板类重载的unappend方法
      i match{
        case Car("baoma",555555) => println("这是宝马");
        case Car("BMW",600000) => println("这是真宝马");
        case Car("aodi",300000) => println("这是奥迪");
        case Car(a,b) => println("这个车的车型是"+a+"  它的价格是"+b)
        case _ => println("这不是车")
      }
    }

  }
}
//创建模板类，模板类中有重载的方法
case class Car(benk:String,price:Int)
case class dog(rpii:String,price:Int)