scala总结
一、简介
java中main方法: public static void main(String[] args){...}
- scala中没有static关键字
- class: 里面的所有的属性与方法都是非static的
- object: 里面的所有的属性和方法都是类似java static修饰的。
object WordCount {
val name:String = "zhangsan"
/**
* scala中没有public修饰符,默认就是public效果
* def: defined的缩写,def标识方法
* main: 方法名
* Array[String]: Array代表是数组,[]是泛型使用,[]里面的类型代表当前Array中转载的元素类型
* Unit: 相当于java 的void
*
* scala中如果一行只写一个语句，那么;可以省略
* 如果一行写多个语句，;用来分割这多个语句
*/
def main(args: Array[String]): Unit = {
//java语法
System.out.println("wordcount")
//scala
println("wordcount")
println(WordCount.name)
}
}第 1 章 Scala变量和数据类型
1.java注释:
- 单行注释: //
多行注释: /.../
文档注释: /*../
scala的注释与java完全一样
*/
2.定义变量
/**
* java中变量定义: 类型 变量名 = 值
*
*
*
* scala中变量定义语法: val/var 变量名:变量类型 = 值
* val与var的区别:
* val定义的变量不可以被重新赋值
* var定义的变量可以被重新赋值
* scala在定义变量的时候，变量类型是可以省略，省略之后scala会自动推断数据类型
*
* scala定义变量的时候必须初始化
* @param args
*/
def main(args: Array[String]): Unit = {
val name:String = "zhangsan"
//val定义的变量不可以被重新赋值
//name = "lisi"
var age:Int = 100
age = 200
println(name)
println(age)
val address = "shenzhen"
println(address)
}
}3.控制台输入
/**
* scala中读取控制台输入的数据: StdIn
*
* 读取文件内容: Source.fromFile(path,"utf-8")
*/
def main(args: Array[String]): Unit = {
val str = StdIn.readLine("请输入一句话")
println(str)
println(Source.fromFile("d:/data.txt", "utf-8").getLines().toBuffer)
}4.数据类型
/**
* java数据类型:
* 1、基本数据类型
* byte、short、char、int、long、float、double、boolean
* 2、引用数据类型
* String、class、集合、数组
*
* scala数据类型:
* Any: 是所有类的父类
* AnyVal: 值类型
* Byte、Short、Char、Int、Long、Float、Double、Boolean
* Unit: 相当于java的void, 有一个实例()
* StringOps: 对java String的扩展
* AnyRef: 引用类型
* String、scala class、java class、scala集合、java集合,..
* Null: 是所有引用类型的子类, 有一个实例null[null一般是给引用类型赋初始值使用，在定义变量的时候如果使用null赋初始值，此时变量的类型必须定义]
*
* Nothing: 所有类型的子类,但是不是给程序员使用，是scala内部使用
*
* @param args
*/
def main(args: Array[String]): Unit = {
/**
* String str = null
* str = "zhangsan"
*
* class Person
*
* class Student extends Person
*
* Student s = new Student
*
* s = new Person
*/
var s:String = null
s = "zhangsan"
println(s)
//val a:Int = null
//println(a)
}5.获取字符串
/**
* java中如何得到一个字符串:
* 1、通过""包裹
* 2、new String(..)
* 3、通过一些方法
* 4、字符串拼接【+】
* scala中得到一个字符串:
* 1、通过""包裹
* 2、字符串拼接[插值表达式] s"${变量名/表达式}"
* 3、new String(..)
* 4、通过""" """包裹[能够保留字符串的输入的格式]
* 5、通过一些方法
* @param args
*/
def main(args: Array[String]): Unit = {
//1、通过""包裹
val name = "ZHANGSAN"
val address = "shenzhen"
val str = name + address
//2、字符串拼接
val str2= s"${name}-${address}"
println(str2)
val str3 = s"1+1=${1+1}"
println(str3)
val str5 = new String("hello")
println(str5)
//3、通过三引号包裹
val sql =
"""
|create table student(
| id string,
| name string,
| age string)COLUMN_ENCODED_BYTES=0
""".stripMargin
println(sql)
//三引号与插值表达式结合使用
val tableName = "student"
val sql2 =
s"""
|create table ${tableName}(
| id string,
| name string,
| age string)COLUMN_ENCODED_BYTES=0
""".stripMargin
println(sql2)
println(str2.substring(2))
val str6 = "hello %s".format("lisi")
println("http://www.xx.com/aa/bb?ip=%s".format("192.168.1.102"))
println("http://www.xx.com/aa/bb?ip=%d".format(10))
println(str6)
}6 .类型的转换
/**
* 数字和数字的转换
* 1、低精度向高精度转换: Int->Long
* java中: 自动转换
* scala中: 自动转换
* 2、高精度转低精度: Long->Int
* java中: 强转
* scala: toXXX方法
* 数字和字符串的转换
* 1、数字转字符串
* java: 字符串拼接
* scala: 字符串拼接\toString
* 2、字符串转数字
* java: Integer.ValueOf(字符串),..
* scala: toXXX方法
*/
def main(args: Array[String]): Unit = {
//低精度向高精度转换
val a:Int = 10
val b:Long = a
//高精度转低精度
val c:Long = 100
val d:Int = c.toInt
println(d)
//数字转字符串
val s:String = c.toString
val s1:String = s"${c}"
println(s)
println(s1)
//字符串转数字
val s2 = "10"
val e:Int = s2.toInt
println(e)
//字符串中.不一定是小数点
val s3 = "10.0"
//val f:Int = s3.toInt
//println(f)
val g:Double = s3.toDouble
println(g)
}第 2 章 Scala中运算符和流程控制
1.运算符
/**
* java中运算符：
* 1、算数运算符: +、-、*、/、% ++ --
* 2、比较运算符: > < >= <= != ==
* 3、逻辑运算符: && || !
* 4、赋值运算符: = += -= *= /=
* 5、位运算符: < > & | >>
* 6、三元运算符: 逻辑表达式? 表达式1: 表达式2
*
* scala中没有三元运算符，如果想要实现三元运算符可以通过if-else做
* scala没有++、--运算符。
* scala中运算符:
* 1、算数运算符: +、-、*、/、%
* 2、比较运算符: > < >= <= != ==
* 3、逻辑运算符: && || !
* 4、赋值运算符: = += -= *= /=
* 5、位运算符: < > & | >>
*
* scala中运算符都是方法。
*/
def main(args: Array[String]): Unit = {
val a = 10
val c = a + 20
val d = a.+(20)
println(d)
}2.块表达式
/**
* 块表达式: 由{ }包裹的一块代码称之为块表达式
* 块表达式有返回值，返回值是{ }中最后一个表达式的结果值
* 后续大家看到{ }就可以认为是块表达式[ for循环、while循环的大括号不能看做块表达式]
*
*/
def main(args: Array[String]): Unit = {
val b = {
println("hello....")
val c = 10+10
//return "xx"
}
println(b)
println("----------------------")
10
//return "xx"
}3.条件表达式
/**
* java中条件表达式的用法：
* 1、单分支: if
* 2、双分支: if-else
* 3、多分支： if-else if -..-else
*
* scala中条件表达式的用法：
* 1、单分支: if
* 2、双分支: if-else
* 3、多分支： if-else if -..-else
* scala的条件表达式有返回值,返回值是符合条件的分支的{ }的最后一个表达式的结果值
*/
def main(args: Array[String]): Unit = {
val a =10
//单分支
if(a%2==0){
println("a是偶数")
}
//双分支
if(a%3==0){
println("a是3的倍数")
}else{
println("a不是3的倍数")
}
//多分支
if(a%3==0){
println("a是3的倍数")
}else if(a%4==0){
println("a是4的倍数")
}else{
println("其他...")
}
//if表达式有返回值
val b = if(a%2==0){
println("..............")
a*a
}
println(b)
val c = if(a%10==0){
if(a%5==0){
println("5.。。。。。。。。")
a*a
}else{
println("+++++++++++++")
a+10
}
}
println(c)
}
4.for循环
/**
* java的for循环：
* 1、基本for: for(int i=0;i<=100;i++)
* 2、增强for： for(类型 变量: 集合/数组)
*
* scala中重要的两个方法：
* to:
* 用法: startIndex.to(endIndex)
* 结果: 会生成一个左右闭合的集合
* until:
* 用法: startIndex.until(endIndex)
* 结果: 会生成一个左闭右开的集合
* scala中方法调用有两种方式：
* 1、对象.方法名(参数值,..)
* 2、对象 方法名 (参数值,..) [如果方法只有一个参数,此时()可以省略]
* scala for循环语法: for(变量 <- 数组/集合/表达式) { 循环体 }
* for循环的守卫: for(变量 <- 数组/集合/表达式 if(布尔表达式)) { 循环体 }
* 步长: for(变量 <- start to end by step) { 循环体 }
* 嵌套for循环: for(变量 <- 数组/集合/表达式;变量 <- 数组/集合/表达式;...) { 循环体 }
* 变量嵌入: for(变量 <- 数组/集合/表达式; 变量2 = 值 ;变量 <- 1 to 变量2;...)
* for默认是没有返回值的，如果想要for有返回值需要用yield表达式： for(变量 <- 数组/集合/表达式) yield { 循环体 }
*
* @param args
*/
def main(args: Array[String]): Unit = {
//基本用法
for( i <- 1 to 10){
println(s"i=${i}")
}
println("+"*100)
//步长
for( j<- (1 to 10).by(2) ){
println(s"j=${j}")
}
println("-"*100)
for( j<- 1 to 10 by 2 ){
println(s"j=${j}")
}
println("*"*100)
for(k<- 1 to 10){
if(k%2==0){
println(s"k=${k}")
}
}
println("*"*100)
//守卫
for(k<- 1 to 10 if(k%2==0)) {
println(s"k=${k}")
}
/**
* for(k<- 1 to 10){
* println(s"k=${k}")
* if(k%2==0){
* println(s"k=${k}")
* }
* }
* 此循环不能通过守卫简化，因为if语句之前还有其他的语句
*/
println("*"*100)
for(i<- 1 to 10){
for(j<- i to 10){
println(s"i+j=${i+j}")
}
}
//通过scala嵌套for循环简化上面循环
println("*"*100)
for(i<- 1 to 10; j<- i to 10){
println(s"i+j=${i+j}")
}
/* for(i<- 1 to 10){
println(s"i=${i}")
for(j<- i to 10){
println(s"i+j=${i+j}")
}
}
不能使用scala嵌套for循环简化
*/
for(i<- 1 to 10 ){
if(i%2==0){
for(j<- i to 10){
println(s"i+j=${i+j}")
}
}
}
for(i<- 1 to 10 if (i%2==0); j<- i to 10 ){
println(s"i+j=${i+j}")
}
println("*"*100)
for(i<- 1 to 10){
val k = i * i
for(j<- 1 to k){
println(s"i+j=${i+j}")
}
}
println("*"*100)
//变量嵌入简化
for(i<- 1 to 10; k= i*i;j<- 1 to k){
println(s"i+j=${i+j}")
}
//yield表达式
val result = for(i<- 1 to 10) yield {
i * i
}
println(result.toBuffer)
println("------------------")
1 to 10 foreach(println(_))
}
5.while和do-while
/**
- scala中while、do-while的用法与java一样
- while与do-while的区别：
- while 先判断在执行
- do-while 先执行在判断
- @param args
*/
def main(args: Array[String]): Unit = {
var i = 11
while ( i<=10 ){
println(s"i=${i}")
i=i+1
}
println("*"*30)
var j =11
do{
println(s"j=${j}")
j = j+1
}while(j<=10)
}
6.循环控制break
/**
* java中使用break与continue控制循环
* break: 结束整个循环
* continue: 结束本次循环立即开始下一次循环
*
* scala中没有break与continue
* 实现break:
* 1、导入包:
* 2、使用breakable以及break方法
* @param args
*/
def main(args: Array[String]): Unit = {
//break
var i=0
/*while (i<=10){
if(i==5){
throw new Exception("......")
}else{
println(s"i=${i}")
i=i+1
}
}*/
//scala封装的break实现
breakable({
while (i<=10){
if(i==5) break()
println(s"i=${i}")
i=i+1
}
})
//continue
var j=0
/* while (j<=10){
try{
if(j==5){
j=j+1
throw new Exception("...")
}
println(s"j=${j}")
j=j+1
}catch {
case e:Exception =>
}
}*/
//使用scala的封装实现continue
while (j<=10){
breakable({
j=j+1
if(j==5) break()
println(s"j=${j}")
})
}
}
第 3 章 Scala中方法和函数
1.Scala中方法定义
/**
* 方法语法: def 方法名( 变量名:类型,... ) : 返回值类型 = { 方法体 }
*
* scala方法可以定义在方法中
*
* 方法如果定义在类中是可以重载的
*
* 方法如果定义在方法中是不可以重载的
*/
def main(args: Array[String]): Unit = {
val result = add(2,3)
println(result)
//scala方法可以定义在方法中
def add2( x:Int,y:Int ) = { x* y }
//def add2( x:Int ) = { x* 10 }
println(add2(4, 5))
}
//方法如果定义在类中是可以重载的
def add( x:Int , y:Int ) = {
x + y
}
def add( x:Int ) = {
x * 10
}
1.2.Scala方法简化
/**
* scala方法的简化原则:
* 1、如果方法体中只有一行语句，{ }可以省略
* 2、如果方法不需要返回值,那么=可以省略
* 3、如果使用方法体{}中最后一个表达式的结果值作为方法的返回值,那么此时返回值类型可以省略
* 如果方法体中有return关键字必须定义返回值类型
* 4、如果方法不需要参数，那么定义方法的()可以省略
* 如果定义方法的时候没有(),那么在调用方法的时候也不能带上()
* 如果定义方法的时候有(),那么在调用方法的时候()可以省略也可以不省略
* 在简化的时候,=与{ }不能同时省略
*/
def main(args: Array[String]): Unit = {
println(add2(2, 3))
printHello2("lisi")
//如果定义方法的时候没有(),那么在调用方法的时候也不能带上()
printName2
printName()
printName
}
//基本定义方法的语法
def add(x:Int,y:Int):Int = {
x+y
}
//如果方法体中只有一行语句，{}可以省略
def add2(x:Int,y:Int):Int = x+y
//基本语法
def printHello(name:String):Unit = {
println(s"hello ${name}")
}
//如果方法不需要返回值,那么=可以省略
def printHello2(name:String) {
println(s"hello ${name}")
}
//基本语法
def m1(x:Int,y:Int):Int = {
x+y
}
//如果使用方法体{ }中最后一个表达式的结果值作为方法的返回值,那么此时返回值类型可以省略
def m2(x:Int,y:Int) = {
x+y
}
//如果方法体中有return关键字必须定义返回值类型
def m3(x:String) = {
/* if(x==null) return null;
return "hello";*/
if(x==null) {
null
}else{
"hello"
}
}
//基本语法
def printName():Unit = {
println(".............")
}
//如果方法不需要参数，那么定义方法的是()可以省略
def printName2:Unit = {
println("............")
}
/**
* 在简化的时候,=与{}不能同时省略
*/
def printName3 = println("............")
1.3.Scala方法参数
/**
* java方法参数:
* 1、public 返回值类型 方法名(类型 参数名,..) { 方法体 }
* 2、可变参数: public 返回值类型 方法名(类型... 参数名) { 方法体 }
* scala方法的参数
* 1、正常形式: def 方法名(参数名:类型,..):返回值类型 = {方法体}
* 2、默认值: def 方法名(参数名:类型=默认值,..):返回值类型 = {方法体}
* 如果默认值单独使用,在定义方法的时候需要将默认值定义在参数列表最后面
* 3、带名参数:
* 指调用方法的时候将指定值传递给哪个参数: 方法名(参数名=值)
* 4、可变参数: def 方法名(参数名:参数类型,..,参数名:参数类型*)
* 可变参数必须定义在参数列表的最后面
* 可变参数不能与默认值参数、带名参数一起使用
* 可变参数不能直接传递集合，但是可以通过 集合名称:_* 的方式将集合的所有元素传递给可变参数
*
* @param args
*/
def main(args: Array[String]): Unit = {
println(add(2, 3))
println(add2())
// 如果默认值单独使用,在定义方法的时候需要将默认值定义在参数列表最后面
println(add3(10))
//带名参数: 指调用方法的时候将指定值传递给哪个参数
println(add4(y=10))
println(add5(10,20,3,4,5,6,7,8))
val paths = getPaths(7,"/user/warehouse/hive/user_info")
readPaths(paths:_*)
}
def add(x:Int,y:Int) = x+y
//默认值: def 方法名(参数名:类型=默认值,..):返回值类型 = {方法体}
def add2(x:Int=10,y:Int=20) = x+y
// 如果默认值单独使用,在定义方法的时候需要将默认值定义在参数列表最后面
def add3(y:Int,x:Int=10) = x+y
def add4(x:Int=10,y:Int) = x+y
def add5(x:Int,y:Int,z:Int*) = {
x+y+z.sum
}
/**
* /user/warehouse/hive/user_info/20201017
* /user/warehouse/hive/user_info/20201016
* /user/warehouse/hive/user_info/20201015
* /user/warehouse/hive/user_info/20201014
* /user/warehouse/hive/user_info/20201013
* /user/warehouse/hive/user_info/20201012
* /user/warehouse/hive/user_info/20201011
* /user/warehouse/hive/user_info/20201010
*
* 需求: 统计前7天的用户注册数
*/
def readPaths(path:String*): Unit ={
//模拟读取数据
println(path.toBuffer)
}
def getPaths(n:Int,pathPrefix:String) = {
//获取当前日期
val currentDate = LocalDateTime.now()
for(i<- 1 to n) yield {
//日期加减法
val time = currentDate.plusDays(-i)
//拼接路径
val str = time.format(DateTimeFormatter.ofPattern("yyyyMMdd"))
s"${pathPrefix}/${str}"
}
}
2.Scala中函数的定义
/**
* 函数的语法: val 函数名 = (参数名:参数类型,....) => { 函数体 }
* 函数的返回值就是函数体的块表达式的结果值
* 函数不可以重载，因为函数名其实就是变量名，同一作用域不能存在同名参数
*
* 函数的简化：
* 1、如果函数体中只有一行语句，{}可以省略
*
* 函数在调用的时候必须带上()
*/
def main(args: Array[String]): Unit = {
println(add(2, 3))
//方法就是函数,函数也是对象
println(add(2,3))
println(add2(2,3))
println(add3(2,3))
println(add4)
}
val add = (x:Int,y:Int) => {
x-y
}
val add4 = () => 10 * 10
val add3 = (x:Int,y:Int) => x+y
//函数不可以重载，因为函数名其实就是变量名，同一作用域不能存在同名参数
/* val add = (x:Int) => {
x-10
}*/
val add2 = new Function2[Int,Int,Int] {
override def apply(v1: Int, v2: Int): Int = v1-v2
}
3.Scala中方法和函数的区别
/**
* 方法和函数的区别:
* 1、方法如果定义在类里面，可以重载，函数因为是对象，所以不能重载
* 2、方法是保存在方法区,函数是对象保存在堆里面
* 联系:
* 1、如果方法定义在方法里面,它其实就是函数
* 2、方法可以手动转成函数: 方法名 _
*/
def main(args: Array[String]): Unit = {
val f = m1 _
println(f(2,3))
}
/**
* 方法重载
*/
def add(x:Int,y:Int):Int = x+y
def add(x:Int) = x * x
val func = (x:Int,y:Int) => x+y
//val func = (x:Int) => x*x
def m1(x:Int,y:Int) = x+y
4.高阶函数
/**
* 高阶函数: 以函数作为参数或者返回值的方法/函数称之为高阶函数
*
*
*/
def main(args: Array[String]): Unit = {
val func = (x:Int,y:Int) => x+y
println(add(10, 20, func))
//方法就是函数
//println(add(3,5,m1 _))
println(add(3,5,m1))
}
/**
* 高阶函数
* @param x
* @param y
* @param func 函数对象，封装的操作
* @return
*/
def add(x:Int,y:Int,func: (Int,Int)=>Int ) = {
func(x,y)
}
def m1(x:Int,y:Int) = x*y
4.1高阶函数的简化
/**
* 高阶函数的简化：
* 1、将函数作为值进行传递
* 2、函数的参数类型可以省略
* 3、如果函数的参数在函数体中只使用了一次,那么可以用_代替
* 1、如果在函数体中参数的使用顺序与参数的定义顺序不一致，不能用_代替
* 2、如果函数的参数只有一个,并且在函数体中没有做任何操作直接将函数的参数返回,此时也不能用_代替
* 4、如果函数只有一个参数,函数参数列表的()可以省略
*
*/
def main(args: Array[String]): Unit = {
val func = (x:Int,y:Int)=>x*y
println(add(3, 5, func))
//1、将函数作为值进行传递
println(add(3,5, (x:Int,y:Int)=>x*y ))
//2、函数的参数类型可以省略
println(add(3,5, (x,y)=>x*y ))
//3、如果函数的参数在函数体中只使用了一次,那么可以用_代替
// 前提:
// 1、如果在函数体中参数的使用顺序与参数的定义顺序不一致，不能用_代替
// 2、如果函数的参数只有一个,并且在函数体中没有做任何操作直接将函数的参数返回,此时也不能用_代替
// 3、如果函数体中有嵌套,并且函数的参数处于嵌套中以表达式的方法存在,,此时也不能用_代替
println(add(3,5, _+_ ))
// 1、如果在函数体中参数的使用顺序与参数的定义顺序不一致，不能用_代替
println(add(3,5, (x,y)=>y-x )) //不能用_简化
//println(add(3,5,_-_))
val func2 = (x:Int) => x
println(m1(5, func2))
println(m1(5, (x:Int) => x))
println(m1(5, (x) => x))
//不能用_简化
val result = m1(5, _)
//println(m1(5, _))
//
//println(result(func2))
//4、如果函数只有一个参数,函数参数列表的()可以省略
println(m1(5, x => x))
val func10 = (x:Int) => (x+10)*2
println(add3(10, x => (x+10)*2))
println(add3(20,x=>(x)+10))
println(add3(20,(_)+10))
}
def add(x:Int,y:Int,func: (Int,Int)=>Int ) = func(x,y)
def m1(x:Int, func: Int => Int) = func(x)
def add3(x:Int,func: Int=>Int) = func(x)
4.2高阶函数例子
/**
* 1、定义一个高阶函数，按照指定的规则对集合里面的每个元素进行操作
* 比如: val arr = Array[String]("spark","hello","java","python")
* 对集合中每个元素进行操作，得到集合每个元素的长度
* val result = Array[Int](5,5,4,6)
*/
def main(args: Array[String]): Unit = {
val arr = Array[String]("spark","hello","java","python")
val func = (x:String) => x.charAt(2).toInt
val result = map(arr,func)
println(result.toBuffer)
}
def map(arr:Array[String],func: String => Int)={
for(element<- arr) yield {
func(element)
}
}
4.3定义高阶函数对元素进行聚合
/**
* 2、定义一个高阶函数，按照指定的规则对集合中的所有元素进行聚合
* val arr =Array[Int](10,2,4,6,1,8,10)
* 求得集合中的所有元素的和
* val result = xx
*/
def main(args: Array[String]): Unit = {
val arr =Array[Int](10,2,4,6,1,8,10)
val func = (agg:Int,curr:Int)=> agg * curr
println(reduce(arr, func))
//1、将函数作为参数直接传递
println(reduce(arr, (agg:Int,curr:Int)=> agg * curr))
//2、函数的参数类型可以省略
println(reduce(arr, (agg,curr)=> agg * curr))
//3、函数的参数在函数体中只使用了一次，可以用_代替
println(reduce(arr, _ * _))
}
def reduce( arr:Array[Int],func: (Int,Int)=>Int )={
var tmp:Int = arr(0)
for(i<- 1 until arr.length) {
tmp = func(tmp,arr(i))
}
tmp
}
4.4定义高阶函数求最大元素
/**
* 3、定义一个高阶函数，按照指定的规则获取指定最大元素
* val arr = Array[String]("zhangsan 20 3000","lisi 30 4000","wangwu 15 3500")
* 获取年龄最大的人的数据
* val result = "lisi 30 4000"
*
*/
def main(args: Array[String]): Unit = {
val arr = Array[String]("zhangsan 20 3000","lisi 30 4000","wangwu 15 3500")
val func = (x:String,y:String) => {
val first = x.split(" ")(2).toInt
val last = y.split(" ")(2).toInt
if(first>last) {
x
}else{
y
}
}
println(maxBy1(arr, func))
println(maxBy2(arr, (x: String) => x.split(" ")(2).toInt))
}
def maxBy1( arr:Array[String], func: (String,String)=> String)={
var tmp = arr(0)
for(i<- 1 until arr.length){
tmp = func(tmp,arr(i))
}
tmp
}
def maxBy2( arr:Array[String],func: String=>Int) = {
var tmp = func(arr(0))
var result = arr(0)
for(element<- arr){
if(tmp<func(element)){
tmp = func(element)
result = element
}
}
result
}
4.6定义高阶函数进行分组
/**
* 4、定义一个高阶函数，按照指定的规则对数据进行分组
* val arr = Array[String]("zhangsan 男 深圳","lisi 女 深圳","王五 男 北京")
* 根据性别进行分组
* val result = Map[String,List[String]](
* "男"-> List("zhangsan 男 深圳","王五 男 北京"),
* "女" -> List("lisi 女 深圳")
* )
*
*/
def main(args: Array[String]): Unit = {
val arr = Array[String]("zhangsan 男 深圳","lisi 女 深圳","王五 男 北京")
val func = (x:String) => x.split(" ")(1)
println(groupBy(arr, func))
println(groupBy(arr,(x:String) => x.split(" ")(1)))
println(groupBy(arr,(x) => x.split(" ")(1)))
println(groupBy(arr,x => x.split(" ")(1)))
println(groupBy(arr,_.split(" ")(1)))
}
def groupBy( arr:Array[String],func: String=>String )={
//1、创建一个分组的存储容器
val result = new util.HashMap[String,util.List[String]]()
//2、遍历集合所有元素
for(element<- arr){
//得到分组的key
val key = func(element)
//3、判断分组的key是否在容器中存在，如果不存在，则直接添加到容器中
if(!result.containsKey(key)){
val list = new util.ArrayList[String]()
list.add(element)
result.put(key,list)
}else{
//4、如果存在，此时应该取出key对应的List，将元素添加到List
val list = result.get(key)
list.add(element)
}
}
//5、返回结果
result
}
4.7定义高阶函数对元素进行过滤
/**
* 5、定义一个高阶函数，按照指定的规则对数据进行过滤，保留符合要求的数据
* val arr =Array[Int](10,2,4,6,1,8)
* 只保留偶数数据
* val result = Array[Int](10,2,4,6,8)
*/
def main(args: Array[String]): Unit = {
val arr =Array[Int](10,2,4,6,1,8)
println(filter(arr, x => x % 2 == 0).toBuffer)
}
def filter( arr: Array[Int], func: Int => Boolean )={
for(element<- arr if( func(element) )) yield {
element
}
}
5.匿名函数
/**
* 匿名函数: 没有函数名的函数
* 匿名函数不能单独使用,只能将匿名函数作为高阶函数的参数进行传递
*/
def main(args: Array[String]): Unit = {
val func = (x:Int,y:Int) => x+y
println(func(20, 10))
//(x:Int,y:Int) => x+y
def add(x:Int,y:Int,func: (Int,Int)=>Int) = {
func(x,y)
}
println(add(10, 20, (x: Int, y: Int) => x + y ))
}
6.柯里化
/**
* 柯里化: 有多个参数列表的方法称之为柯里化
* @param args
*/
def main(args: Array[String]): Unit = {
println(add(10, 20,30))
println(add2(10, 20)(30))
val func = add3(10,20)
println(func(30))
println(add3(10, 20)(30))
println(add4(10,20)(30))
val func2 = add2 _
val func3 = add3 _
}
def add(x:Int,y:Int,z:Int) = x+y+z
//柯里化
def add2(x:Int,y:Int)(z:Int) = x+y+z
/**
* 柯里化演变过程
*/
def add3(x:Int,y:Int) = {
val func = (z:Int) => x+y+z
func
}
def add4(x:Int,y:Int) = {
// Person p = new Person
// return new Person;
//val func = (z:Int) => x+y+z
//func
(z:Int) => x+y+z
}
7.闭包
/**
* 闭包： 函数体中使用了不属于自身的变量的函数
* @param args
*/
def main(args: Array[String]): Unit = {
println(func(100))
}
val b = 10
/**
* 闭包
*/
val func = (x:Int) => {
val c = 10
x + c + b
}
def add(x:Int,y:Int) = {
/* val func = (z:Int)=> {
val func2 = (a:Int)=> a+x+y+z
func2
}
func*/
(z:Int)=> {
(a:Int)=> a+x+y+z
}
}
8.递归
/**
* 递归: 自己调用自己称之为递归
* 前提:
* 1、必须要有退出条件
* 2、递归必须定义返回值类型
*/
def main(args: Array[String]): Unit = {
println(m1(5))
}
def m1(n:Int):Int = {
if(n==1){
1
}else{
n * m1(n-1)
}
}
9.惰性求值
/**
* 惰性求值: 变量只有在真正使用的时候才会赋值
* @param args
*/
def main(args: Array[String]): Unit = {
lazy val name = "zhangsan"
val age = 20
println(name)
println(age)
}
10.控制抽象
/**
* 控制抽象: 其实就是一个块表达式,可以将块表达式作为参数[ => 块表达式的结果值类型 ]传递给方法，后续当做函数进行调用
*
* 控制抽象只能用于方法的参数
* 控制抽象在调用的时候不能带上()
* @param args
*/
def main(args: Array[String]): Unit = {
val b = {
println("xxxxxxxxxxxx")
val c = 20
c * c
}
def m1(x:Int) = {
println(x*x)
}
m1({
println("xxxxxxxxxxxx")
val c = 20
c * c
})
def m2(x:Int,func: Int=>Int) = {
func(x)
func(x)
func(x)
}
m2(10,x=>{
println(".....................")
x+10
})
var i = 0
breakable({
while (i<=10){
if(i==5) break()
println(s"i=${i}")
i=i+1
}
})
val func2 = () => println("hello.........")
func2()
m4({
println("+++++++")
false
})
println("*"*100)
var j = 0
myLoop({
j<=10
})({
println(s"j=${j}")
j = j+1
})
}
def m4(f1: => Unit) = {
//在调用控制抽象的时候不能带上()
f1
f1
f1
}
def myLoop(condition: =>Boolean)(body: =>Unit):Unit = {
if(condition) {
body
myLoop(condition)(body)
}
}
第 4 章 类和对象
1.Scala定义类
//如果class中没有任何东西,{}可以省略
class Person
/**
* java class创建语法: 修饰符 class 名称{...}
*
* scala里面没有public关键字,默认就是public
* scala创建class的语法: class 名称 {...}
* scala创建对象: new class名称(..)
*/
def main(args: Array[String]): Unit = {
//如果使用无参的构造器,()可以省略
val person = new Person
println(person)
}
1.1定义类中属性和方法
class Person{
//定义属性: 修饰符 val/var 属性名:类型 = 值
//val定义的属性不可被修改
//var定义的属性可以被修改
//@BeanProperty注解不能用在private修饰的属性上
@BeanProperty
var name = "zhangsan"
@BeanProperty
var age = 20
/* def setName(name:String) = this.name=name
def getName() = this.name
def setAge(age:Int) = this.age = age
def getAge() = this.age*/
//scala中属性有默认的get/set方法,get的方法名其实就是属性名，set的方法名其实就是 属性名=
//在class中var修饰的属性可以使用_初始化,使用_初始化的时候必须指定属性的类型
var address:String = _
//setXXx getXXx
//JSON解析
//定义方法: 修饰符 def 方法名(参数名:参数类型,...):返回值类型 = {方法体}
def printName () = println(s"name=${name}")
//定义函数: 修饰符 val 函数名 = (参数名:参数类型,...) => {函数体}
val func = (x:Int,y:Int) => x+y
}
def main(args: Array[String]): Unit = {
val person = new Person
println(person.name)
println(person.age)
println(person.address)
person.age=(100)
println(person.age)
person.printName()
println(person.func(10, 20))
println("*"*100)
val json = """{"name":"lisi","age":100}"""
//json转对象
val person2 = JSON.parseObject(json,classOf[Person])
println(person2.name)
println(person2.age)
}
1.2 scala中构造方法
def this(name:String) {
//第一行必须调用其他的辅助构造器或者主构造器
this(name=name,address="beijing")
//this("lisi",100)
}
def this(age:Int) {
this("zhaoliu")
}
def this(name:String,age:Int) {
this(name=name,address="beijing")
}
}
/**
* java中构造方法的定义: 修饰符 类名(参数类型 参数名,..) {..}
*
* scala中构造方法分为两种:
* 1、主构造器: 定义类名后面{}之前,通过()表示
* 主构造器中属性的定义: [修饰符] [val/var] 属性名:类型 = 默认值
* 柱构造器中val/var以及不写val/var的区别：
* val定义的属性不能更改
* var定义的数可以更改
* 使用val/var修饰的非private的属性既可以在class内部使用也可以在class外部使用
* 不用val/var修饰的属性只能在class内部使用
* 2、辅助构造器
* 辅助构造器定义在class里面
* 语法: def this(参数名:参数类型,...){
* //第一行必须调用其他的辅助构造器或者主构造器
* this(..)
* }
*
*/
def main(args: Array[String]): Unit = {
val person = new Person("lisi",100,"shenzhen")
println(person.name)
println(person.age)
println(person.getName)
val person2 = new Person("lisi")
println(person2.getName)
val person3 = new Person(100)
println(person3.getName)
}
1.3 封装
class Person{
@BeanProperty
val name:String = "zhangsan"
//def getName() = this.name
}
/**
* 封装: 属性私有,提供公有的set/get方法
*
* scala中属性一般不私有，通过@BeanProperty注解提供公有的set/get方法
* @BeanProperty对于val修饰的属性只提供get方法
* 对于var修饰的属性提供set与get方法
*/
def main(args: Array[String]): Unit = {
// println($06_Package.AAAAAAA)
val person = new Person
println(person.getName)
}
1.4继承
/*final */class Animal{
/*private */
@BeanProperty val name:String = "zhangsan"
@BeanProperty var age:Int = _
def printHello() = println("...........")
}
class Dog extends Animal{
override val name = "lisi"
override def printHello(): Unit = {
println("888888888888888888888888")
super.printHello()
}
}
/**
* scala中通过extends关键字来实现继承关系
*哪些情况不能被继承:
* 1、private修饰的属性/方法/函数不能被继承
* 2、final修饰的class不能被继承
*子类可以通过override关键字来重写父类的方法/val修饰的属性
*
* var修饰的属性不能通过override来重写
* 子类中可以通过super关键字来调用父类的方法
*
* java中的多态只是方法的多态，属性不多态
* scala中方法和属性都是多态的
*/
def main(args: Array[String]): Unit = {
val dog = new Dog
println(dog.name)
println(dog.age)
dog.printHello()
val animal:Animal = new Dog
animal.printHello()
println(animal.getName)
println(CCCCCCCCCC)
}
1.5scala中包的作用
{
private[chapter06] val AAAAAAA="lisi"
/**
* 包的作用:
* 1、区分同名
* 2、便于管理
* java中对于包的申明方式:
* 1、通过package 包名在.java源文件的第一行
* java中对于包的使用:
* 1、import 包名.*
* 2、import 包名.类名
*java中import导入包必须在声明包后面,class前面
*
* scala中对于包的申明方式:
* 1、通过package 包名在.java源文件的第一行
* 2、通过package 包名{}[通过该方式声明的包在项目结构下看不到但是在target目录下可以看到]
* scala中对于包的使用:
* 1、导入包下所有类: import 包名._
* 2、导入包下某个类: import 包名.类名
* 3、导入包下多个类: import 包名.{类名1,类名2,..}
* 4、导入包下某个类,并起别名: import 包名.{类名=>别名}
* 5、导入包下除开某个类的其他类: import 包名.{类名=>_,_}
* scala可以在任何地方导入包。
* 如果是在父作用域中导入的包，子作用域可以使用
* 子作用域导入的包,父作用域不可以使用
* scala中访问修饰符可以搭配package使用: private[包名] val 属性名:类型 = 值 【代表该属性只能在该包下使用】
*
* 包对象:
* 语法: package object 包名{...}
* 包对象中非private修饰的属性/方法/函数可以在包下任何地方使用
*/
def main(args: Array[String]): Unit = {
import scala.util.control.Breaks._
val scalaMap = new mutable.HashMap[String,String]()
}
}
package bb{
class Student
}
1.6 抽象类
abstract class Animal{
//抽象属性
val name:String
//具体属性
var age:Int = 10
//抽象方法
def m1(x:Int,y:Int)
//具体方法
def add(x:Int,y:Int) = x*y
}
class Dog extends Animal {
//具体方法
override def m1(x: Int, y: Int): Unit = x+y
//重写抽象属性
override val name: String = "lisi"
}
/**
* 抽象类:
* 1、语法: abstract class 类名{....}
* 2、scala的抽象类中可以定义抽象方法，也可以定义具体方法
* scala中抽象类中可以定义抽象属性，也可以定义具体属性
* 抽象方法: 没有方法体的方法称之为抽象方法,定义抽象方法的时候如果不定义返回值类型，返回值默认就是Unit
* 抽象属性: 没有赋予初始值的属性【定义抽象属性的时候，属性的类型必须定义】
*
*/
def main(args: Array[String]): Unit = {
val dog = new Dog
println(dog.m1(10, 20))
println(dog.name)
println(dog.age)
//匿名子类
val p = new Animal {
override val name: String = "zhangsan"
override def m1(x: Int, y: Int): Unit = println(s"${x} ${y}")
}
println(p.name)
p.m1(10,20)
}
1.7 伴生类和伴生对象
object $08_SingleObject {
class Person(val age:Int){
private val name = "艾尔"
def this() = {
this(10)
}
def xx = Person.printHello()
}
object Person{
val age = 100
private def printHello() = {
val person = new Person(20)
println(person.name)
}
def apply(age:Int) = new Person(age)
def apply() = new Person
}
//val name = "xxx"
/**
* 单例对象的语法: object xx{...}
*
* object中所有的方法/属性/函数都是类似java static修饰的。可以通过 object名称.属性/方法/函数 的方法调用
*
* 伴生类和伴生对象
* 1、class与object的名称要一致
* 2、class与object要在同一个.scala文件中
*
* 伴生类和伴生对象可以互相访问对方private修饰的属性/方法/函数
*
* apply方法: 主要用来简化伴生类的对象创建
* 后续可以通过 object名称.apply(..) / object名称(..) 创建伴生类的对象
* @param args
*/
def main(args: Array[String]): Unit = {
val obj1 = $08_SingleObject
val obj2 = $08_SingleObject
println(obj1)
println(obj2)
//println($08_SingleObject.name)
val person = new Person(20)
person.xx
val person4 = Person.apply(10)
person4.xx
val person5 = Person(10)
person5.xx
val arr = Array[Int](10,20,30,40)
val p = Person()
}
}
2. 特质
trait Logger{
//抽象属性
val name:String
//具体属性
val age:Int = 20
//抽象方法
def add(x:Int,y:Int):Int
//具体方法
def m1(x:Int) = x * x
}
trait Logger2
class A
class WarnLogger extends A with Logger with Logger2 {
override val name: String = "zhangsan"
override def add(x: Int, y: Int): Int = x+y
}
/**
* 语法: trait 特质名{....}
* 在trait中既可以定义抽象方法也可以定义具体方法
* 既可以定义抽象字段也可以定义具体字段
*
* 子类如果需要继承父类，extends关键字用来继承父类，trait的实现通过with关键字来做
* 子类如果不需要继承父类,extends关键字用来继承第一个trait，后续其他的trait通过with关键字实现
*
*/
def main(args: Array[String]): Unit = {
//匿名子类
val logger = new Logger {
override val name: String = "lisi"
override def add(x: Int, y: Int): Int = x * y
}
println(logger.add(10, 20))
val warn = new WarnLogger
println(warn.add(100,200))
}
2.1对象混入
trait Logger{
def add(x:Int,y:Int) = x+y
}
class Warnlogger
/**
* 对象混入: 只让某个对象拥有特质的属性和方法
* 语法: new class名称 with 特质名
* @param args
*/
def main(args: Array[String]): Unit = {
val warnlogger = new Warnlogger with Logger
println(warnlogger.add(10, 20))
val a = new Warnlogger
//a.add()
}
2 .2 trait方法
trait ParentLogger{
def log(msg:String) = println(s"ParentLogger:${msg}")
}
trait Logger1 extends ParentLogger{
override def log(msg:String) = {
println(s"Logger1:${msg}")
}
}
trait Logger2 extends ParentLogger{
override def log(msg:String) = {
println(s"Logger2:${msg}")
}
}
trait Logger3 extends ParentLogger{
override def log(msg:String) = {
println(s"Logger3:${msg}")
}
}
class A extends Logger1 with Logger2 with Logger3{
override def log(msg: String): Unit ={
println(s"A:${msg}")
super[Logger2].log(msg)
}
}
/**
* scala可以多实现，如果实现的多个trait中有同名方法，子类实现这多个trait之后相当于有多个同名方法
* 解决方案:
* 1、在子类中重写父trait的同名方法
* 2、创建一个新trait，在新trait中创建一个同名方法，子类的父trait全部继承该新trait。
* 如果父trait中有通过super关键字调用同名方法，此时调用顺序是按照继承顺序从右向左开始调用
* @param args
*/
def main(args: Array[String]): Unit = {
val a = new A
a.log("xxxx")
}
2.3 对象的序列化
class Logger
trait ReadAndWrite{
_:Serializable =>
/**
* 从磁盘读取对象
*/
def read() = {
val ois = new ObjectInputStream(new FileInputStream("d:/obj.txt"))
val obj = ois.readObject()
ois.close()
obj
}
/**
* 将当前对象写入磁盘
*/
def write() = {
val oos = new ObjectOutputStream(new FileOutputStream("d:/obj.txt"))
oos.writeObject(this)
oos.close()
}
}
class Person(val name:String,val age:Int) extends ReadAndWrite with Serializable
/**
* 定义一个trait,trait中自带read、write两个方法能够实现将当前对象读取/写入到磁盘
*
* 自身类型: 子类在实现trait的时候提示必须要先继承/实现某个类型
*/
def main(args: Array[String]): Unit = {
val person = new Person("lisi",20)
person.write()
val p = new Person("zhangsan",30)
val obj = p.read()
println(obj.asInstanceOf[Person].name)
}
3. Scala类型检查
class Animal{
def xx() = println("Animal")
}
class Dog extends Animal{
val name= "xx"
override def xx() = println("Dog")
}
class Pig extends Animal{
val age= 20
override def xx() = println("Dog")
}
def getAnimal() = {
val r = Random.nextInt(10)
if(r%5==0)
new Dog
else if(r%2==0)
new Pig
else
new Animal
}
/**
* java类型判断: 对象 instanceof 类型
* java中类型的强转: (类型)对象
*
* scala类型判断: 对象.isInstanceOf[类型]
* scala中类型强转: 对象.asInstanceOf[类型]
*
* java中获取对象的class形式: 对象.getClass()
* java中获取类的class形式: 类名.class
*
* scala中获取对象的class形式: 对象.getClass()
* scala中获取类的class形式: classOf[类名]
*
*
*/
def main(args: Array[String]): Unit = {
val animal = getAnimal()
println(animal.getClass)
if(animal.isInstanceOf[Animal]){
val pig = animal.asInstanceOf[Pig]
println(pig.age)
}else{
val dog = animal.asInstanceOf[Dog]
println(dog.name)
}
}
4. 枚举类
object Test20 extends App {
println("xxxxxxxxxxx");
}
object $14_App {
// 枚举类
object Color extends Enumeration {
val RED = Value(1, "red")
val YELLOW = Value(2, "yellow")
val BLUE = Value(3, "blue")
}
def main(args: Array[String]): Unit = {
println(Color.RED)
}
}
5. 类起别名
/**
* 新类型: 给类起别名
* type myarr = Array[String]
*/
def main(args: Array[String]): Unit = {
type s = String
type myarr = Array[String]
val name:s = "name"
val arr:myarr = Array[String]("....")
}
第 5 章 数组和集合
5.1 数组
5.1.1不可变数组
/**
* 1、不可变数组的创建方式：
* 1、Array[元素类型](初始元素,..)
* 2、new Array[元素的类型](数组的长度)
*
* 2、插入数据
* 3、删除数据
* 4、获取数据
* 5、修改数据
*
* 一个+与两个+的区别:
* 一个+ 是添加单个元素
* 两个+ 是添加一个集合的所有元素
* 冒号在前与冒号在后的区别:
* 冒号在前 是将元素添加在集合的最末尾
* 冒号在后 是将元素添加在集合的最前面
* 不带冒号 是将元素添加在集合的最末尾
*/
def main(args: Array[String]): Unit = {
//Array[元素类型](初始元素,..)
val arr = Array[Int](10,2,4,6,1)
println(arr.toBuffer)
//new Array[元素的类型](数组的长度)
val arr2 = new Array[Int](10)
println(arr2.toBuffer)
//添加数据
val arr3 = arr.+:(20)
println(arr3.toBuffer)
println(arr.toBuffer)
val arr4 = arr.:+(30)
println(arr4.toBuffer)
//添加一个集合所有元素
val arr5 = arr.++(Array(100,200,300))
println(arr5.toBuffer)
val arr6 = arr.++:(Array(400,500,600))
println(arr6.toBuffer)
//获取元素
val element = arr6(2)
println(element)
//修改元素
arr6(2)=1000
//将不可变数组转可变数组
println(arr6.toBuffer)
for(i<- arr){
println(i)
}
}
5.1.2 可变数组
/**
* 1、可变数组的创建：
* 1、ArrayBuffer[元素类型](初始元素,...)
* 2、new ArrayBuffer[元素类型]()
* 2、添加元素
* 3、删除元素
* 4、修改元素
* 5、获取元素
* 集合方法的区别:
* 一个+/-与两个+/-的区别:
* 一个+/-是添加单个元素
* 两个+/-是添加一个集合的所有元素
* 冒号在前与冒号在后以及不带冒号的区别:
* 冒号在前是将元素添加在集合的末尾
* 冒号在后是将元素添加在集合的最前面
* 不带冒号是将元素添加在集合的末尾
* 带=与不带=的区别:
* 带=是修改集合本身
* 不带=是生成新集合，原有集合没有改变
* +与-的区别:
* +是指添加元素
* -是指删除元素
*/
def main(args: Array[String]): Unit = {
//1、ArrayBuffer[元素类型](初始元素,...)
val arr = ArrayBuffer[Int](2,5,7,1,3)
println(arr)
//2、new ArrayBuffer[元素类型]()
val arr2 = new ArrayBuffer[Int]()
println(arr2)
//添加元素
val arr3 = arr.+:(10)
println(arr3)
println(arr)
arr.+=(20)
println(arr)
arr.+=:(30)
println(arr)
val arr4 = arr.++(Array(100,200))
println(arr4)
val arr5 = arr.++:(Array(300,400))
println(arr5)
arr.++=(Array(1000,3000))
println(arr)
arr.++=:(Array(400))
println(arr)
arr.+=:(500)
arr.+=:(400)
println("*"*100)
println(arr)
//删除元素
val arr6 = arr.-(400)
println(arr6)
arr.-=(1000)
println(arr)
val arr7 = arr.--(Array(400,500,30))
println(arr7)
arr.--=(Array(2,5,7,50))
println(arr)
//获取元素
println(arr(2))
//修改元素
arr(2)=50
println(arr)
//可变数组转不可变数组
println(arr.toArray)
//多维数组
val array = Array.ofDim[Int](3,4)
println(array.length)
println(array(0).length)
}
5.1.2 List
/**
* 1、创建方式:
* 1、List[元素类型](初始元素,...)
* 2、元素 :: 元素 :: .. :: list/Nil
* :: 最后面必须要是一个List或者是Nil
* Nil就是相当于是List的子类
*
* ::与:::的区别：
* ::是添加单个元素
* ::: 是添加一个集合的所有元素
*/
def main(args: Array[String]): Unit = {
//1、List[元素类型](初始元素,...)
val list = List[Int](10,20,30)
println(list)
//元素 :: 元素 :: .. :: list/Nil
val list2 = 10 :: 20 :: 30 :: Nil
println(list2)
var list3:List[Int] = Nil
list3 = list2
//2、添加元素
val list4 = list2.:+(50)
println(list4)
val list6 = list2.+:(60)
println(list6)
val list7 = list2.++(Array(100,200,300))
println(list7)
val list8 = list2.++:(Array(400,500,600))
println(list8)
val list9 = 100 :: list8
println(list9)
val list10 = list9 ::: list
println(list10)
//获取元素
println(list10(2))
//修改元素
//list10(2) = 1000
val list11 = list10.updated(2,1000)
println(list11)
//List转数组
println(list11.toBuffer)
}
5.1.3可变List
/**
* 1、创建方式: ListBuffer[元素类型](初始元素,....)
*/
def main(args: Array[String]): Unit = {
//创建方式: ListBuffer[元素类型](初始元素,....)
val list = ListBuffer[Int](10,20,30)
println(list)
//添加元素
val list2 = list.+:(40)
println(list2)
val list3 = list.:+(50)
println(list3)
list.+=(60)
println(list)
list.+=:(70)
println(list)
val list5 = list.++(Array(80,90,100))
println(list5)
val list6 = list.++:(Array(200,300))
println(list6)
list.++=(Array(100,200))
println(list)
list.++=:(Array(1000,2000))
println(list)
list.append(500,600,700)
println(list)
//删除元素
val list8 = list.-(1000)
println(list8)
list.-=(2000)
println(list)
val list9 = list.--(Array(10,20,30))
println(list9)
list.--=(Array(500,600,700))
println(list)
list.remove(0)
println(list)
//获取元素
println(list(0))
//修改
list(0)=1000
println(list)
list.update(1,200)
println(list)
val list10 = list.updated(3,500)
println(list10)
}
不可变set
/**
* set的特点: 无序、不重复
* 创建方式: Set[元素类型](初始元素,...)
*/
def main(args: Array[String]): Unit = {
val set = Set[Int](1,5,5,2,10,3)
println(set)
//添加元素
val set2 = set.+(20)
println(set2)
val set3 = set.++(Array(100,500,200))
val set4 = set.++:(Array(100,500,200))
println(set3)
println(set4)
//删除元素
val set5 = set4.-(500)
println(set5)
val set6 = set4.--(Array(2,10,100))
println(set6)
//获取元素
//修改元素
for(i<- set4){
println(i)
}
}
可变set
def main(args: Array[String]): Unit = {
//创建方式: mutable.Set[元素类型](初始元素,...)
val set = mutable.Set[Int](10,2,6,1,3)
println(set)
//添加元素
val set2 = set.+(10)
set.+=(20)
println(set2)
println(set)
val set3 = set.++(Array(100,200))
val set4 = set.++:(Array(100,200))
set.++=(Array(300,400))
println(set3)
println(set4)
println(set)
set.add(1000)
println(set)
//删除元素
val set5 = set.-(300)
set.-=(400)
println(set5)
println(set)
val set6 = set.--(Array(300,2,20))
set.--=(Array(10,2,1,6))
println(set6)
println(set)
set.remove(1000)
println(set)
//set.update()
}
元组
object $07_Tuple {
class Person(val name:String,val age:Int,val address:String)
class School(val name:String,val clazz:Clazz)
class Clazz(val name:String,val student:Student)
class Student(val name:String,val age:Int)
/**
* 创建方式：
* 1、通过()方式创建: (初始元素,..)
* 2、如果是创建二元元组,还可以 K->V 的方式创建
* 元组一旦创建,长度以及元素都不可改变
* 元组最多只能存放22个元素
* 元组的值的获取: 元组的变量._角标 【角标从1开始】
*/
def main(args: Array[String]): Unit = {
//1、通过()方式创建: (初始元素,..)
val t1 = ("zhangsan",20,"beijing")
//2、如果是创建二元元组,还可以 K->V 的方式创建
val t2 = "zhangsan" -> 20
println(t1._1)
val school = new School("宝安中学",new Clazz("xx",new Student("lisi",20)))
val school2 = ("宝安中学",("xx",("lisi",20)))
println(school2._2._2._1)
}
def m1(name:String,age:Int,address:String) = {
(name,age,address)
}
}
不可变Map
/**
* 创建方式:
* 1、Map[K的类型,V的类型]( (K,V),(K,V),... )
* 2、Map[K的类型,V的类型] ( K -> V ,...)
* Map中不能有重复key
* Option: 提醒外部当前可能返回数据为空需要进行处理
* Some: 表示非空,数据封装在Some中,后续可以通过get方法获取数据
* None: 表示为空
*/
def main(args: Array[String]): Unit = {
val map = Map[String,Int]( ("zhangsan",20),("lisi",30),("zhangsan",40) )
val map2 = Map[String,Int]( "zhangsan"->20,"lisi"->30)
println(map)
println(map2)
//添加元素
val map3 = map.+("wangwu"->30)
val map4 = map.++( Map(("aa",1),("bb",2)) )
println(map3)
println(map4)
val map5 = map.++:(Map(("aa",1),("bb",2)))
println(map5)
println(map5.getClass)
//更新
val map6 = map5.updated("cc",100)
println(map6)
//获取key对应的value数据
//println(map6("dd"))
//println(map6.get("dd").get)
println(map6.getOrElse("dd", 1000))
//获取map所有的key
for(key<- map6.keys){
println(key)
}
//获取所有的value
for(value<- map6.values){
println(value)
}
}
可变Map
/**
* 创建方式:
* 1、mutable.Map[K的类型,V的类型]( (K,V),(K,V),.. )
* 2、mutable.Map[K的类型,V的类型]( K->V,.. )
* @param args
*/
def main(args: Array[String]): Unit = {
val map = mutable.Map[String,Int]( ("zhangsan",20),("lisi",30) )
val map2 = mutable.Map[String,Int]( "zhangan"->30,"lisi"->20)
println(map)
println(map2)
//添加元素
val map3 = map.+( "wangwu"->25 )
map.+=( "aa"->10)
println(map3)
println(map)
val map4 = map.++(Map[String,Int]("cc"->1,"dd"->2))
val map5 = map.++:(Map[String,Int]("ee"->10,"ff"->20,"aa"->30))
println(map4)
println(map5)
map.++=(Map[String,Int]("pp"->100,"ww"->200))
println(map)
map.put("tt",1000)
println(map)
//删除元素
val map6 = map.-("aa")
println(map6)
map.-=("ww")
println(map)
val map7 = map.--(List("lisi","tt"))
println(map7)
map.--=(List("zhangsan","pp"))
println(map)
map.remove("lisi")
println(map)
//获取元素
println(map.getOrElse("ddd",-1))
//获取所有key
for(key<- map.keys){
println(key)
}
//获取所有的vlaue
for(value<- map.values){
println(value)
}
//修改元素
map("aa")=1000
println(map)
map.update("tt",100)
println(map)
val map10 = map.updated("tt",1)
println(map10)
println(map)
}
获取集合属性
def main(args: Array[String]): Unit = {
val list = List[Int](10,20,30)
//获取集合的长度
println(list.size)
println(list.length)
//是否包含某个元素
println(list.contains(100))
//判断集合是否为空
println(list.isEmpty)
//判断集合是否不为空
println(list.nonEmpty)
//生成字符串
println(list)
println(list.mkString("#"))
}
集合方法
def main(args: Array[String]): Unit = {
//去重 *****
val list = List[Int](10,10,20,30,2,1,1,50)
val list2 = list.distinct
println(list2)
//删除前多少个元素，保留剩余的元素
val list3 = list.drop(2)
println(list3)
//删除后多少个元素，保留剩余元素
val list4 = list.dropRight(3)
println(list4)
//获取第一个元素 ****
val head = list.head
println(head)
//获取最后一个元素 *****
val last = list.last
println(last)
//获取除开最后一个元素的所有元素
val list5 = list.init
println(list5)
println("*"*100)
//除开第一个元素的所有元素
val list11 = list.tail
println(list11)
//反转
val list7 = list.reverse
println(list7)
//获取子集合
val list8 = list.slice(2,5)
println(list8)
//窗口 ******
//size: 窗口的大小
//step: 窗口滑动的长度
val list9 = list.sliding(3,2)
println(list9.toBuffer)
//获取前多少个元素 *****
val list12 = list.take(3)
println(list12)
//获取后多少个元素
val list13 = list.takeRight(3)
println(list13)
//val list = List[Int](10,10,20,30,2,1,1,50)
val list14 = List[Int](10,1,4,5,20)
//交集[两个集合共同的元素]
val list15 = list.intersect(list14)
println(list15)
//差集[ 除开交集之外的元素 A 差 B => 结果是A中除开交集之外的所有元素 ]
val list16 = list.diff(list14)
println(list16)
//并集【两个集合的所有元素,不去重】
val list17 = list.union(list14)
println(list17)
//拉链
val list18 = List[String]("aa","bb","cc","dd")
val list19 = List[Int](1,2,3)
val list20 = list18.zip(list19)
println(list20)
//反拉链
val list21 = list20.unzip
println(list21)
}
集合初级方法
def main(args: Array[String]): Unit = {
val list = List[Int](2,7,1,9,10,5,3)
//最大值
val max = list.max
//最小值
val min = list.min
println(max)
println(min)
//根据什么获取最大值
val list2 = List[String]("zhangsan 20 3000","lisi 15 5000","wangwu 30 1000")
//maxBy中的函数是针对集合的每个元素
val maxBy = list2.maxBy(x=>x.split(" ")(1).toInt)
println(maxBy)
//根据什么获取最小值
val list3 = List[(String,Int)]( ("ZHANGSAN",1000),("LISI",2500),("WANGWU",3000),("WANGWU",2500) )
//minBy中的函数是针对集合的每个元素
println(list3.minBy(_._2))
//求和
println(list.sum)
//List[String]("spark","hello").sum
//排序
//直接按照元素本身排序[升序]
val list4 = list.sorted
println(list4)
//降序
val list5 = list4.reverse
println(list5)
println(list3.sorted)
//指定按照哪个字段排序[升序] *****
println(list3.sortBy(_._2))
//根据指定的规则排序
println(list.sortWith((x, y) => x < y))
println(list.sortWith((x, y) => y < x))
}
集合高级方法
def main(args: Array[String]): Unit = {
val list = List[String]("spark","hello","java","python")
//map(func: 集合元素类型 => B ): 主要用来转换数据[转换值、转换类型]
// map中的函数是针对集合的每个元素进行操作
// map的应用场景: 一对一 【val B = A.map(..) B集合的元素的个数=A集合元素个数】
val list2 = list.map(x=>x.length)
println(list2)
val list3 = List[Int](10,20,30,40)
val list4 = list3.map(x=>x*x)
println(list4)
//foreach(func: 集合元素类型 => U ):Unit
// foreach中的函数也是针对集合的每个元素
// foreach与map的区别: map有返回值，foreach没有返回值
val list5 = List[(String,Int,String)]( ("lisi",20,"深圳"),("zhangsan",15,"北京") )
list5.foreach(println(_))
val func = (x:(String,Int,String)) => println(x)
list5.foreach(println)
//flatten-压平
//flatten只能用于集合中嵌套集合的场景
//flatten的应用场景: 一对多
val list6 = List[List[String]](
List[String]("aa","bb"),
List[String]("cc","dd"),
List[String]("ee","ff")
)
val list7 = list6.flatten
println(list7)
val list8 = List[List[List[String]]](
List(List[String]("aa","bb"),List[String]("cc","dd")),
List(List[String]("ee","ff"),List[String]("oo","xx"))
)
val list9 = list8.flatten
println(list9)
val list10 = List[String]("spark","hello")
println(list10.flatten)
//flatMap(func: 集合元素类型=> 集合 ) = map+flatten
// flatMap中的函数也是针对集合中的每个元素
// flatMap应用场景: 一对多
val list11 = List[String]("hadoop spark","hello java python")
val list12 = list11.map(x=>x.split(" "))
val list13 = list12.flatten
println(list13)
println(list11.flatMap(_.split(" ")))
//List(hadoop,spark,hello.java,python)
//filter( func: 集合元素类型 => Boolean ) - 过滤
// filter中的函数针对集合的每个元素,filter保留的是函数返回值为true的数据
val list14 = List[Int](10,2,4,5,7,9)
println(list14.filter(_ % 2 == 0))
//groupBy(func: 集合元素类型=> K ) --分组
//groupBy是根据指定的字段进行分组，里面的函数针对是集合每个元素
//groupBy的结果是Map[分组的key,List[原有集合元素类型]]
val list15 = List[(String,String)](
("ZHANGSAN","SHENZHEN"),
("LISI","BEIJING"),
("WANGWU","SHENZHEN"),
("ZHAOLIU","SHENZHEN")
)
//list15.groupBy(x=> x._2)
val list16 = list15.groupBy(_._2)
println(list16)
//reduce(func: (集合元素类型,集合元素类型) => 集合元素类型 ) --聚合
//reduce中的函数是两两聚合，然后将上一次的聚合结果与下一个元素再次聚合
//reduce最终结果是单个数据，数据的类型就是原有集合的元素类型
val list17 = List[Int](10,2,4,5,7,9)
val result = list17.reduce( (agg,curr)=>{
println(s"agg=${agg} curr=${curr}")
agg * curr
})
//reduce的执行过程：
// agg上一次的聚合结果 curr:本次要聚合元素
// 第一次执行的时候，agg的值就是集合第一个元素[10], curr集合第二个元素[2] (agg,curr)=> agg * curr = 20
// 第二次执行的时候，agg上一次的聚合结果[20], curr集合第三个元素[4] (agg,curr)=> agg * curr = 80
// ......
println(result)
//reduceRight(func: (集合元素类型,集合元素类型) => 集合元素类型 )
//reduceRight中的函数是两两聚合，然后将上一次的聚合结果与下一个元素再次聚合
//reduceRight最终结果是单个数据，数据的类型就是原有集合的元素类型
println("*"*100)
val result2 = list17.reduceRight((curr,agg)=>{
println(s"agg=${agg} curr=${curr}")
agg-curr
})
//reduceRight的执行过程：
// agg上一次的聚合结果 curr:本次要聚合元素
// 第一次执行的时候，agg的值就是集合第最后一个元素[9], curr集合倒数第二个元素[7] (agg,curr)=> agg - curr = 2
// 第二次执行的时候，agg上一次的聚合结果[2], curr集合倒数第三个元素[5] (agg,curr)=> agg * curr = -1
// ......
println(result2)
println("+"*100)
//fold(agg第一次执行的初始值)(func: (集合元素类型，集合元素类型)=>集合元素类型)
//fold与reduce唯一的不同就是多了agg的初始值
list17.fold(100)( (agg,curr)=>{
println(s"agg=${agg} curr=${curr}")
agg-curr
})
println("-"*100)
//foldRight(agg第一次执行的初始值)(func: (集合元素类型，集合元素类型)=>集合元素类型)
list17.foldRight(200)( (curr,agg)=>{
println(s"agg=${agg} curr=${curr}")
agg - curr
})
}
案例一word count
object $14_WordCount {
def main(args: Array[String]): Unit = {
val datas = List("Hello Scala Hbase kafka", "Hello Scala Hbase", "Hello Scala", "Hello")
//1、切割句子获取单词，压平
//datas.flatMap(x=>x.split(" "))
val words = datas.flatMap(_.split(" "))
//List(Hello,Scala,Hbase,kafka,Hello,Scala,Hbase,Hello,Scala,Hello)
//2、按照单词进行分组
val grouped = words.groupBy(x=>x)
/**
* Map[
* Hello -> List[Hello,Hello,Hello,Hello],
* Scala-> List[Scala,Scala,Scala],
* Hbase-> List[Hbase,Hbase],
* kafka->List[kafka]
* ]
*/
//3、统计单词的个数
val result = grouped.map(x=>{
//x = Hello -> List[Hello,Hello,Hello,Hello]
val num = x._2.length
(x._1,num)
})
//4、结果展示
result.foreach(println)
//最终结果: [(Hello,4),(Scala,3),(Hbase,2),(Kafka,1)]
// datas.flatMap(_.split(" ")).groupBy(x=>x).map(x=>(x._1,x._2.size)).foreach(println)
}
}
案例二word count
object $15_WordCountHight {
def main(args: Array[String]): Unit = {
val datas = List(("Hello Scala Spark World", 4), ("Hello Scala Spark", 3), ("Hello Scala", 2), ("Hello", 1))
//1、切割句子获得单词，赋予初始次数，压平
val words = datas.flatMap(x=>{
//x = ("Hello Scala Spark World", 4)
val arr = x._1.split(" ")
//Array(Hello,Scala,Spark,World)
val result = arr.map(y=>(y,x._2))
//Array( (Hello,4),(Scala,4),(Spark,4),(World,4) )
result
})
//List( (Hello,4),(Scala,4),(Spark,4),(World,4),(Hello,3),(Scala,3),(Spark,3),(Hello,2),(Scala,2),(Hello,1) )
//2、按照单词分组
val grouped = words.groupBy(_._1)
/**
* Map[
* Hello -> List( (Hello,4),(Hello,3),(Hello,2),(Hello,1) ),
* Scala -> List( (Scala,4),(Scala,3),(Scala,2)),
* Spark-> List( (Spark,4),(Spark,3)),
* World -> List( (World,4))
* ]
*/
//3、统计单词的总个数
val result = grouped.map(x=>{
//x = Hello -> List( (Hello,4),(Hello,3),(Hello,2),(Hello,1) )
//val num = x._2.map(_._2).sum
// (x._1,num)
val result = x._2.reduce((agg,curr)=>(agg._1,agg._2+curr._2 ))
result
})
//List[Hello->10,Scala->9,Spark->7,World->4]
//4、结果展示
result.foreach(println)
}
}
案例三
object $16_Home {
/**
* 1、求出哪些省份没有农产品市场
* 2、获取菜的种类最多的三个省份
* 3、获取每个省份菜的种类最多的三个农贸市场
*/
def main(args: Array[String]): Unit = {
val products = Source.fromFile("datas/product.txt","utf-8").getLines().toList
val allprovince = Source.fromFile("datas/allprovince.txt").getLines().toList
//m1(allprovince,products)
//m2(products)
m3(products)
}
/**
* 获取每个省份菜的种类最多的三个农贸市场
*/
def m3(products:List[String]) = {
//1、过滤非法数据
products.filter(_.split("\t").size==6)
//2、列裁剪- 选择 菜名、省份、农产品市场
.map(line=>{
val arr = line.split("\t")
(arr(4),arr(3),arr(0))
})
//3、去重
.distinct
//4、按照省份、农产品市场分组
.groupBy(x=> (x._1,x._2) )
/**
* Map(
* (湖南省,长沙市马王堆批发市场) -> List( (湖南省,长沙市马王堆批发市场,大白菜),(湖南省,长沙市马王堆批发市场,青椒),... )
* (湖南省,长沙市aa) -> List( (湖南省,长沙市aa,大白菜),(湖南省,长沙市aa,青椒),... )
* ....
* )
*/
//5、统计每个省份、每个农产品市场的菜的种类数
.map(x=>{
//x = (湖南省,长沙市马王堆批发市场) -> List( (湖南省,长沙市马王堆批发市场,大白菜),(湖南省,长沙市马王堆批发市场,青椒),... )
(x._1._1,x._1._2,x._2.size)
})
/**
* List(
* (湖南省,长沙市马王堆批发市场,10)
* (湖南省,长沙市aa,20)
* (湖北省,武汉市bb,30)
* ....
* )
*/
//6、按照省份分组
.groupBy(_._1)
/**
* Map(
* 湖南省 -> List( (湖南省,长沙市马王堆批发市场,10),(湖南省,长沙市aa,20),..)
* 湖北省 -> List( (湖北省,武汉市bb,30),... )
* ....
* )
*/
//7、对每个省份农产品种类数进行排序，取前三
.map(x=>{
//x = 湖南省 -> List( (湖南省,长沙市马王堆批发市场,10),(湖南省,长沙市aa,20),..)
(x._1,x._2.toList.sortBy(_._3).reverse.take(3))
})
//8、结果展示
.foreach(println)
}
/**
* 获取菜的种类最多的三个省份
*/
def m2(products:List[String]) = {
//1、过滤非法数据
products.filter(_.split("\t").length==6)
//2、列裁剪-选择菜名-省份
.map(line=>{
val arr = line.split("\t")
(arr(4),arr(0))
})
//List( ( 湖南省,大白菜),( 湖南省,大白菜),( 湖南省,青椒)，...)
//3、去重【每个省份有多个农产品市场可能有多个同名的菜】
.distinct
//List( ( 湖南省,大白菜),( 湖南省,青椒)，...)
//4、按照省份分组
.groupBy(_._1)
/**
* Map[
* 湖南省 -> List( ( 湖南省,大白菜),( 湖南省,青椒),...)
* 湖北省 -> List( ( 湖北省,大白菜),( 湖北省,青椒),...)
* ]
*/
//5、统计每个省份的菜的种类数量
.map(x=>{
//x = 湖南省 -> List( ( 湖南省,大白菜),( 湖南省,青椒),...)
(x._1,x._2.size)
})
//List( 湖南省->10,湖北省->5,..)
//6、排序
.toList
.sortBy(_._2)
//List(湖北省->5,湖南省->10,广东省->20,..)
//7、取前三
.reverse
.take(3)
//8、结果展示
.foreach(println)
}
/**
* 1、求出哪些省份没有农产品市场
*/
def m1(allprovince:List[String],products:List[String]) ={
//三要素: 过滤、去重、列裁剪
//1、过滤
val filterProduct = products.filter(line=>line.split("\t").length==6)
//2、获取农产品市场数据的省份
val productProvinces = filterProduct.map(line=> {
line.split("\t")(4)
})
//3、去重
val distincProvince = productProvinces.distinct
//4、将农产品数据省份与全国所有省份对比，得到哪些省份没有农产品市场【求差集】
val result = allprovince.diff(distincProvince)
//5、结果展示
result.foreach(println)
}
}
不可变队列
/**
* 队列的特点: 先进先出
* 创建方式: Queue[集合元素类型](初始元素,...)
* @param args
*/
def main(args: Array[String]): Unit = {
val queue = Queue[Int](10,2,4,1,6)
println(queue)
//添加元素
val queue2 = queue.+:(100)
val queue3 = queue.:+(200)
println(queue2)
println(queue3)
val queue4 = queue.++(List(9,8,7))
val queue5 = queue.++:(List(5,6,7))
println(queue4)
println(queue5)
val queue6 = queue.enqueue(1000)
println(queue6)
//删除元素
val dequeue: (Int, Queue[Int]) = queue.dequeue
println(dequeue)
val option = queue.dequeueOption
println(option)
//修改
val queue7 = queue.updated(1,20)
println(queue7)
}
可变队列
object $18_MutableQueue {
def main(args: Array[String]): Unit = {
//创建方式
val queue = mutable.Queue[Int](10,20,3,5,1)
println(queue)
//添加元素
val queue2 = queue.+:(30)
val queue3 = queue.:+(40)
queue.+=(50)
queue.+=:(60)
println(queue2)
println(queue3)
println(queue)
val queue4 = queue.++(List(1,2,3))
val queue5 = queue.++:(List(4,5,6))
println(queue4)
println(queue5)
queue.++=(List(7,8,9))
println(queue)
queue.enqueue(10,20,30,40)
println(queue)
//删除元素
println(queue.dequeue())
println(queue)
//修改
queue.update(0,20)
println(queue)
}
}
开启多线程
object $19_ParCollection {
def main(args: Array[String]): Unit = {
val list = List[Int](14,1,6,9,10,20,7,8)
list.foreach(x=>println(Thread.currentThread().getName))
println("8"*100)
list.par.foreach(x=>println(Thread.currentThread().getName)）
}
}
模式匹配
object $01_MatchDefind {
/**
* 语法: 变量 match {
*
* case 值1 => {
* .....
* }
* case 值2 => {
* ...
* }
* .....
* }
*
* 模式匹配可以有返回值，返回值是符合条件的分支的{}的最后一个表达式的结果值
*
*/
def main(args: Array[String]): Unit = {
val word = StdIn.readLine("请输入一个单词:")
val result = word match {
case "hadoop" =>
println("输入的单词是hadoop")
10
case "spark" =>
println("输入的单词是spark")
20
case "flume" =>
println("输入的单词是flume")
30
//相当于switch的default
/* case x => {
println(s"其他单词${x}")
}*/
//如果变量不需要在=>右边使用可以用_代替
case _ => {
println(s"其他单词")
-1
}
}
println(result)
}
}
守卫
object $02_MatchIf {
/**
* 守卫语法:
* 变量 match {
* case 值 if(布尔表达式) => ...
* case 值 if(布尔表达式) => ...
* }
*/
def main(args: Array[String]): Unit = {
val line = StdIn.readLine("请输入一句话:")
line match {
case x if(x.contains("hadoop")) => println(s"输入的句子中包含hadoop")
case x if(x.contains("spark")) => println(s"输入的句子中包含spark")
case x if(x.contains("flume")) => println(s"输入的句子中包含flume")
case x => println("其他句子")
}
}
}
匹配值
object $03_MatchValue {
def main(args: Array[String]): Unit = {
val arr = Array("spark",1,2.0,false,30)
val index = Random.nextInt(arr.length)
val value:Any = arr(index)
println(value)
value match {
case 1 => println("........1")
case 2.0 => println("........2.0")
case "spark" => println("........spark")
case false => println("..........false")
case _ => println("其他")
}
}
}
匹配类型
/**
* 匹配语法: 变量 match{
* case 变量名:类型 => ...
* case 变量名:类型 => ..
* case _:类型 => .. //如果变量名不需要在=>右边使用可以用_代替
* ...
* }
*/
def main(args: Array[String]): Unit = {
val list:List[Any] = List(1,2.0,false,10,"spark")
val index = Random.nextInt(list.length)
val value = list(index)
println(value)
val result = value match {
case _:String => "输入的是字符串"
case x:Int => s"输入的是整数${x}"
case _:Double => "输入的是浮点型"
case _:Boolean => "输入的是布尔"
case _ => "其他"
}
println(result)
}
匹配数组
object $05_MatchArray {
def main(args: Array[String]): Unit = {
//val arr:Array[Any] = Array(4,1,10,2,7)
val arr:Array[Any] = Array("spark",1,2.0)
arr match {
//匹配数组只有一个元素
case Array(x) => println(s"数组只有一个元素${x}")
//匹配数组只有三个元素,匹配元素的类型
case Array(x:String,y:Int,z:Double) => println("匹配数组有三个元素，并且元素类型分别为String,Int,Double")
//匹配数组有三个元素
case Array(x,y,z) => println(s"数组有三个元素${x},${y},${z}")
//匹配数组至少有一个元素
case Array(_,_*) => println("数组至少有一个元素")
}
// int[] arr = new int[] {}
// object[] arr = new object[] {}
// String[] arr = new String[] {}
arr match {
//case x:Array[Int] => println("arr是Int数组")
case x:Array[Any] => println("arr是Any数组")
//case x:Array[String] => println("arr是String数组")
}
}
}
list匹配
object $06_MatchList {
def main(args: Array[String]): Unit = {
val list = List[Int](1,2,7,9,10)
//val list = List[Any]("spark",1,2.0)
//第一种匹配方式
list match {
//匹配List只有一个元素
case List(x) => println("List只有一个元素")
//匹配List有三个元素,以及匹配元素的类型
//case List(x:String,y:Int,z:Double) => println("list中有三个元素，并且元素类型为string,int,double")
//匹配List有三个元素
case List(x,_,z) => println("List有三个元素")
//匹配List至少有一个元素
case List(x,_*) => println("List至少有一个元素")
}
println("*"*100)
list match {
//匹配List只有一个元素
case x :: Nil => println("List只有一个元素")
//匹配List有三个元素,以及匹配元素的类型
//case (x:String) :: (y:Int) :: (z:Double) :: Nil => println("list中有三个元素，并且元素类型为string,int,double")
//匹配List有三个元素
case x :: _ :: z :: Nil => println("List有三个元素")
//匹配List至少有一个元素
case x :: y :: aaa => println(s"List至少有一个元素,${x} ${aaa}")
}
println("*"*100)
//泛型的特点: 泛型擦除，泛型只是编译器使用，用来规定集合里面的数据类型是啥，真正在编译的时候jvm虚拟机会将泛型擦掉
list match {
case x:List[String] => println("string list")
case x:List[Any] => println("any list")
case x:List[Int] => println("int list")
case _ => println("其他list")
}
}
}
匹配元组
object $07_MatchTuple {
def main(args: Array[String]): Unit = {
val t1 = ("zhangsan",20,"shenzhen")
//元组在匹配的时候,元组的元素的个数必须与匹配条件的元组的元素个数一致
val name = "zhangsan"
t1 match{
case (x:String,y:Int,z:String) => println(".........")
case (x,y,z) => println(s"${x} ${y} ")
// case (x,y) => println(s"${x} ${y} ${z}")
}
val schools = List[(String,(String,(String,Int)))](
("宝安中学",("大数据1班",("zhangsan",20))),
("宝安中学",("大数据1班",("lisi",20))),
("宝安中学",("大数据1班",("wangwu",20))),
("宝安中学",("大数据1班",("zhaoliu",20)))
)
//schools.map(x=> x._2._2._1 ).foreach(println)
schools.map(x=> {
x match {
case (schoolName,(className,(stuName,age))) => stuName
}
} ).foreach(println)
}
}
匹配样例类
object $08_MatchCaseClass {
//样例类
case class Person(name:String,var age:Int)
/* class Student(val name:String ,var age:Int)
object Student{
def apply(name:String,age:Int) = new Person(name,age)
}*/
case class School(name:String,clazz:Clazz)
case class Clazz(name:String,stu:Student)
case class Student(name:String,age:Int)
abstract class Sex
case object Man extends Sex
case object Woman extends Sex
def xx(sex:Sex): Unit ={
}
class Animal(val name:String,val age:Int)
object Animal{
def unapply(arg: Animal): Option[(String, Int)] = {
if(arg==null){
None
}else{
Some((arg.name,arg.age))
}
}
}
/**
* 样例类: case class 类名(val/var 属性名:属性类型,....)
* val修饰的属性不可变
* var修饰的属性可变
* val/var可以省略不写，如果省略默认就是val修饰的
* 样例创建对象: 类名(属性值,..)
*
* 样例对象: case object object名称
*样例对象一般作为枚举使用。
* @param args
*/
def main(args: Array[String]): Unit = {
//对象创建
val person = Person("zhangsan",20)
println(person)
println(person.name)
println(person.age)
//val student = Student("lisi",30)
//println(student.name)
val schools = List[School](
School("宝安中学",Clazz("大数据1班",Student("zhangsan",20))),
School("宝安中学",Clazz("大数据1班",Student("lisi",20))),
School("宝安中学",Clazz("大数据1班",Student("wangwu",20))),
School("宝安中学",Clazz("大数据1班",Student("zhaoliu",20)))
)
schools.map(x=>x.clazz.stu.name).foreach(println)
xx(Man)
person match {
case Person(x,y) => println(s"${x} ${y}")
}
val wangcai = new Animal("wangcai",5)
wangcai match {
case Animal(x,y) => println(s"${x} ${y}")
}
}
}
匹配参数
object $09_MatchParamDefind {
def main(args: Array[String]): Unit = {
val t1 = ("zhangsan",20,"shenzhen")
println(t1._1)
val (name,age,address) = ("zhangsan",20,"shenzhen")
println(name)
val x :: Nil = List(10)
println(x)
val Array(a,y,z) = Array(10,20,30)
println(a,y,z)
val name1:String = "zhangsan"
println(name)
val list = List[(String,Int)](("zhangsan",20),("lisi",30))
for((name,age)<- list){
println(name)
}
}
}
偏函数
/**
* 偏函数: 没有match关键字的模式匹配称之为偏函数
* 语法: val 函数名:PartialFunction[IN,OUT] = {
* case 条件1 =>...
* case 条件2 => ..
* ...
* }
* IN: 代表函数的参数类型
* OUT: 函数的返回值类型
* @param args
*/
def main(args: Array[String]): Unit = {
val func:PartialFunction[String,Int] = {
case "hadoop" =>
println("hadoop......")
10
case "spark" =>
println("spark..........")
20
case _ =>
println("其他.......")
-1
}
println(func("hadoop"))
val schools = List[(String,(String,(String,Int)))](
("宝安中学",("大数据1班",("zhangsan",20))),
("宝安中学",("大数据1班",("lisi",20))),
("宝安中学",("大数据1班",("wangwu",20))),
("宝安中学",("大数据1班",("zhaoliu",20)))
)
//schools.map(_._2._2._1).foreach(println(_))
/*schools.map(x=>{
x match {
case (schoolName,(className,(stuName,age))) =>stuName
}
}).foreach(println(_))*/
val getStuName:PartialFunction[(String,(String,(String,Int))),String] = {
case (schoolName,(className,(stuName,age))) => stuName
}
//schools.map(getStuName).foreach(println(_))
//偏函数使用的正确姿势
schools.map{
case (schoolName,(className,(stuName,age))) => stuName
}.foreach(println(_))
}
异常
object $01_Exception {
/**
* java中关于的异常的处理:
* 1、捕获异常: try{} catch{} finally{}
* try{
* ...
* }catch(Exception e){
* ..
* }finally{ --用于释放资源
* ..
* }
* 2、抛出异常: throw new ..Exception [必须在方法上throws Exception]
* scala中关于异常处理:
* 1、捕获异常:
* 1、try{} catch{} finally{} 【一般用于获取外部资源的时候使用】
* 2、Try(代码).getOrElse(代码执行失败返回的默认值)
* Success: 代表Try中包裹的代码执行成功,后续可以通过get方法取出代码的执行结果
* Filture: 代表Try中包裹的代码执行失败
* 2、抛出异常: throw new ..Exception [scala抛出异常不需要在方法后面通过throws Exception声明]
* @param args
*/
def main(args: Array[String]): Unit = {
//println(m1(10, 0))
println(m2(10,0))
val list = List[String](
"1 zhangsan 20 shenzhen",
"2 lisi beijing",
"3 lisi tianjin",
"4 zhaoliu 55 shenzhen"
)
//需求: 求年龄总和
list.map(line=>{
val age = Try(line.split(" ")(2).toInt).getOrElse(-1)
age
}).filter(_!= -1).foreach(println(_))
}
def m1(x:Int,y:Int) = {
if(y==0) throw new Exception("y=0")
x/y
}
def m2(x:Int,y:Int) = {
try{
x/y
}catch {
case e:Exception => println("y=0")
}
}
def jdbc() = {
var connection:Connection = null
var statement:PreparedStatement = null
try{
//1、获取连接
connection = DriverManager.getConnection("jdbc:mysql://hadoop102:3306/test")
//2、创建statement对象
statement = connection.prepareStatement("insert into person values(?,?,?)")
//3、封装参数
statement.setString(1,"zhangsan")
statement.setString(3,"shenzhen")
statement.setInt(2,20)
//4、执行
statement.executeUpdate()
}catch {
case e:Exception=>
}finally {
//5、关闭
if(statement!=null)
statement.close()
if(connection!=null)
connection.close()
}
}
}
either
object $02_Either {
def main(args: Array[String]): Unit = {
val either = m1(10,0)
either match {
case Left(result) =>
println(s"失败.....${result}")
case Right(result) =>
println(s"成功......${result}")
}
}
def m1(x:Int,y:Int) = {
try{
Right(x/y)
}catch {
case e:Exception => Left((y,e))
}
}
}
案例
object $03_Home {
def main(args: Array[String]): Unit = {
val datas = Source.fromFile("datas/aa","utf-8").getLines().toList
//1、切割（司机、区域、时间[转成时间戳]）
datas.map(line=>{
//line="A 龙华区 宝安区 2020-07-15 10:05:10 2020-07-15 10:25:02"
val arr = line.split("\t")
val id = arr.head
val fromAddr = arr(1)
val toAddr = arr(2)
val fromTime = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(arr(3)).getTime
//LocalDateTime.parse(fromTime,DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"))
val toTime = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(arr(4)).getTime
(id,fromAddr,toAddr,fromTime,toTime)
})
//2、按照司机分组
.groupBy(_._1)
/**
* Map(
* A-> List(
* （A,龙华区,宝安区,2020-07-15 10:05:10,2020-07-15 10:25:02）,
* （A,龙岗区,宝安区,2020-07-15 11:55:55,2020-07-15 12:12:23）,
* （A,龙岗区,龙华区,2020-07-15 11:02:08,2020-07-15 11:17:15）,
* （A,宝安区,龙岗区,2020-07-15 10:35:15,2020-07-15 10:40:50）,
* （A,龙华区,龙岗区,2020-07-15 11:33:12,2020-07-15 11:45:35）,
* （A,宝安区,龙岗区,2020-07-15 12:17:10,2020-07-15 12:33:21）
* )
* B-> List(
* (B,宝安区,福田区,2020-07-15 11:43:22 2020-07-15 11:55:45),
* (B,福田区,宝安区,2020-07-15 12:05:05 2020-07-15 12:22:33),
* (B,龙华区,龙岗区,2020-07-15 10:45:25 2020-07-15 10:50:00),
* (B,宝安区,龙岗区,2020-07-15 12:27:20 2020-07-15 12:43:31),
* (B,福田区,龙华区,2020-07-15 10:15:21 2020-07-15 10:35:12),
* (B,龙岗区,宝安区,2020-07-15 11:12:18 2020-07-15 11:27:25)
* )
* )
*/
.toList
//3、对每个司机的数据按照上车/下车时间排序
.flatMap(x=>{
//x= A-> List(
// （A,龙华区,宝安区,2020-07-15 10:05:10,2020-07-15 10:25:02）,
// （A,龙岗区,宝安区,2020-07-15 11:55:55,2020-07-15 12:12:23）,
// （A,龙岗区,龙华区,2020-07-15 11:02:08,2020-07-15 11:17:15）,
// （A,宝安区,龙岗区,2020-07-15 10:35:15,2020-07-15 10:40:50）,
// （A,龙华区,龙岗区,2020-07-15 11:33:12,2020-07-15 11:45:35）,
// （A,宝安区,龙岗区,2020-07-15 12:17:10,2020-07-15 12:33:21）
// )
val list = x._2.sortBy(_._4)
// List(
// （A,龙华区,宝安区,2020-07-15 10:05:10,2020-07-15 10:25:02）,
// （A,宝安区,龙岗区,2020-07-15 10:35:15,2020-07-15 10:40:50）,
// （A,龙岗区,龙华区,2020-07-15 11:02:08,2020-07-15 11:17:15）,
// （A,龙华区,龙岗区,2020-07-15 11:33:12,2020-07-15 11:45:35）,
// （A,龙岗区,宝安区,2020-07-15 11:55:55,2020-07-15 12:12:23）,
// （A,宝安区,龙岗区,2020-07-15 12:17:10,2020-07-15 12:33:21）
//)
val slidingList = list.sliding(2)
/**
* List(
* List(（A,龙华区,宝安区,2020-07-15 10:05:10,2020-07-15 10:25:02）,（A,宝安区,龙岗区,2020-07-15 10:35:15,2020-07-15 10:40:50）),
* List(（A,宝安区,龙岗区,2020-07-15 10:35:15,2020-07-15 10:40:50）,（A,龙岗区,龙华区,2020-07-15 11:02:08,2020-07-15 11:17:15）),
* List(（A,龙岗区,龙华区,2020-07-15 11:02:08,2020-07-15 11:17:15）,（A,龙华区,龙岗区,2020-07-15 11:33:12,2020-07-15 11:45:35）),
* List(（A,龙华区,龙岗区,2020-07-15 11:33:12,2020-07-15 11:45:35）,（A,龙岗区,宝安区,2020-07-15 11:55:55,2020-07-15 12:12:23）),
* List(（A,龙岗区,宝安区,2020-07-15 11:55:55,2020-07-15 12:12:23），（A,宝安区,龙岗区,2020-07-15 12:17:10,2020-07-15 12:33:21）),
*
* )
*/
//4、计算每个司机每次的等客时间
val result = slidingList.map(y=>{
//y = List(（A,龙华区,宝安区,2020-07-15 10:05:10,2020-07-15 10:25:02）,（A,宝安区,龙岗区,2020-07-15 10:35:15,2020-07-15 10:40:50）),
//等客区域
val region = y.head._3
//等客时间 = 下一次的上车时间 - 上一次下车时间
val duration = y.last._4 - y.head._5
(region,duration)
})
result
})
//List( (宝安区,10),(龙岗区,22),(龙华区,16),(龙岗区,10),(宝安区,5) ,(龙华区,10),(龙岗区,22),(宝安区,16),(福田区,10),(宝安区,5))
//6、按照区域分组
.groupBy(_._1)
/**
* Map(
* 宝安区-> List((宝安区,10),(宝安区,5),(宝安区,16),(宝安区,5))
* ....
* )
*/
//7、计算平均等客时间
.map(x=>{
//x = 宝安区-> List((宝安区,10),(宝安区,5),(宝安区,16),(宝安区,5))
val time = x._2.map(_._2).sum
val count = x._2.size
(x._1,time/count/1000)
})
//8、结果展示
.foreach(println(_))
}
}
隐式转换
import java.io.File
import scala.io.{BufferedSource, Source}
object xx{
implicit def fileToSourceBufferd(file:File):BufferedSource = {
Source.fromFile(file,"utf-8")
}
implicit def doubeToInt1(x:Double):Int = x.toInt
implicit def doubeToInt2(x:Double):Int = x.toInt + 10
}
object $01_ImplicitMethod{
/**
* 隐式方法: 悄悄将一个类型转成另一个类型
* 语法: implicit def 方法名(变量名:待转换类型): 目标类型 = {..}
*隐式转换方法使用时机:
* 1、当前类型与目标类型不一致的时候，会自动调用隐式方法
* 2、当对象使用了不属于自身的属性/方法/函数的时候,会自动调用隐式方法
*隐式转换的解析:
* 当需要使用隐式转换的时候，后首先从当前的作用域中查找是否有符合条件的隐式转换
* 如果说隐式转换不在当前作用域，需要进行导入之后再使用:
* 1、如果隐式转换定义在Object中,导入的时候使用: import 包名.object名称.隐式转换方法名
* 2、如果隐式转换定义在class中,导入的时候使用:
* 1、创建对象
* 2、对象名.隐式转换方法名
* @param args
*/
def main(args: Array[String]): Unit = {
// 1、当前类型与目标类型不一致的时候，会自动调用隐式方法
//val abc = new xx
import xx.doubeToInt1
val a:Int = 2.0
println(a)
val file = new File("d:/pmt.json")
//2、当对象使用了不属于自身的属性/方法/函数的时候,会自动调用隐式方法
import xx.fileToSourceBufferd
file.getLines()
}
}
隐式转换参数
object AA{
implicit val y:Int = 10
implicit val a:Int = 100
}
object $02_ImplicitParam {
/**
* 隐式转换参数的语法:
* 1、通过implicit val 变量名:类型 = 值
* 2、def 方法名(..)(implicit 变量名:类型)
* 如果有多个隐式转换参数/方法都符合要求，需要明确通过import 包名.隐式参数名/方法名的方式指定使用哪个隐式转换参数/方法
* @param args
*/
def main(args: Array[String]): Unit = {
import AA.a
println(m1(20))
}
def m1(x:Int)(implicit y:Int) = x+y
隐式转换类
object $03_ImplicitClass {
class Person(val name:String,val age:Int)
implicit class MaxMin(p:Person){
def max(p1:Person) = {
if(p.age<p1.age) p1
else p
}
}
/**
* scala隐式转换类在2.10版本之后才有
* 语法: implicit class 类名(属性名: 待转换的类型) {
* ...
* }
* @param args
*/
def main(args: Array[String]): Unit = {
val person1 = new Person("zhagnsan",20)
val person2 = new Person("lisi",30)
person1.max(person2)
}
//implicit def personToMaxMin(p:Person ):MaxMin = new MaxMin(p)
}
泛型方法
/**
* 泛型主要用于方法与类
* 泛型方法的定义语法: def 方法名[T,U](x:T):U = {..}
*/
def main(args: Array[String]): Unit = {
println(m1[Int](Array[Int](1, 2, 3)))
}
def m1[T](x:Array[T]):Int = {
x.length
}
泛型类
object $02_GenericClass {
class Person[T,U](var name:T,var age:U) {
def setName(name:T) = this.name=name
def getName():T = this.name
}
/**
* 泛型类的定义语法: class 类名[T,U](val/var 属性名:T,..) {
*
* def 方法名(参数名:U):返回值类型 = {..}
* }
* @param args
*/
def main(args: Array[String]): Unit = {
val person = new Person[String,Int]("zhangsan",20)
person.setName("lisi")
println(person.getName())
}
}
泛型上下限
/**
* 上下限:
* 上限【代表传入的泛型必须是指定类型或者是其子类】: T <: 指定类型
* 下限 【代表传入的类型必须是指定类型或者是其父类】 : T >: 指定类型
* @param args
*/
def main(args: Array[String]): Unit = {
//m1(new BigBigDog)
val big:Any = new BigBigDog
m2(1)
}
class Animal
class Dog extends Animal
class BigDog extends Dog
class BigBigDog extends BigDog
def m1[T<:Dog](x:T) = {
println(x)
}
def m2[U>:BigDog](x:U) = {
println(x)
}
泛型 非变、协变、逆变
object $04_GenericChange {
class Parent
class Sub1 extends Parent
class Sub2 extends Sub1
//class AA[T]
//class AA[+T]
class AA[-T]
/**
* 非变: 泛型有父子关系，但是泛型对象没有任何关系 T
* 协变: 泛型有父子关系,泛型对象继承了泛型的父子关系 +T
* 逆变: 泛型有父子关系,泛型对象颠倒了泛型的父子关系 -T
* @param args
*/
def main(args: Array[String]): Unit = {
var list1 = List[B](new B,new B)
var list2 = List[B1](new B1,new B1)
list1 = list2
println(list1)
//非变
//var aa1 = new AA[Parent]
//var aa2 = new AA[Sub1]
//aa1 = aa2
//协变
//var aa1 = new AA[Parent]
//var aa2 = new AA[Sub1]
//aa1 = aa2
//println(aa1)
//逆变
var aa1 = new AA[Parent]
var aa2 = new AA[Sub1]
aa2 = aa1
println(aa2)
}
class B
class B1 extends B
}
泛型上下文
/**
* 泛型上下文语法: def 方法名[T:类型](参数名:T) = {
* val 变量名 = implicitly[类型[T]]
* ....
* }
* @param args
*/
def main(args: Array[String]): Unit = {
implicit val p = new Person[String]
f[String]("zhangsan")
f[String]("lisi")
}
class Person[U]{
var field:U = _
def printHello = println("hello.....")
def setField(field:U) = this.field = field
}
def f[A](a:A)(implicit person:Person[A])= {
person.setField(a)
person.printHello
}
def f1[A:Person](a:A) = {
val person = implicitly[Person[A]]
person.setField(a)
person.printHello
}
案例分析
需求: 统计每个用户一小时内的最大登录次数
user_id,login_time
a,2020-07-11 10:51:12
a,2020-07-11 11:05:00
a,2020-07-11 11:15:20
a,2020-07-11 11:25:05
a,2020-07-11 11:45:00
a,2020-07-11 11:55:36
a,2020-07-11 11:59:56
a,2020-07-11 12:35:12
a,2020-07-11 12:58:59
b,2020-07-11 14:51:12
b,2020-07-11 14:05:00
b,2020-07-11 15:15:20
b,2020-07-11 15:25:05
b,2020-07-11 16:45:00
b,2020-07-11 16:55:36
b,2020-07-11 16:59:56
b,2020-07-11 17:35:12
b,2020-07-11 17:58:59
import java.text.SimpleDateFormat
import scala.io.Source
object $01_Home {
/**
* 需求: 统计每个用户一小时内的最大登录次数
* @param args
*/
def main(args: Array[String]): Unit = {
//1、读取数据
val datas = Source.fromFile("datas/datas.txt","utf-8").getLines().toList
//2、切割数据,转换时间
val mapDatas = datas.map(line=>{
val arr = line.split(",")
val userID = arr.head
val time = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(arr.last).getTime
(userID,time)
})
//3、遍历数据，根据遍历的每条数据筛选哪些数据与该数据处于一个小时
mapDatas.map(x=>{
//x = (a,2020-07-11 10:51:12)
//4、统计每个时间对应的登录次数
val num = mapDatas.filter(y=>y._1 == x._1 && y._2>=x._2 && y._2<=x._2+3600000).size
(x._1,num)
})
//5、按照用户进行分组
.groupBy(_._1)
/**
* Map(
* a-> List( (a,5),(a,6),(a,4),..)
* b-> List( (b,4),..)
* )
*/
//6、统计最大登录次数
.map(x=>{
//x=a-> List( (a,5),(a,6),(a,4),..)
x._2.maxBy(_._2)
})
//7、结果展示
.foreach(println(_))
}
}
案例分析二
val list = List[(String,String,String)](
("1001","2020-09-10 10:21:21","home.html"),
("1001","2020-09-10 10:28:10","good_list.html"),
("1001","2020-09-10 10:35:05","good_detail.html"),
("1001","2020-09-10 10:42:55","cart.html"),
("1001","2020-09-10 11:35:21","home.html"),
("1001","2020-09-10 11:36:10","cart.html"),
("1001","2020-09-10 11:38:12","trade.html"),
("1001","2020-09-10 11:40:00","payment.html"),
("1002","2020-09-10 09:40:00","home.html"),
("1002","2020-09-10 09:41:00","mine.html"),
("1002","2020-09-10 09:42:00","favor.html"),
("1003","2020-09-10 13:10:00","home.html"),
("1003","2020-09-10 13:15:00","search.html")
)
//需求: 分析用户每次会话的行为轨迹
import java.text.SimpleDateFormat
import java.util.UUID
case class UserAnasisy(var sessionid:String,userid:String,time:Long,page:String)
object $02_Home {
def main(args: Array[String]): Unit = {
val list = List[(String,String,String)](
("1001","2020-09-10 10:21:21","home.html"),
("1001","2020-09-10 10:28:10","good_list.html"),
("1001","2020-09-10 10:35:05","good_detail.html"),
("1001","2020-09-10 10:42:55","cart.html"),
("1001","2020-09-10 11:35:21","home.html"),
("1001","2020-09-10 11:36:10","cart.html"),
("1001","2020-09-10 11:38:12","trade.html"),
("1001","2020-09-10 11:40:00","payment.html"),
("1002","2020-09-10 09:40:00","home.html"),
("1002","2020-09-10 09:41:00","mine.html"),
("1002","2020-09-10 09:42:00","favor.html"),
("1003","2020-09-10 13:10:00","home.html"),
("1003","2020-09-10 13:15:00","search.html")
)
// 每条数据都给一个唯一标识，进行数据转换
list.map(x=>{
val sessionid = UUID.randomUUID().toString
val time = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(x._2).getTime
UserAnasisy(sessionid,x._1,time,x._3)
})
//分组
.groupBy(_.userid)
/**
* Map(
* 1001-> List(UserAnasisy("1","1001","2020-09-10 10:21:21","home.html"),UserAnasisy("2","1001","2020-09-10 10:28:10","good_list.html"),UserAnasisy...)
* 1002-> List(...)
* )
*/
//按照时间排序
.flatMap(x=>{
val sortedUser = x._2.sortBy(_.time)
//窗口
val slidingList = sortedUser.sliding(2)
/**
* List(
* List(UserAnasisy("1","1001","2020-09-10 10:21:21","home.html"),UserAnasisy("2","1001","2020-09-10 10:28:10","good_list.html"))
* List(UserAnasisy("2","1001","2020-09-10 10:28:10","good_list.html")，UserAnasisy ("3","1001","2020-09-10 10:35:05","good_detail.html"))
* ...
* )
*/
slidingList.foreach(y=>{
//y = List(UserAnasisy("1","1001","2020-09-10 10:21:21","home.html"),UserAnasisy("2","1001","2020-09-10 10:28:10","good_list.html"))
//判断上一次与下一次是否在30分钟内，如果在30分钟内就是属于同一次会话
if(y.last.time - y.head.time < 30*60*1000) {
y.last.sessionid = y.head.sessionid
}
})
x._2
})
//结果展示
.foreach(println(_))
}
}
案例分析三