1.val和var的区别:
val : 值
类似 final 不能再次赋值
val 值名称:类型 = xxx
var : 变量
可以再次赋值
2. scala的基本数据类型:
Byte/Char
Short/Int/Long/Float/Double
Boolean
类型转换:
val a:Int = 10
val b = a.asInstanceOf[Double] /** 强制转换为Double
判断是不是该类型
val h = 10.isInstanceOf[Int] 返回结果为true
3. lazy 的用法
lazy在修饰一个属性时,是不会进行赋值操作的,只有当你使用该属性时,它才会被赋值(也可以叫做延迟加载)
scala> lazy val a = 1
a:Int = <lazy> /** 该属性是没有值的
scala> a /** 第一次使用该属性,此时才会进行赋值操作
res0: Int = 1
4. scala常见的IDE
IDEA: 需要自己安装scala插件 重点推荐
Eclipse: 自带scala
5.使用idea整合maven构建scala应用程序
scala中控制版本的标签
<properties>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
<encoding>UTF-8</encoding>
<scala.version>2.11.8</scala.version>
<spark.version>2.3.0</spark.version>
</properties>
6. scala函数
6.1 方法的定义和使用:
def 方法名(参数名:参数类型,参数名:参数类型): 返回值类型 = {
// 括号内的叫做方法体
//方法体的最后一行是作为返回值的, 不用加return
}
* 没有入参的函数,调用时可以不用带括号
当定义函数时如果不写返回值类型,idea会自动把Unit设置为返回值类型,表示没有返回值类型,类似(void)
6.2 默认参数的使用:
* 在函数定义时,允许指定参数的默认值,但是当你传入之后以传入的值优先.
eg:
def sayName(name:String = "PK"):String = {
println(name)
}
6.3 命名参数的使用:
def speed(distance:Float, time:Float) : Float = {
distance/time
}
调用 println(speed(100,10)) res 10.0
命名参数的用法: println(speed(time=10,distance=100)) 就是在调换顺序的时候可以指定参数名,建议还是按照顺序为参数赋值
6.4 可变参数的使用:
* JDK5之后就已经提供了可变长参数的概念
用法:
def sum(numbers:Int*) = {
var result = 0
for(number <- numbers){
result += number
}
}
只需要在参数的后面加上*,在函数体内部进行循环,然后进行逻辑操作,具体的返回还需要看调用方法时添加的参数的数量
6.5 条件表达式:
if(x>0){
true
}else{
false
}
6.6 循环表达式:
6.6.1 to
scala> 1 to 5
res0: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5)
是一个左右都是闭区间的原因
6.6.2 Range
scala> Range(1,5)
res1: scala.collection.immutable.Range = Range(1, 2, 3, 4)
是一个左闭右开的区间
/**最后添加的一个参数表示步长,就是每次加2
* scala> Range(1,5,2)
res2: scala.collection.immutable.Range = Range(1, 3)
6.6.3 until
scala> 1.until(5)
res3: scala.collection.immutable.Range = Range(1, 2, 3, 4)
是一个左闭右开的区间
总结:实际to和until都是Range下的
* 6.6.4 for循环遍历
val courses = new Array("spark","spark sql","spark streaming"."storm")
/** 右边是需要遍历的集合对象,左边是遍历出的对象
for(course <- courses){
println("遍历的结果是:"+course)
}
* 6.6.5 foreach java8中已经出现的遍历方式
val courses = new Array("spark","spark sql","spark streaming"."storm")
/** 最左边是需要遍历的结合对象,括号里面就是遍历之后的一个个对象
courses.foreach(course => println(course))
6.6.6 while 的循环用法
var (num,sum) = (100,0)
while(num > 0){ //出口
sum = sum + num
num = num - 1 //步幅为1
}
println("1到100的求和"+sum)
7. 面向对象:
7.1 面向对象的概述:
7.1.1 封装: 属性,方法封装到类中
7.1.2 继承: 父类和子类之间的关系
7.1.3 多态: 父类引用指向子类对象 开发框架的基石
7.2 类的定义和使用
7.2.1 成员变量
private [this] val gender = "man" /** 私有成员只有在本类中使用,
var name:String = _ 也可以声明为"";"_"表示占位符
7.3 构造器
7.3.1 主构造器定义的方法:
class Person(val name:String,val age:Int) {...}
7.3.2 从属构造器的定义方法:
/** 首先在类中定义初始化的成员变量school
var school:String = _
/** 由于已经定义了类型,因此不需要再次定义类型,只需要直接添加即可
def this(name:String,age:Int,school:String){
this(name,age) /** 从属构造器方法的第一行必须是调用主构造器
this.school = school
}
7.4 继承和重写
7.4.1: 继承
就是父类有的,子类可以直接使用,但是当子类需要更多的时候,可以自己在子类中进行添加
7.4.2: 重写
子类继承父类的东西是可以进行改写的,可以根据自己的需要进行重写
重写语法:
override def 函数名:返回值类型....
7.5 抽象类
类的一个或者多个方法没有完整的实现(只有定义,没有实现)
abstract class Person2{
def speak
val name:String
val age:Int
}
/** 抽象类不能创建实例对象
class Student2 extends Person2 {
// override def speak: Unit = ??? /** 三个问号指代 方法体{} */
override def speak: Unit ={
println("speak...")
}
override val name: String = "李国辉" //实现的属性必须要赋值,用占位符会报错
override val age: Int = 26
}
7.6 伴生类和伴生对象
在伴生对象中创建apply方法,在主方法中进行测试的时候,创建对象
new AppTest() 指代的意思是穿件伴生对象AppTest并且默认调用伴生对象中的apply方法
总结:
类名() ==> 调用的是对象的apply方法 val b = AppTest() 不需要进行new操作,
因为在伴生对象的apply方法中已经进行了.
对象() ==> 调用的是类的apply方法 val c = new AppTest() c()
通常用法:
在object的apply方法中去new Class
7.7 case class
定义: 当定义一个类时加上case,使用该类时不用new,可以直接拿着用
object CaseClassApp {
def main(args: Array[String]): Unit = {
println(Dog("沈庆华").name)
}
}
case class Dog(name:String)
使用场景:
模式匹配(后续会讲解)
7.8 trait
Trait xxx extends ATrait with BTrait
eg:
class AparkConf(loadDefaults:Boolean)
extends Cloneable
with Logging
with Serializable
.... trait之间是继承,但是当要实现多个trait修饰类时,他们之间除了第一个,
其他之间需要用with进行连接
8. scala 集合
8.1: 数组
8.1.1 定长数组:
创建数组的方式:
方式一:
val b = Array[String](长度);
方式二:
val b = Array("spark","stream") 推荐使用
问题:
创建数组的时候为什么不用new:
因为Array底层点进去就是apply方法,所以不需要进行new操作
数组转换为String类型的方式:
b.mkString 所得到的结果是堆积在一起的,没有分隔符
b.mkString(",") 所得到的结果是以,分隔的字符串
8.1.2 变长数组:
eg:
val c = scala.collection.mutable.ArrayBuffer[Int]()
c += 1
c += 2
c += (5,6,7)
println("数组原内容:"+c)
c.insert(4,20) //在下标的为4的位置插入元素20,原下标为4的元素向后平移
println("添加之后的数组内容:"+c)
c.remove(0) //移除下标为0的元素
println("移除之后的内容:"+c)
c.remove(0,3) // 从下标0开始 移除3个元素
println("移除多个之后的内容:"+c)
c.trimEnd(2) //移除数组最后面的两个元素
for(i <- 0 until c.length){
println("打印结果:"+c(i)) /**寻常的遍历方式
}
for(res <- c){
println("获取数组元素最简便的方式:"+res) /** 最简便的遍历方式
}
for(res <- c.reverse){
println("获取数组元素逆序输出:"+res) /** 逆序输出遍历结果的方式
}
8.2: List
8.2.1 定长集合:
* Nil : 就是一个空的集合,在scala.collection.immutable.Nil下
val l = List(1,2,24,4,6)
println(l.head) res 1 /** head 表示获取一个集合的头
println(l.tail) res List(2,24,4,6) /** tail 表示获取一个集合的身体
val l2 = 1 :: Nil 创建一个只有一个元素1的集合, 1表示头,中间::表示拼接,Nil表示一个集合
val l3 = 1 :: 2 :: 3 :: Nil 表示把1,2,3作为集合元素从左到右放入到集合中
8.2.2 变长集合:
val l4 = scala.collection.mutable.ListBuffer[Int]()
l4 += 2
l4 += (7,5,4)
l4 ++= List(8,3,1) /** ++= 用在进行添加一个集合的时候
l4 -= (1, 4)
l4 --= List(6,7,8) /** --= 用在删除一个集合中所带的元素,没有的话就不删了
常用方法:
变成定长集合的方式:
l4.toList
变成数组的方式:
l4.toArray
是否为空:
l4.isEmpty
集合的头,体:
l4.head l4.tail
总结:
和java中的List集合类似,有序有下标
8.3: Set
val b = scala.collection.mutable.Set[Int]()
b += 3
b ++= Set(5,7,8)
总结:
Set集合无序无下标
8.4: Map
* 不可变Map集合 默认是在immutable包下的
val a = Map("PK" -> 18,"李国辉" -> 25) /** 箭头左边就如同key,箭头右边指代的就是value
println(a("PK")) 也可以 a.get("PK") /** 根据键获取值
* 可以进行修改的Map集合,只需要导入mutable下面的Map即可
val b = scala.collection.mutable.Map
b += ("wamngwu" -> 11,"zhaoliu" -> 23)
空的Map
val c = scala.collection.mutable.HashMap[String,Int]()
* /** 此方法是为了当你通过key获取值时,key不存在,会产生异常,因此,用getOrElse方法,在key没有的情况下给他一个默认值
val a = Map("PK" -> 18,"ligh" -> 25)
println(a.getOrElse("lisi",9))
* Map 集合的遍历:
方式一:
for((key,value) <- b){
println(key + ":" + value)
}
方式二:
for(key <- b.keySet){
println(key + ":" + b.getOrElse(key,9))
}
方式三:
for(value <- b.values){
println(value)
}
方式四: 类似方式一
for((key,_) <- b){
println(key + ":" + b.getOrElse(key,8))
}
☆ 8.5: OPtion&Some&None
eg1:
b.get("ligh")
res11: Option[Int] = Some(26)
eg2:
val a = Map("PK" -> 18,"ligh" -> 25)
println(a.getOrElse("lisi",9))
res:
Some(2)
None
具体的关系等后续再补充
8.6: Tuple(元组)
用法:
val a = (1,2,3,4,5)
println(a) // res (1,2,3,4,5)
println(a._5) // res 5
println("元组的长度:"+a.productArity)
for(i <- 0 until(a.productArity)){
println("遍历的元组的内容为:"+a.productElement(i)) /** 使用的方法不一样
}
应用场景:
val hostport = ("localhost",8080) /** 把ip和端口放在元组中,然后以后在用的时候调用就很方便
hostport._1 //获取localhost
hostport._2 //获取8080
9. 模式匹配
扫描二维码关注公众号，回复：
3171664 查看本文章
9.1 基本模式匹配
// 如同java中的switch case,需要匹配的参数放在match的前面,然后在方法体的case中进行相应的匹配执行的代码逻辑操作
object MatchApp extends App{
val names = Array("liguohui","shenqinghua","ligou")
val name = names(Random.nextInt(names.length))
name match {
case "liguohui" => println("一个好人")
case "shenqinghua" => println("是一个狗")
case _=> println("不知道你们说的是什么?")
}
def gradeTest(grade:String): Unit = {
grade match{
case "A" => println("成绩很优秀")
case "B" => println("成绩可以")
case "C" => println("成绩勉强")
case _ => println("成绩待提高啊")
}
}
gradeTest("A")
gradeTest("B")
gradeTest("D")
}
9.1.1 加条件的模式匹配:双重过滤
def gradeTest(name:String,grade:String): Unit = {
grade match{
case "A" => println("成绩很优秀")
case "B" => println("成绩可以")
case "C" => println("成绩勉强")
case _ if(name == "lisi")=> println(name+",成绩待提高啊")
case _=> println("成绩有点差啊")
}
}
9.2 Array模式匹配
def greeting(array:Array[String]):Unit = {
array match{
case Array("张三") => println("hello...")
case Array(x,y) => println(x+"==="+y)
case Array("沈庆华",_*) => println("是一头猪...")
case _ => println("你说的是啥啊?")
}
}
greeting(Array("张三"))
greeting(Array("沈庆华","liguohui","sdas"))
9.3 List模式匹配
ist match {
case "liguohui" :: Nil => println("是一个好人...")
case x :: y :: Nil =>println("this is " + x + " , " +y) //匹配只有两个元素的集合
case "ligh" :: "李国辉" :: "GoodMan" :: Nil => println("很舒服啊") //匹配三个元素的集合
case "pk" :: tail => println("头加尾...") // 匹配以pk开头的集合
case _ => println("啥都没有啊...")
}
}
9.4 类型匹配
根据传入的参数的类型进行匹配,获取相应的参数的类型
eg:
obj match{
case i : Int => println("Int")
case s : String => println("String") //匹配到String字符串
case map : Map[_,_] => map.foreach(println) //匹配到map集合并且打印
case list : List[_] => println("List") //匹配到List集合
case _=> println("类型不存在!")
}
}
matchType(Map("li" -> "sda"))
matchType(List("liguohui"))
9.5 Scala异常处理
/** 把需要做处理的代码逻辑放在try块中,然后在catch中进行捕获,最终在finally中进行最终操作.
try{
val i = 10/0
println(i)
}catch {
case e:ArithmeticException => println("除数不能为0")
case e:Exception => println("错误原因:"+e.getMessage)
}finally {
println("最终结束...")
}
9.5 case class 模式匹配
case修饰的类可以直接调用,不需要new
def classMatch(person:Person): Unit ={
person match {
case CTO(name,floor) => println(name+"在第"+floor+"楼层")
case Employee(name,floor) => println(name+"在第"+floor+"是一个员工")
case _=> println("是一个游客...")
}
}
class Person
case class CTO(name:String,floor:Int) extends Person
case class Employee(name:String,floor:Int) extends Person
case class Other(name:String) extends Person
classMatch(CTO("李国辉",10))
classMatch(Employee("张三",22))
classMatch(Other("other"))
总结:
由于所有的类都是继承了Person,所以在传入参数的时候只需要传入所有类的父类即可,另外case修饰的类不用new,可以直接使用
9.6 some&None模式匹配
因为map通过get方法获取的返回值类型为Option,Option下面有Some和Node两种类型,因此可以使用
Some表示有值,None表示没有值
val grades = Map("李国辉" -> "A","ligh" -> "B")
def someMatch(name:String): Unit ={
val grade = grades.get(name)
grade match {
case Some(grade) => println(name + "的成绩是:"+grade)
case None => println(name+"没有成绩啊...")
}
}
someMatch("李国辉")
someMatch("haha")
10.scala函数高级操作:
10.1 字符串的高级操作
知识点一: 字符串的拼接
val a = "hello,"
val b= "liguohui"
println(s"$a+$b") //获取参数的值通过$符号获取,并且在获取前加上一个s
知识点二: 多行字符串
val c =
"""
|这是多行字符串的写法
|在双引号里面,然后按shift+" 就出现三队双引号
|很好用哦
""".stripMargin
println(s"这是多行字符串:$c")
10.2 匿名函数
函数是可以命名的,也可以不命名
val m1 = (x:Int,y:Int) => x+y
然后调用 m1(10,1) res 11
10.3 curry函数
定义: 将原来接收两个参数的一个函数,转换成2个
以前的方法:
def add(x:Int,y:Int) = x+y
调用的时候add(1,2)
curry函数:
def add(x:Int)(y:Int) = x+y
调用的时候直接add(1)(2)
10.4 高阶函数(重要)
10.4.1 map函数
逐个去操作集合中的每个元素
写法一:
val l = List(1,2,3,4,5,6,7)
l.map(x => x+1) /** 符号'=>' 左边的表示入参,就是指代集合中一个一个的元素,'=>'后面表示的就是具体的逻辑操作
写法二:
val l = List(1,2,3,4,5,6,7)
l.map( _ + 1) /** 符号'_'表示占位符,指代任何参数
//filter相当于过滤,里面是过滤条件
//take 函数是获取集合的前几个值
l.take(4).foreach(print) /** 获取l中的前四个值
println("======")
l.map(x => x+1).filter(_ > 6).foreach(println)
10.4.2 filter 过滤函数 flatmap 压缩函数 foreach 遍历函数 reduce 执行操作函数
//filter相当于过滤,里面是过滤条件
//take 函数是获取几个的前几个参数
l.take(4).foreach(print)
println("======")
l.map(x => x+1).filter(_ > 6).foreach(println)
l.reduce(_+_) // 使用前面的占位符加上后面的 如同 1+2 3+3 6+4 依次做累加操作
l.reduce(_-_) // 依次做累减操作
l.reduceLeft(_-_)
val c = l.max
val sum = l.sum
//把各个集合的元素压缩在一个集合中进行输出
val c1 = List(List(1,2),List(3,4),List(6,7)) //此时数据显示 c1: List[List[Int]] = List(List(1, 2), List(3, 4), List(6, 7))
c1.flatten.foreach(print) // 显示结果 res8: List[Int] = List(1, 2, 3, 4, 6, 7)
//把c1集合的元素进行乘以2操作
//原来做法:
c1.map(_.map(_*2)) // 第一个占位符表示那一个集合,第二个表示该集合里面的元素进行乘以2操作 res9: List[List[Int]] = List(List(2, 4), List(6, 8), List(12, 14))
//为了压缩在一个集合中:
c1.flatMap(_.map(_*2)) // res10: List[Int] = List(2, 4, 6, 8, 12, 14)
eg:
val txt = scala.io.Source.fromFile("/Users/fish/hello.txt").mkString; //从磁盘中读取数据
println(txt)
val texts = List(txt)
texts.flatMap(_.split(",")).map(x => (x,1)).foreach(println)
10.5 偏函数
如同match case,但是不同的是,他是被包含在花括号里面的没有macth这个单词的一组case语句
//定义方法: 方法名:PartitalFunction[传过来的参数类型,返回的参数类型]
//入参 返回参数类型
def sayHello:PartialFunction[String,String] = {
case "ligh" => "hha..."
case "李国辉" => "a good man"
}
println(sayHello("ligh"))
11. scala的隐式转换
11.1 隐式转换的概述:
就是为一个已经存在的类添加一个新的方法
java中是动态代理,aop的思想实现
scala中通过隐式转换实现
11.2 隐式转换的实战
//为了实现man类中的人具有飞的功能,因此要用隐式转换
implicit def manToSuperman(name:Man):SuperMan = new SuperMan(man.name)
val man = new Man("pk")
man.fly()
**// 格式: 关键词 def 方法名(名字1:一般类):牛逼的类 = new 牛逼的类(名字1)
本身File没有read方法,自己定义了一个,然后赋给一般类,就有了read方法了
implicit def readAddFile(file:File):RichFile = new RichFile(file);
val file = new File("/Users/fish/hello.txt")
val text = file.read()
print(text)
}
class Man(val name:String){
def eat(): Unit ={
println(s"人[ $name ] eat ...." )
}
}
class SuperMan(name:String) {
def fly(): Unit = {
println(s"人[ $name ] fly ....")
}
}
//将要为file添加一个新的方法read
class RichFile(val file:File){
def read() ={
scala.io.Source.fromFile(file.getPath).mkString
}
隐式转换切面封装:
其实就是上面的关于implicit的方法提取出来,在源类中注释,通过import的方法使用,
object ImplicitAspect extends App{
implicit def manToSuperman(name:Man):SuperMan = new SuperMan(man.name)
implicit def readAddFile(file:File):RichFile = new RichFile(file);
}
然后需要在那个类中使用就可以通过 import ImplicitAspect._ 开始使用
11.3 隐式参数(了解)
定义: 值得是在函数或者方法中,定义一个用implicit修饰的参数,此时,Scala会尝试找到一个指定类型的,
用implicit修饰的对象,即隐式值,并注入参数
eg:
implicit val name = "李国辉";
def testParam(implicit name:String): Unit ={
println(s"[$name]是一个好人...")
}
testParam // res [李国辉]是一个好人...
testParam("liguohui") // res [liguohui]是一个好人...
//但是当出现两个implicit修饰的参数时就会出现错误,因为方法不知道去使用把一个
11.4 隐式类
定义: 就是对类增加implicit限定的类,其主要作用是对类的加强!
implicit class Calculator(x:Int){ //对传入的Int类型的参数做隐式转换,也就意味值所有传过来的整型参数都有add方法
//传入的除了Int类型的参数都不能调用add方法
def add(a:Int) = a+x
}
println(1.add(10))
12 scala操作外部数据
12.1 操作文件
//方式一:
//一行一行的读取文件内容 (重要)
val file = Source.fromFile("/Users/fish/hello.txt")(scala.io.Codec.UTF8)
def readLine() ={
for(line <- file.getLines()){
println("文件的内容:"+line)
}
}
// readLine()
//方式二:
//一个字符一个字符的毒 (重要)
def readChar(): Unit ={
for(ele <- file){
println("读取的结果:"+ele)
}
}
// readChar()
//方式三: (重要)
//根据访问地址进行读取,获取的是该访问路径下的页面的前端代码
def readNet(): Unit ={
val file = Source.fromURL("http://www.baidu.com")
for(line <- file.getLines()){
println(line)
}
}
readNet()
}
总结:
读取方式中,当同时读取一个文件时,有一种方式读取成功,下一个方式就会失效,不再进行读取操作
12.2 读取和操作xml:
其实下面读取配置文件的内容的方法就是对load方法的重载
//读取配置文件的内容
def loadXml(): Unit ={
val text = scala.xml.XML.load(this.getClass.getClassLoader.getResource("test.xml"))
println(text)
}
loadXml()
var xml = XML.load(new FileInputStream("/Users/fish/scala-project/scala-train/src/main/resources/test.xml"))
println("另外一种方式读取:"+xml)
12.3 操作MySQL数据:
// val driver = "com.mysql.jdbc.Driver"
val url = "jdbc:mysql://115.29.32.62:3306/ligh"
val username = "root"
val password = "7d428bc667"
var connection:Connection =null
try{
classOf[com.mysql.jdbc.Driver]
connection = DriverManager.getConnection(url,username,password)
val statement = connection.createStatement()
val resuleSet = statement.executeQuery("select * from user")
while (resuleSet.next()){
val id = resuleSet.getString("id")
val name = resuleSet.getString("name")
println(s"获取的id=[$id]<===>name=[$name]")
}
}catch {
case e:Exception => e.printStackTrace()
}finally {
if (connection==null){
connection.close()
}
}
}
12.4 操作xml (重要)
//读取配置文件的内容
// def loadXml(): Unit ={
val xml = scala.xml.XML.load(this.getClass.getClassLoader.getResource("test.xml"))
println(xml)
// }
// loadXml()
// var xml = XML.load(new FileInputStream("/Users/fish/scala-project/scala-train/src/main/resources/test.xml"))
// println("另外一种方式读取:"+xml)
//获取的是header标签下的field标签下的内容
// val text = xml \ "header" \ "field"
// println("获取的标签下的值:"+text)
//获取所有field标签及其内容
/* val fields = xml \\ "field"
for (field <- fields){
println("所有的field标签内容:"+field)
}*/
//获取header下的field下的name属性的值 下面两种方式均可以
/* val fieldAttributes = (xml \ "header" \ "field" \\ "@name")
//val fieldAttributes = (xml \ "header" \ "field").map(_ \ "@name")
for (res <- fieldAttributes){
println("结果是:"+res)
}*/
//首先是获取所有symbol标签下的值,然后找到ricker属性,转成字符串,进行比较是否是IBM,然后输出
/* val filters = (xml \\ "symbol")
.filter(x => (( x \ "@ricker").text).equals("IBM"))
for (filter <- filters){
println("过滤之后的结果:"+filter)
}*/
(xml \ "symbols" \ "symbol")
.map(x => (x \ "@ricker",x.text,x \ "@hah"))
.foreach(println)
}