scala 笔记

scala

声明变量

val 不可变的

var 可变的

val str = “hello world”

val str2 : String = “hello world”

默认导入 inport java,lang._

_代表所有的

基本语法

函数式运算

scala> 5+3
res1: Int = 8
scala> (5).+(3)
res2: Int = 8

range

scala> 1 to 5
res3: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5)
scala> 1 to 10 by 2
res4: scala.collection.immutable.Range = Range(1, 3, 5, 7, 9)

从可控制台读取

import io.StdIn._

scala> var i =readInt()
i: Int = 56

写入文件

import java.io.PrintWriter

scala> import java.io.PrintWriter
import java.io.PrintWriter
scala> val out = new PrintWriter("output.txt")
out: java.io.PrintWriter = java.io.PrintWriter@4a9f80d3
scala> for(i<- 1 to 5) out.println(i)
scala> out.close

读文件

import scala.io.Source

scala> import scala.io.Source
import scala.io.Source
scala> val input = new Source.fromFile("output.txt")
<console>:16: error: type fromFile is not a member of object scala.io.Source
       val input = new Source.fromFile("output.txt")
                              ^
scala> val input = Source.fromFile("output.txt")
input: scala.io.BufferedSource = non-empty iterator
scala> val lines = input.getLines
lines: Iterator[String] = non-empty iterator
scala> for(line <- lines) println(line)
1
2
3
4
5

异常处理

try-catch

if 条件表达式

if(x>0){
}else{
}

有一点与 Java 不同的是，Scala中的if表达式的值可以赋值给变量 跟java中的三目运算符差不多

val x = 6
val a = if(x>0) 1 else -1

while循环

while(i>0){
i-=1}
var i = 0
do{
i +=1
}while(i<5)

for 循环

for(变量<-表达式)

for(i<- 1 to 5)println(i)
//添加打印条件
for(i<- 1 to 5 if i%2==0)println(i)
//多重循环
for(i<- 1 to 5;j<- 1 to 3)println(i*j)
//循环后的结果赋值给r
val r = for(i<- 1 to 5 if i%2==0) yield{println(i);}

数据结构

导入scala.collection.immutable 所有不可变的类

导入scala.collection.mutable 所有可变的类

列表（List）不可变的

var list = List("a","b","c") list不可变
list.head  //取出头部
list.tail  //取出除了头部以外的
**增加元素 使用::生成一个新的列表**
var otherList = "d"::list
//新列表是
List("d","a","b","c")

集合（Set）

集合包括可变集和不可变集，分别位于scala.collection.mutable包和scala.collection.immutable

默认创建不可变的

var mySet = Set("a","Spark")
mySet += "Scala"
var 可变 Set不可变，所以最终结果只想另一个对象
//如果要声明一个可变集，则需要提前引入scala.collection.mutable.Set
import scala.collection.mutable.Set
val myMutableSet = Set("Database","b")
myMutableSet += "c" 
val不可变，但是Set可变，最终结果是塞到Set中，还是同一个对象

映射（Map）

Scala 的映射包含了可变的和不可变的两种版本，分别定义在包scala.collection.mutable 和scala.collection.immutable 里。默认情况下，Scala中使用不可变的映射。如果想使用可变映射，必须明确地导入scala.collection.mutable.Map

val map = Map("a"->"aa" , "b"->"bb")
println(map("a"))
//如果给定的键不存在会有异常 所以访问前可以先调用contains方法确定键是否存在
var x = if(map.contains("a")) map("a") else  0
//定义一个可变的map
import scala.collection.mutable.Map
val map2 = Map("a"->"aa", "b"->"bb")
map2 +=("c"->"cc")
//遍历一个map
for((k,v)<- map2)println(k+v)
for(k<- map2.keys)println(k)
for(v<- map2.values)println(v)

数组（Array）

一种可变的、可索引的、元素具有相同类型的数据集合。

val arr = new Arry[Int](3)//生命一个长度为3的整形数组
arr(0) = 1 //给第一个元素赋值
可以不给定数组的类型Scala可以自己推断
val arr2 = Arry(1,2,3)
如果让数组可以变 导入import scala.collection.mutable
arr2 +=4

元组（Tuple）

元组是对多个不同类型对象的一种简单封装。定义元组最简单的方法就是把多个元素用逗号分开并用圆括号包围起来。

使用下划线“_”加上从1开始的索引值，来访问元组的元素

val tuple = ("bigdata",12,34.0)
println(tuple._1)
println(tuple._1)

迭代器（Iterator）

迭代器（Iterator）不是一个容器，而是提供了按顺序访问容器元素的数据结构。

迭代器包含两个基本操作：next和hasNext。next可以返回迭代器的下一个元素，hasNext用于检测是否还有下一个元素

val iter = Iterator("a","b","c")
 while(iter.hasNext){println(iter.next())}
 或者
 for(x <- iter){println(x)}

面向对象

类

class Counter{
private var value = 0
private var name = ""
//构造函数
def this(name:String){
  this()//先调用主构造函数
  this.name = name
}
def increment():Unit={value += 1}//如果只有一行大括号可以省略
或者 def increment() {value += 1}
def current():Int={value} //value就是返回值
}
val counter = new Counter 或者 new Counter()
counter.increment()
//单例对象
object MyCounter{
  def main(args:Arry[String]){

  }
}

对象

单例对象

Scala采用单例对象（singleton object）来实现与Java静态成员同样的功能。

使用object 关键字定义单例对象

object Person{
  private var name=""
}

在类中定义apply方法，实例化的时候会自动被调用

class ApplyTest{
 def apply(param : String){
 }
}
var a = ApplyTest("name")

例如scala中给一个数组赋值使用()而不是像java中使用[]，就是因为()是调用了其内部的apply方法

继承

抽象类

abstract class Person{
   val name : String
   def eat()//抽象方法
   def run()
}
class student extends Person{
   override val name = "dahai"
   def eat()
   override def run()//重写此方法
}

特质

特质相当于java中的接口使用关键字 trait

多实现 使用 with 关键字

trait Person{
  var id : Int
  def currentId():Int{}
}
trait SuperMan{
    def fly()
   }
class student extends Person{}
class student1 extends Person with SuperMan{}

模式匹配 相当于java中的switch case 这里使用match和case,case后面可以是任何类型的常量 也可以是条件表达式

val num = 1
val str = num.match{
 case 1 => "big"
 case 2 => "data"
 case 3 => "spark"
 case "aa" => "哈哈"
 case _ if(0==0) =>println(sss)
 case _ => "doop" //相当于java中的default
}

case 类

case class Man(age : Int , sex : String)
for (nam <- List(Man(15,"男"),Man(16,"女"))){
 car match{
   case Man(15,"男") => println()
   case Man(16,"女") => println()
 }
}

函数式编程

函数式编程的优点

- 大数据应用和并发需求的驱动；

- 纯函数的行为表现出与上下文无关的透明性和无副作用性，避免了多线程并发应用中最复杂的状态同步问题

Scala在架构层面上提倡上层采用面向对象编程，而底层采用函数式编程。

匿名函数 lambda表达式

val fun = （num : Int） => num * 2 
println(fun(3))

占位符语法

为了让函数更简单，使用下划线作为一个或者多个参数的占位符

val list - List(3,9,6,5,4,7,)
list.filter(x => 5) 
等价于
list.filter(_ > 5)

map和flatMap

map

将某个函数应用到集合中的每个元素，映射得到一个新的元素，map方法会返回一个与原容器类型大小都相同的新容器，只不过元素的类型可能不同。

val books = List("a","b","c")
books.map(s => s.toUpperCase)
结果是
List("A","B","C")

flatMap

将某个函数应用到容器中的元素时，对每个元素都会返回一个容器（而不是一个元素），然后，flatMap把生成的多个容器“拍扁”成为一个容器并返回。返回的容器与原容器类型相同，但大小可能不同，其中元素的类型也可能不同。

val books = List("Hadoop","Hive","DHFS")
book.flatMap(s => s.toList)
结果是
List("H","a","d","o","o","p","H","i","v","e","D","H","F","S")

reduce，fold 规约求和

规约操作是对容器元素进行两两运算，将其“规约”为一个值

val list = List(1,2,3,4,5)
list.reduce(_+_)//将列表元素累加 结果为15
fold也是规约，它提供了一个初始值
list.fold(10)(_+_) 结果为 25

filter操作

val list = List(1,2,3,4,5,6) filter(_%2==0)

filterNot方法过滤出不符合条件的元素；exists方法判断是否存在满足给定条件的元素；find方法返回第一个满足条件的元素。

val list = List(1,2,3,4,5,6)
list exits{_ == 5}
list find{_ == 6}