Scala基本类型——aboutyun

1、其类型首字母都要大写。

scala变量定义，首先需要一个关键字  val  或者 var  接着是变量名  ： 冒号后面跟着变量类型 =  等号后面跟着变量值

val  a:Int =1   定义一个变量 a ，是整形 ，初始值是1

如果定义float类型的话，小数点后面要加一个f(因为有小数都认为是double类型)

还有一个对于String类型，用的都是双引号（可以是一个字符也可以是多个字符）

对于chart类型，用的都是单引号。（只能是一个字符）

boolean类型，是ture或者false

在应用中，scala编辑器是自动识别推断其类型，但是对应的单引号或者双引号要正确。

对于整形中的byte,long,short等类型，要指明确告诉它要将它定义成为其中的类型。

 

对于关键字val 与var，

val定义了一个变量值后，变量值是不能再改变了

var定义了一个变量值后，其变量值还可以改变

2、程序控制语句。

a、 if 语法结构
if ("about" == "yun") {   println("about == yun") } else {   print("about != yun") }
// 输出 about != yun

// 使用if 语法定义变量，x结果为0
val x = if ("about" == "yun") 1 else 0

b、 while 语法结构
var x = if ("about" == "yun") 1 else 0
while (x < 5){   x += 1   println("x: %s".format(x)) }

c、

val arrs = Array("aboutyun", "hadoop", "spark")  //一个数组（可用while也可用for循环输出）

// 集合操作方式（常用） for (arr <- arrs){   println("arr: %s".format(arr)) } 但有前缀

// 间接操作方式
for (i <- 0 to arrs.length - 1){   println("arr: %s".format(arrs(i))) }//用的是to

for(i<-0 until arrs.length){println(arrs(i))}//用的是until

d、for循环

// 生成一个0到5的集合
val arrs = 0 to 5

// 针对arrs中的偶数乘以2生成一个新的集合 for (arr <- arrs if arr % 2 == 0) yield arr * 2

// for循环嵌套
for (i <- "abc"; j <- "xyz") println(s"$i+$j")

for (i <- "abc"; j <- "xyz") {println("i:%s,j:%s".format(i,j))}//其实%s,输出字符串时，将i,j替换前面的%

3、Array/List的基本操作

a、// 定义一个长度为5的整型数组
scala> val arrs = new Array[Int](5)  //这里用new
arrs: Array[Int] = Array(0, 0, 0, 0, 0)

// 赋值给第一个索引
scala> arrs(0) = 100

scala> arrs// 直接输入数组名就能输出其内容
res22: Array[Int] = Array(100, 0, 0, 0, 0)

// 使用apply方法定义数组及赋值
scala> val arrs = Array[Int](100, 200, 300)  //这里不用new，而是让它自动调用apply
arrs: Array[Int] = Array(100, 200, 300)

b、array的遍历

scala> val arrs = Array[Int](100, 200, 300)
arrs: Array[Int] = Array(100, 200, 300)

方式一：scala> for (arr <- arrs) println(arr)  //表示对其遍历打印出来

方式二：scala>for(i<-0 until arrs.length){println(i)}//打印i是其索引。如果打印的是arrs(i)则是其里面的每个元素

c、List的定义和操作

// 构造List对象
scala> val list = List(1, 2, 3)  //内部用的是apply的方式。直接定义名字
list: List[Int] = List(1, 2, 3)
// 使用Nil和 :: 追加符来构建
scala> val list = 1 :: 2 :: 3 :: Nil   //方式二：nil 是一个空的list,可以直接输出空集合，  先创建一个空集合，：：就是不断添加元素
list: List[Int] = List(1, 2, 3)

// 添加元素
scala> list :+ 4   //方式三：集合后面添加一个冒号： 添加一个加号+  然后就是要添加的元素了。也可以往前加
res60: List[Int] = List(1, 2, 3, 4)
scala> list
res61: List[Int] = List(1, 2, 3)

// mkString使用“_”拼接元素（制作字符串）
scala> list.mkString("_")  //表示拼接时候用什么拼接
res62: String = 1_2_3

其他常用方法：head, last, take   //list.head 是取第一个    list.last是最后一个元素  list.take是取多少个元素，并且生成新的list

d、List的遍历

// 方式一
scala> for (l <- list) print(l + ",")    //直接打印每个元素，对于可循环的都能用
1,2,3,

// 方式二
scala> list.foreach(l => print(l + ","))//不需要再输入集合的名字了。l就表示list里面的每一个元素。
1,2,3,

在scala终端，输入一个list在输入一个点 . 回车后，会出list所有能调用的方法。

这两种方式的区别：

4、Set/Map/Tuple 操作

set有一个功能可以去重，元素不重复。map是映射，里面的元素是有两部分。Tuple里面的元素可以是不同类型的

a、Set的操作

Scala 默认导入一下的包：

import java.lang._ import scala._ import Predef._

Predef中默认包含了 不可变的Set/Map，如果要使用可变的集合需要手动导入scala.collection.mutable包

Set是一种不存在重复元素的集合，与数学中定义的集合是对应的。且是无顺序的。

// 定义Set
scala> val set = Set(1, 2, 1, 3)
set: scala.collection.immutable.Set[Int] = Set(1, 2, 3)  自动去重

// 增加元素
scala> set + 5
res98: scala.collection.immutable.Set[Int] = Set(1, 2, 3, 5)

b、Map操作

Map 是一种键值对的集合，一般翻译成映射

// 定义不可变 Map 键与值之间用->进行分隔
scala> val map = Map("aboutyun" -> "a", "hadoop" -> "h", "spark" -> "s")
map: scala.collection.immutable.Map[String,String] = Map(aboutyun -> a, hadoop -> h, spark -> s)

// 定义可变 Map（在前面导入一个包名时候是可变的）
scala> val map2 = scala.collection.mutable.Map("aboutyun" -> "a", "hadoop" -> "h", "spark" -> "s")
map2: scala.collection.mutable.Map[String,String] = Map(spark -> s, hadoop -> h, aboutyun -> a)

// 添加元素，用put的方法
scala> map2.put("flume","f")
res128: Option[String] = None

scala> map2
res129: scala.collection.mutable.Map[String,String] = Map(spark -> s, hadoop -> h, aboutyun -> a, flume -> f)

可变的，是复制初始化后，还可以对其内容进行修改，增加。而不可变的一旦初始化后就不能变了。

c、Tuple 操作

Tuple 是一种可以包含多个类型元素的集合，一般翻译成元组

// 定义元组
scala> val tuple = ("aboutyun", "hadoop", 1)  //tuple定义的时候要用括号，
tuple: (String, String, Int) = (aboutyun,hadoop,1)    //回车后就会输出显示其类型
// 二元组特殊定义方式 （其实和map的键值对是差不多的）
scala> val tup = "aboutyun" -> 1
tup: (String, Int) = (aboutyun,1)

// 访问第一个元素
scala> tuple._1（返回第一个元素，与前面的取索引是不一样的。）
res141: String = aboutyun

// 模式匹配获取元素内容
scala> val (a, b) = tup
a: String = aboutyun
b: Int = 1

d、遍历方式

5、函数和常用高阶函数

a、函授的格式

          

 def是一定要使用的，  函数体也是函数的功能。

b、函授字面量

函数字面量表示函数可以赋值给变量
Scala函数将最后的值作为函数的返回值，不需要return语句

// 定义一个自增函数
scala> def increase(x:Int): Int = {x+1}
increase: (x: Int)Int

scala> increase(1)
res145: Int = 2

// 使用incr引用increase函数，=>左侧表示输入，右侧表示转换操作
scala> val incr = (x: Int) => x + 1  （=>的的左边表示要接收的参数类型，右边是一个方法体）
incr: Int => Int = <function1>       （函授赋值给变量也）

scala> incr(1)
res151: Int = 2

c、匿名函授

集合的map函数可以对集合中的每个元素进行操作，接受的参数为针对元素进行操作的函数，例如相对List(1, 2, 3)集合中每个元素加1，可以使用以下方法：

scala> println(List(1, 2, 3).map(incr))     （如果函授的参数又是另一个函授的话，则称之为高阶函数）
List(2, 3, 4)

// 使用匿名函数进行简化
scala> println(List(1, 2, 3).map((x:Int) => x + 1))  （这里不用写匿名函授了，而是直接写函授字面量）
List(2, 3, 4)

d、函授简化

// 简化匿名函数，自动判断类型
scala> println(List(1, 2, 3).map((x)=> x + 1))
List(2, 3, 4)

// 简化匿名函数，函数参数只有一个，可以省略 ()
scala> println(List(1, 2, 3).map(x=> x + 1))
List(2, 3, 4)

// 简化匿名函数，函数参数右侧只出现一次，可以进一步简化
scala> println(List(1, 2, 3).map(_ + 1))
List(2, 3, 4)

// 可以使用花括号{} 替代小括号 ()

scala> println(List(1, 2, 3).map{_ + 1})
List(2, 3, 4)

e、常用的高阶函数

map

map函数用于对集合中的每个元素进行转换

// 对列表中所有元素加1
scala> println(List(1, 2, 3).map(_ + 1))
List(2, 3, 4)

// 获取所有key
scala> println(Map("spark"->1,"hive"->2,"hadoop"->3).map(_._1))
List(spark, hive, hadoop)

// 等价于
scala> println(Map("spark"->1,"hive"->2,"hadoop"->3).map(x => x._1))
List(spark, hive, hadoop)

// 等价于
scala> println(Map("spark"->1,"hive"->2,"hadoop"->3).map{case (k, v) => k})
List(spark, hive, hadoop)

flatten

flatten 函数用于对嵌套的集合展开，函数接收的参数类型为集合类型

scala> println(List(List(1, 2, 3), List(5, 6)).flatten(x=>x.reverse))
List(3, 2, 1, 6, 5)

scala> println(List(List(1, 2, 3), List(5, 6)).flatten)
List(1, 2, 3, 5, 6)

flatMap

flatMap函数结合了flatten和map两个函数的功能

scala> println(List(List(1, 2, 3), List(5, 6)).flatMap(x => x.map(x => x + 1)))
List(2, 3, 4, 6, 7)

scala> println(List(List(1, 2, 3), List(5, 6)).flatMap(_.map(_ + 1)))
List(2, 3, 4, 6, 7)

filter

filter函数用于筛选集合中满足某些条件的元素

scala> println(List("List","Set","Array").filter(_.length>3))
List[String] = List(List, Array)

scala> println(Map("List"->3,"Set"->5,"Array"->7).filter(_._2>3))
Map(Set -> 5, Array -> 7)

reduce

reduce函数用于对集合做聚合，接受两个参数，常用于把当前结果和集合的下一个元素累加

scala> println(List(1, 2, 3, 4).reduce((x, y) => x + y))
10

// 简化
scala> println(List(1, 2, 3, 4).reduce(_ + _))
10

6、 类和对象-

a、 主构造器

// 定义一个Person类，包含name,age,city三个成员变量，其中city默认为“BeiJing”

class Person(var name: String, var age: Int, var city: String="BeiJing") {   override def toString() = "name: %s, age: %s, city: %s".format(name, age, city) }

// 使用new来创建Person类
scala> val p = new Person("Bob", 18)
p: Person = name: Bob, age: 18, city: BeiJing

// 修改Person的city
scala> p.city = "TianJin"
p.city: String = TianJin

b、单例对象

有些场景下我们不需要创建对象，但是需要调用对象的方法，Scala不支持static，但是Scala可以通过单例对象来解决。

object Person {   private var personId = 0   def opId(): Int = {     personId += 1     personId   }   def main(args: Array[String]): Unit = {     println("personId: %s".format(Person.opId()))   } }

c、伴生对象和伴生类

在上面单例对象的文件下，我们可以定义一个class Person，class Person 称为object Person的伴生类，object Person 称为class Person的伴生对象。

d、apply 方法

 

7、模式匹配与正则表达式

a、模式匹配

8、特殊符号含义

a、// -> 返回二元组，常用于构造 Map

scala> 1 -> "one"
res8: (Int, String) = (1,one)

scala> Map(1 -> "one", 2 -> "two", 3 -> "three")
res9: scala.collection.immutable.Map[Int,String] = Map(1 -> one, 2 -> two, 3 -> three)

b、// <- 常用于for循环，用于遍历一个可迭代的对象

scala> for (i <- 0 until 5) println(i)

c、// => 常用于构造匿名函数，左侧是输入参数，右侧是方法体

scala> val add = (x: Int, y: Int) => x + y
add: (Int, Int) => Int = <function2>

scala> println(add(10, 20))
30

d、// ::: 用于两个List的连接
scala> List(1,2,3) ::: List(4,5)
res31: List[Int] = List(1, 2, 3, 4, 5)

e、// _ 有多种含义

// 1. 通配符

scala> import scala.math._
import scala.math._

// 2. 获取元组的指定位置元素
scala> val tup = 1 -> 2
tup: (Int, Int) = (1,2)

scala> tup._2
res0: Int = 2

// 3. 可以在匿名函数中表示每个元素
scala> val lst = List(1,2,3,4,5)
lst: List[Int] = List(1, 2, 3, 4, 5)

scala> val lstFilter = lst.filter(_ > 3)
lstFilter: List[Int] = List(4, 5)

// 4. 模式匹配中表示不需要引用的名字
scala> val tuple = (1, 2, 3)
tuple: (Int, Int, Int) = (1,2,3)

scala> val (_, two, _) = tuple
two: Int = 2

// 5. 表示可变（不定长）参数
scala> def sum(parms: Int*) = {
     |   var result = 0
     |   for (par <- parms) {
     |     result += par
     |   }
     |   result
     | }
sum: (parms: Int*)Int

scala> println(sum(1 to 5: _*))
15