5.1 Scala概述
5.1.2 Windows环境下安装Scala
5.1.1 Scala特性
1.面向对象
2.函数式编程
3.扩展性
4.并发性
5.可以和Java混编
5.2 Scala基础语法
1.声明常量和变量
(1)声明常量
val 常量名:数据类型=初始值
val a:int =1或val a = 1
(2)声明变量
var 变量名:数据类型=初始值
注:
支持同时声明多个变量如var a,b = 1
可以重复使用同一变量名定义变量,解释器以最新定义为准
声明变量需要初始化,否则报错
(优先使用常量,除非确实需要修改)
2.输出值的方式
(1)直接调用变量名
(2)借助输出函数
差值字符串
字符串前加“s”或“f”
加s:不支持格式化
${varName}
加f:支持在$变量后指定格式化参数
$varNum%.2f (保留小数点两位)
${varName}插入变量名
1.print()函数结合加号对多个内容进行连接并输出
2.println()函数输出结束后自动换行
3.printf()函数格式化输出
3.数据类型 (首字母大写)
-
9种基本数据类型:String位于java.lang包,其余位于Scala包
Any是所有其他类型的超类(父类)
Nothing是任何其他类型的子类
Unit无返回值
String对象
字符串对象用双引号
常用方法
(1)String concat(String str)方法
将指定字符串连接到此字符串的结尾
"ABC",concat("DEF")
(2)Boolean endsWith(String sufix)方法
测试字符串是否以指定的后缀结束
"ABC". endsWith("C")
(3)Int length()方法
返回字符串的长度
"ScalaPythonJava".length()
res: Int = 15
(4)Boolean matches(String regex)方法
判断字符串是否匹配给定的正则表达式
"ScalaPythonJava".matches(".*Python.*")
res: Boolean = true
(5)String replace(char oldChar, char newChar)方法
返回一个新的字符串,newChar 字符串替换原字符串中出现的oldChar字符串得到
"I love Python".replace("Python","Scala")
res: String = I love Scala
(6)String replaceAll(String regex, String replacement)方法
使用给定的replacement字符串替换字符串中所有与给定的正则表达式相匹配的子字符串
"ab123sdab4543das756as876asd".replaceAll("\\d+","#num#")
res: String =abfnumtsdabfnumidastnumfasfnumfasd
(7)String replaceFirst(String regex,String replacement)方法
使用给定的replacement字符串替换字符串中与给定的正则表达式相匹配的第一个子字符串
(8)String[] split(String regex)方法
按正则表达式匹配的子字符串拆分字符串。
String[]表示split(String regex)执行结束后的返回值是字符串数组
"I love Python".split("")
res: Array[String]= Array(I, love, Python)
(9)Char[] toCharArray()方法
将字符串转换为一个字符数组
"Scala".toCharArray()
res: Array[Char] = Array(S, c, a, l, a)
(10)String toLowerCase()方法
将字符串中的所有字符都转换为小写
(11)String trim()方法
删除字符串的首尾空白符
(12)String take(num)方法
获取字符串前num个字符
//获取"hello"前两个字符 "hello".take(2)
res: String = he
(13)reverse属性
反转字符串
4.运算符
算术运算符
+、-、*、/、%(取余)
关系运算符(比较运算符)
==,!=,>,<,≥,≤
逻辑运算符
&&与(都满足),‖或(一个满足), !非
赋值运算符
=,+=,-=,*=,/=,%=
5.3 Scala控制结构
1.条件表达式
val s = if(x >0)1 else 0
2.if...else选择结构
单分支,双分支,多分支
3.编写和运行Scala脚本
一起执行的Scala语句序列放在同一文件,称为脚本
执行scala test.scala
4.循环结构
while,do while,for
for没有直接对应结构
(1)for(x<-Range)
Range 可以是一个数字区间,如
i to j表示的区间是[i,j]
i until j表示的区间是[i,j)
(2)for 循环可用分号隔开多个区间
可以迭代多个区间的所有可能值
for( a <- 1 to 2;b <-1 to 2) println( "a:"+a+"b:"+b)
(3)for 循环中使用数组、列表和集合
for 循环中使用列表 val list1=List(3,5,2,1,7)//创建列表 listl: List[Int] = List(3,5,2,1,7) for(x <- list1) print(""+x) 3 5 2 1 7
(4)for 循环中使用过滤器
for(x <- list1 if x%2==1) print(""+x) 3 5 1 7
5.4 数组
1.定长数组 使用()访问数组元素而不是[]
var z:Array[String] = new Array[String](3)
var z = new Array[String](3)
2.变长数组
1、ArrayBuffer创建变长数组
import scala.collection.mutable.ArrayBuffer
val arr1 = ArrayBuffer[Int]()//定义一个Int类型、长度为0的变长数组
2.追加、修改、删除变长数组的元素
val bigData = ArrayBuffer("Hadoop","Storm")//创建变长数组
(1)“+=”追加一个元素
bigData += "Spark"
(2)“++=”追加一个数组的元素
bigData ++= Array("Hbase","Graphx")
(3)“-=”删除元素
bigData -= "Graphx"
(4)“--=”删除在指定数组中出现的元素
bigData --= Array("Spark","Graphx")
(5)remove()方法删除指定位置的元素
调用变长数组对象的removeo方法从指定索引开始移除指定数量的元素。
bigData.remove(1,2)//从索引1处开始移除2个元素
(6)insert()方法在指定位置前插入元素
bigData.insert(0,"Spark")//在索引 0前插入元素"Spark"
定长数组和变长数组之间转换,调用toBuffer()和toArray()方法。
3.遍历数组
1.for 循环和until遍历数组
for(i <- 0 until a.length)
△注意:变量i的取值从0到a.length-1。
2.直接遍历数组元组
for(e <- b)
△注意:变量e先被设为b(0),然后被设为b(1),以此类推。
4.数组转换
按某种方式将一个数组转换为一个全新的数组,而原数组不变。
创建一个新数组 val a=Array(1,2,3,4)
1.for(...) yield
val result = for(elem <- a) yield 2 * elem
result: Array[Int] = Array(2, 4, 6, 8)
result中的值由yield之后的表达式2*elem产生,每次迭代为result产生一个值。
2.数组对象的map()方法
val result2 = a.map{3 * _}
result2: ArraylInt] = Array(3,6, 9,12)
3.数组对象的filter()和map()方法
val result3 = a.filter(_ % 2 == 0).map {2 * _}
result3: Array[Int] = Array(4, 8)
可以添加语句处理那些满足特定条件的元素。
5.数组对象的操作方法
1.map()方法映射数组 var arr = Array(1,2,3,4)
通过一个函数改变数组中的每个元素
arr.map(x => x* 5)
res: Array[Int] = Array(5, 10, 15, 20)
△注意:x=>x*5这种表达式称为Lambda表达式,用来创建临时使用的匿名函数。
Lambda 表达式的语法格式如下: (参数1,参数2,…)=>表达式
2.foreach()方法遍历数组中的元素
和map()方法类似,但是foreach()没有返回值。
3.min、max、sum分别输出数组的最小元素、最大元素、数组元素和
4.head、tail分别查看数组的第一个元素、除第一个元素外的其他元素
5.sorted、sortBy()、sortWith()排序
(1)sorted
sorted默认为升序排列,降序排列则需要反转。
arr.sorted//升序
arr.sorted.reverse//降序
(2)sortBy()
需要参数,表明进行排序的数组元素的形式。
arr.sortBy(x=>x)//升序
arr,sortBy(x =>-x)//降序
(3)sortWith() var arr = Array("a","d","F","B","e")
sortWith((String,String)=>Boolean) 需要匿名函数来说明排序规则,要有两个参数进行比较。
arr.sortWith((x:String, y:String) => x<y)
arr.sortWith((x,y) => x<y)
6.filter()方法进行过滤
filter()方法移除传入函数的返回值为 false的数组元素。
过滤掉数组 arr中奇数,得到只含偶数的数组。arr.filter(x=>x%2==0)
7.flatten扁平化操作 val arr = Array(Array(1,2),Array(3,4))//二维数组
把嵌套的结构展开,二维数组展开成一维数组。
arr.flatten
res: Array(Int) = Array(1, 2, 3,4)
8.flatMap 操作
结合map()和 fatten功能,相当于先进行map()操作再进行flatten操作,接收一个可以处理嵌套数组的函数,把返回结果连接起来。
arr.flatMap(x=> x.map(_*10))
res: Array[Int] = Array(10, 20, 30,40)
9.显示数组内容
mkString()方法显示数组的内容,允许指定元素之间的分隔符,该方法的另一个重载版本可以指定元素的前缀和后缀。
to*方法(*为数据类型名)
数据类型转换
5.5 列表
1.不可变列表
与数组的比较
(List声明)类似于数组,所有元素都具有相同的数据类型。
与数组不同的是,不可变列表的元素是不可变的,不可变列表的元素值一旦被觉了就不能改变。
1.创建不可变列表
val course: List[String] = List("Scala", "Python")
course: List[String] = List(Scala, Python)
//创建二维列表 val dim: List[List[Int]]= List(List(1,0),List(0,1)
dim: List[List[Int]] = List(List(1, 0), List(0, 1))
不可变列表具有递归的结构 (也即链接表结构) 数组不具有。即不变列表
要么是Nil(即空列表)
要么是一个head元素加上一个tail, 而tail又是一个列表
val nums:List[Int] = List(1,2,3,4)
nums: List[Int] = List(1, 2, 3, 4)
nums.head
res: Int = 1
nums.tail
res: List[Int] = List(2, 3,4)
(1)创建空列表
val L = Ni1
val L2 = List()
(2)“::”创建列表
“::”根据给定的head 和tail 创建一个新的列表。
△注意:“::”右结合,即从末端开始创建列表。
val newList=1::List(3, 5)
newList: List[Int] = List(1, 3, 5)
(3)“:::”连接列表创建新列表
val L4 = L3 ::: List("Hadoop","Hbase")
L4: List[String] = List(Spark, Scala, Python, Hadoop, Hbase)
2.不可变列表的操作9个
head:返回列表的第一个元素。
tail:返回一个列表,含除了第一个元素之外的其他元素。
init:返回一个列表,含除了最后一个元素之外的其他元素。
reverse:用于将列表的元素顺序反转。
last:返回列表的最后一个元素。
length:返回列表的长度。
range:创建数值范围的列表。 List.range(from,until)
创建从from 到until(不包括 until)的所有数值的列表。
step值作为第3个参数
将产生从from到uni的间隔为step 的列表元素,step值可正可负。
List.range(1,9,2)
res: List[Int] = List(1, 3, 5, 7)
isEmpty:判断列表是否为空,在列表为空时返回true。
sorted:排序。
3.不可变列表对象的常用方法15个
val L5= List("Spark","Scala", "Python", "Hadoop","Hbase")
L5: List(String)= List(Spark, Scala, Python, Hadoop, Hbase)
(1)count(s => s.length==num)
统计列表中长度为num的字符串的个数
//对L5中长度为5的字符串进行计数 L5.count (s =>s.length == 5)
res0: Int = 3
(2)drop(num)
返回去掉列表开头num个元素的列表
L5.drop(2)
res1: List[String] = List (Python, Hadoop, Hbase)
(3)dropRight(num)
返回去掉列最后num个元素的列表
L5.dropRight(3)
res2: List[String] = List(Spark, Scala)
(4)exists(s => s=="***")
判断列表中是否有字符串的值为"***"
L5.exists(s => s=="Spark")
res3: Boolean = true
(5)forall(s => s.endsWith(“k”)
判断列表里的元素是否都以”k”结尾
L5.forall(s => s.endsWith("k"))
res4: Boolean = false
(6)foreach(s => println(s))
遍历输出列表元素
L5.foreach(s => print(s+" "))
Spark Scala Python Hadoop Hbase
(7)map(f)
通过给定的函数f将所有元素重新计算
//对L5的元素都拼接$,并返回一个新的列表 scala> L5.map(s => s + "$")
List[String] = List(Spark$, Scalas$, Python$, Hadoops$, Hbases$)
(8)mkString("-")
对列表的元素以"-"拼接并返回
L5.mkString("-")
res11: String-Spark-Scala-Python-Hadoop-Hbase
(9)filterNot(s => s.length==5)
返回列表中长度不为5的元素所组成的列表
L5.filterNot(s => s.length == 5)
res12: List[String] = List(Python, Hadoop)
(10)take(num)
从列表左边取num个元素组成一个新列表
L5.take(3)
res13: List[String]=List(Spark, Scala, Python)
(11)takeRight(num)
从列表右边取num个元素组成一个新列表
L5.takeRight(3)
res14: List(String) = List(Python, Hadoop, Hbase)
(12)sortBy(x => x),升序排列
sortBy(x => -x),降序排列
(13)sortWith(_<_),升序排列
sortWith(_>_),降序排列
(14)“:+”和“+:”
“:+”在末端添加元素以得到一个新列表
list2.:+(10)
res25:List[Int] = List(3, 5,2, 1, 7,10)
“+:”在首端添加元素以得到一个新列表
list2.+:(0)
res26: List(Int] = List(0, 3, 5,2, 1,7)
(15)toString()
将列表转换为字符串
List(1,2,3).tostring()
res27: String = List(1, 2,3)
2.可变列表 ListBufer声明
对于可变列表,既可以修改某个位置的元素值,也可以增加或删除列表元素。
1.创建可变列表
import scala.collection.mutable.ListBuffer
val LBl = ListBuffer(1,2,3,4,5,6)
2.可变列表的常用操作
(1)按值删除列表元素
5.6 集合
不可变集合
可变集合
5.7 元组
元组的常用操作
拉链操作
5.8 映射
不可变映射
可变映射
5.9 Scala函数
匿名函数
高阶函数
函数的定义
5.10 Scala模式匹配
5.11 Scala面向对象编程
类与对象
单例对象和伴生对象
5.12 Scala读写文件
读文件
写文件