Scala学习之路

最新推荐文章于 2024-05-28 17:45:14 发布

Supper宝宝

最新推荐文章于 2024-05-28 17:45:14 发布

阅读量886

点赞数

文章标签： scal

本文链接：https://blog.csdn.net/kebexue/article/details/86499955

版权

-》Scala简介

-》Scala 版本：

scala-2.12.4

语音	编译	执行	扩展名
java	javac	java	java
scala	scalac	scala	scala

-》数据类型

java	scala
byte/char/short/int/long/float/double/boolean/void/string	string/byte/char/short/int/long/float/double/boolean/unit

-》变量定义

java

scala

类型变量名

val 不可变的

var可变的

指定类型时需要，赋值需要跟类型保持一致

val a:int=3 （正确） val b:int = 2.1（错误）

Uint = （）；（）相当于什么也没有

-》混合类型

scala> if (d>0) "error" else 2
res11: Any = error 相当于java的object

d
res12: Int = 5

scala> val m = if(d>=5) 1
m: AnyVal = 1

AnyRef：

Anyval ：包含所有的scala类型

scala> val m = if(d<0) 1 else if (d>0) d else -1
m: Int = 5

val r = for(i<- 1 to 10) yield i*10
r: scala.collection.immutable.IndexedSeq[Int] = Vector(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)

scala> r
res13: scala.collection.immutable.IndexedSeq[Int] = Vector(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)

scala> 1.to(10)
res14: scala.collection.immutable.Range.Inclusive = Range 1 to 10

scala> 1.to(10).map(_*100)
res15: scala.collection.immutable.IndexedSeq[Int] = Vector(100, 200, 300, 400, 500, 600, 700, 800, 900, 1000)

map;取出元素

_：代表元组

-》代码生成器：
scala> for(i <- 1 to 10; if(i%2 == 0 )) yield i
res10: scala.collection.immutable.IndexedSeq[Int] = Vector(2, 4, 6, 8, 10)

scala>

1 to 10 == 1.to(10) 等价

+ - * % 的作用和java一样，但是操作符实际上是方法

方法定义：

def add(a:Int,b:Int):Int = {
  a + b
}

def 定义方法的关键字

add ：函数名

a：参数

Int参数类型

：Int 返回值类型

a+b函数体

-》函数定义

val st = (a:Int,b：Int)=>{a+b}

可变参数使用 *代表同类参数

如果不确定类型 Any*表示任意类型

返回值也为Any

package com.alex.scalatest

object ScalaDemo {
方法定义
  def add(a:Int,b:Int):Int = {
    a + b
  }

//可变参数
  def many(int:Int*):Int = {
    var sum = 0
    for(v <- int){
      sum += v
    }
    sum
  }

   //默认参数
  def defaulttest(a:Int=100,b:Int=200,c:Int):Int = {
    a * b *c
  }

  def main(args: Array[String]): Unit = {
    for(i <- 1 to 10){
      println(i)
    }

    println(add(2,8))
    println(many(100,200,300,400))
     println(many(12345678,567899,6789))
    print(defaulttest(100,200,500))
  }
}

-》格式化输出：f或s

-》柯理化

将多个参数的函数改为传一个参数的函数

def test (a:Int,b；Int)：Int={}

==》def test(a:Int)(b:Int):Int ={}

-》闭包：

闭包是一个函数，返回值依赖于声明在函数外部的一个或多个变量。

闭包通常来讲可以简单的认为是可以访问一个函数里面局部变量的另外一个函数

var factor = 3  
val multiplier = (i:Int) => i * factor

-》偏应用函数

def log(date:Date,name:String) = {
  println(s"date$date---------String:$name")
}

val date = new Date
val message = log(date,_:String)
message("Alex")
message("Amy")
message("Mia")

-》Scala 指定函数参数名

一般情况下函数调用参数，就按照函数定义时的参数顺序一个个传递。但是我们也可以通过指定函数参数名，并且不需要按照顺序向函数传递参数

object Test {
   def main(args: Array[String]) {
        printInt(b=5, a=7);
   }
   def printInt( a:Int, b:Int ) = {
      println("Value of a : " + a );
      println("Value of b : " + b );
   }
}

-》递归函数

def factorial(i:Int):Int = {
  if(i<=1)
  {
    return 1
  }
  else
  {
    i * factorial(i-1)
  }
}

-》偏函数

函数定义【String参数类型, Int返回值类型】

def test4:PartialFunction[String, Int] ={
  case "Alex" => 35
  case "Mia"  => 1
  case _      =>3
}

val arr = Array("nice to meet you", "Hello World")
arr: Array[String] = Array(nice to meet you, Hello World)

scala> arr.map
<console>:13: error: missing argument list for method map in trait TraversableLike
Unapplied methods are only converted to functions when a function type is expected.
You can make this conversion explicit by writing `map _` or `map(_)(_)` instead of `map`.
arr.map
^

scala> arr.map(_.split(" "))
res1: Array[Array[String]] = Array(Array(nice, to, meet, you), Array(Hello, World))

scala> arr.map(_.split(" ")).flatten

def flatten[U](implicit asTrav: Array[String] => Traversable[U],implicit m: scala.reflect.ClassTag[U]): Array[U]
def flatten[B](implicit asTraversable: Array[String] => scala.collection.GenTraversableOnce[B]): scala.collection.mutable.IndexedSeq[B]

scala> arr.map(_.split(" ")).flatten
res2: Array[String] = Array(nice, to, meet, you, Hello, World)

scala> arr.flatmap
<console>:13: error: value flatmap is not a member of Array[String]
arr.flatmap
^

scala> arr.flatmap(_.split(" "))
<console>:13: error: value flatmap is not a member of Array[String]
arr.flatmap(_.split(" "))
^

scala> arr.flatMap(_.split(" "))
res5: Array[String] = Array(nice, to, meet, you, Hello, World

-》长度可变的数组

scala> val td = scala.collection.mutable.ArrayBuffer(2,3,4,5)
td: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(2, 3, 4, 5)

scala> td += 666
res0: td.type = ArrayBuffer(2, 3, 4, 5, 666)

-》map体现的是映射关系

flatten将多个数组里的数据扁平化

flatMap = map +flatten

arrt.flatMap(_.split(" "))
res23: Array[String] = Array(hello, Amy, i, love, u, Hello, yun, Welcome, to, shanghai)

split切分

arrt.map(_.split(" "))将多个值按照空格进行切分

foreach进行将多个数据进行打印，遍历数组中的数据

arrt.foreach(x->println(x))

scala> arrt.foreach(x=>println(x))
hello yun i love u
Hello yun Welcome to shanghai

scala> arrt.foreach(x=>print(x))
hello yun i love uHello yun Welcome to shanghai
scala> arrt.foreach(x=>println(x))
hello yun i love u
Hello yun Welcome to shanghai

scala> res5.foreach(r=>println(r))
nice
to
meet
you
Hello
World

wordCount程序

-》分组

scala>arr.flatMap(_.split(" ")).groupBy(x=>(x)).map(x=>(x._1,x._2.length))
res18: scala.collection.immutable.Map[String,Int] = Map(nice -> 1, to -> 1, you -> 1, Hello -> 1, meet -> 1, World -> 1)

-》排序

scala> test.flatMap(_.split(" ")).groupBy(x=>(x)).map(x=>(x._1,x._2.length)).toList.sortBy(x=>(x._2))
res31: List[(String, Int)] = List((Dream,1), (Hello,1), (Two,1), (World,2), (One,3))

scala> test.flatMap(_.split(" ")).groupBy(x=>(x)).map(x=>(x._1,x._2.length)).toList.sortBy(x=>(-x._2))
res32: List[(String, Int)] = List((One,3), (World,2), (Dream,1), (Hello,1), (Two,1))

-》集合import scala.collection.mutable._

不可变集合

List

可变集合

ArrayBuffer()

val arrt1 = ArrayBuffer(2,3,4)
arrt1: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(2, 3, 4)-.->

->Seq序列：

不可变的序列

字符串的拼接：

++、:::两个集合相加

++：合并集合。

.+：头部追加

：+尾部追加

scala> ll.+:(66)
res13: List[Int] = List(66, 2, 3, 4, 5, 6)

scala> ll+:.(77)
<console>:1: error: ';' expected but '.' found.
ll+:.(77)
^

scala> ll:+(77)
res14: List[Int] = List(2, 3, 4, 5, 6, 77)

count 统计个数

ll.count(x=>x%2==0)
res17: Int = 3

filter过滤

sortBy排序

sortWith排序

scala> val tt = List(("g",2),("h",6),("g",8),("y",1))
tt: List[(String, Int)] = List((g,2), (h,6), (g,8), (y,1))

scala> tt.sortWith((x,y)=>x._2 >y._2)
res20: List[(String, Int)] = List((g,8), (h,6), (g,2), (y,1))

scala> tt.sortWith((x,y)=>x._2 <y._2)
<console>:1: error: ')' expected but $XMLSTART$< found.
tt.sortWith((x,y)=>x._2 <y._2)
^

scala> tt.sortWith((x,y)=>x._2 < y._2)
res21: List[(String, Int)] = List((y,1), (g,2), (h,6), (g,8))

grouped分组

scala>

tt.grouped(2).toList
res24: List[List[(String, Int)]] = List(List((g,2), (h,6)), List((g,8), (y,1)))

Fold折叠

左、右折叠

规则：默认为左折叠（（（初始值）-3）-4 ）-7

右折叠 3-（4-（7-1））=5

Reduce 依次叠加

aggregate

底层采用的是foldLeft左折叠

zip拉链

将一致的数据聚合到一起

Set

无序的、不可重复

不可变的集合

Map

put 增加元素，get获取元素

remove删除元素 -= 删除元素

getOrElse 获取值，如果有值正常输出，如果没有值则直接输出默认值

集合的学习

单例对象

特点：

1）单例对象中的成员变量和方法可以直接采用类名.变量和类名.方法去访问

2）申明类时采用Object的形式

3）单例模式的调用

类

1）主构造器：在类声明时指定

2）辅助构造器：采用this的形式，调用时先调用主构造器

如果想访问主构造器中的成员，需要指定参数的类型，否则不可访问

构造器的访问权限

被private修饰的主构造器或辅助构造器不能被外界访问，运行时会报错

类的访问权限

在类的前面加private【this】表示的是该包下的类可以访问，其他不能访问，如果去掉shis，本包内也不能访问

伴生对象：单例对象和类名一致

apply方法必须写在伴生对象中

抽象字段：没有做初始化的字段

特质trait，不支持多继承

类似java的interface，定义方法，然后其他类去继承来实现

trait demo1 ()

混入特质：继承一个类，实现多个特质

抽象类

修饰符abstract

模式匹配;

## 关键字

final ：如果特质里的方法不想被重写，用final修饰，但是final不能修饰未有实现的函数

final修饰：

类：不能被继承

方法：不能被重写

type:

定义特质的时候，可以不指定类型

样例类：

在类的前面加个case，并且支持模式匹配

### 并发编程框架AKKA

特点：

1）akka构建在JVM平台上，是一种高并发、分布式并且容错的应用工具包

2）对并发模型进行更高的抽象

3）异步，非阻塞，高性能的事件驱动编程模型

4）轻量级事件处理1G内存容纳百万的Actor

同步：阻塞（发消息，一直等待消息）

核心程序：通过ActorSystem创建Actor

隐式

implicit分类：

1）隐式分类

2）隐式类型转换

3）隐式类

特点：让代码变的更灵活

如果不加隐式implicit，调用时必须加（），如果加了implicit，可加可不加

隐式值会覆盖掉默认值

隐式转换类型

隐式类：

# MLib

MLlib is Apache Spark's scalable machine learning library.MLlib是Apache Spark的可扩展机器学习库

MLlib包含许多算法和实用程序。

ML算法包括：

分类：逻辑回归，朴素贝叶斯，......
回归：广义线性回归，生存回归，......
决策树，随机森林和梯度提升树
建议：交替最小二乘法（ALS）
聚类：K均值，高斯混合（GMM），......
主题建模：潜在Dirichlet分配（LDA）
频繁项目集，关联规则和顺序模式挖掘

ML工作流程工具包括：

特征转换：标准化，规范化，散列，......
ML管道施工
模型评估和超参数调整
ML持久性：保存和加载模型和管道

其他工具包括：

分布式线性代数：SVD，PCA，......
统计：汇总统计，假设检验，......

Supper宝宝

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Scala学习之路

-》Scala简介-》Scala 版本：scala-2.12.4语音编译执行扩展名 java javac java java scala scalac scala scala -》数据类型java scala byte/char/short/int/long/float/double/boolean/...
复制链接

扫一扫