scala的使用
1.什么是scala
2.数据类型
1.字符串
2.数值
3.布尔
4.tuple 元组
5.Map键值对
3.scala顶层数据接口
4.语法
1.值 val
2.变量 var
3.打印
4.变量与值的初始化
5.数据类型转换
6.数据类型判断
7.集合
8.方法的调用
9.流程控制
10.方法与函数
11.类
1.属性,方法,构造器
2.伴生类和伴生对象
3.构造器
4.继承
5.抽象类
6.特质
12.高阶函数
1.函数的创建
2.相互转换
3.自定义高阶函数
4.高阶函数
1.什么是scala
1.Scala是一门多范式的编程语言
2.一种类似java的编程语言
3.实现可伸缩的语言
4.并集成面向对象编程和函数式编程的各种特性
2.数据类型
1.字符串:String
2.数值:Int、Long、Float、Double
3.布尔:Boolean
4.tuple 元组
1.创建
val a = (1,2,3,4)
(,)=>最多22个
2.取值a._1
val list = arr.map(x => x.map(t =>(t._1,t._2 + 2)))
5.Map键值对
Map(k->v)
集合,元素一对一对的
1.值不可变
1.创建
val b=Map(“zs” ->12,“ls” ->15)
2.取值
1.b.get(“zs”)
2.b.getOrElse(“zs”,“默认值”)
3.补充Option:要么有要么无
Some =》有
None =》无
2.值可变
1.创建
val m1 = scala.collection.mutable.Map("zs" ->12,"ls" ->15)
2.取值
b.get("zs")
3.改值
b("zs")=10
3.scala顶层数据接口
1.Any => java Object
1.AnyVal 值类型
unit =》void (返回值为空)
2.AnyRef 引用类型
String
3.scala底层数据接口
Nothing
1.Nothing 值
2.Null => Nothing 引用
4.语法
1.值 val
1.val 变量名:数据类型 = 值
val username:String= “hhh”
2.不可重写
username=“mmm” (错误)
2.变量 var
var 变量名:数据类型 = 值
var age:Int= 19
3.打印
1.换行 println
println(username)
2.不换行 print
print(age)
4.变量与值的初始化
1.显示初始化
val num =1
2.占位符:_
1.val name:String=_
2.需要明确是什么数据类型
val age=_ (错误)
5.数据类型转换
1. asInstanceOf[
val age = i.asInstanceOf[Double]
2.toxxx
val b = i.toDouble
6.数据类型判断
isInstanceOf
name.isInstanceOf[String]
7.集合
1.scala集合包
1.可变(长度)
2.不可变(长度)
2.Array
1.定长数组 =》不可变
Array
1.new
创建
val arr=new Array[String](10)
2.非new
创建
val arr2=Array[String]("1","2","3")
3.增添
arr(0)="zs"
4.数组长度
arr.length
5.遍历
1.for(elem <-arr2){
println(elem)
}
2.for(i <- 0 until arr2.length){
println(arr2(i))
3.arr2.foreach(println(_))
4.arr2.indices.map(i =>{
println(arr2(i))
})
6.api
1.元素反转
1.reverse
2.自己编写
for(i <- (arr2.length-1).to(0,-1)){
println(arr2(i))
}
2.数组相加
++ 类似的数据结构拼接
3.常见api
max,min,sum
xxx.max
4.把数据内元素转换成字符串输出
mkString
val res=arr2.mkString("{",",","}")
println(res)
2.变长数组 =》可变
ArrayBuffer
1.创建()
val a = ArrayBuffer[Int]
2.添加
a +=1
3.insert
a.insert(3,4,5,6,7)
从第三个位置插入4,5,6,7
4.remove
a.remove(2,1)
从第二个位置开始删除1个
2.Range
1.快速构建集合
返回值都是range:
1.to [] 左闭右闭 1~10
val r1: Range.Inclusive = 1 to 10
2.until [) 左闭右开 1~9
val r2: Range = 1 until 10
3.List
1.长度不可变:List
1.Nil 是不可变size为0的List
2. :: 追加元素
Nil
val a = 1:: Nil
val b =(1,2,3)::Nil
3.api
head:取出List的第一个元素
tail:取出List非第一个元素以外的所有
package com.bigdaya.scala
object T9 {
def main(args: Array[String]): Unit = {
println(sum(1,2,3,4))
}
def sum(nums:Int*):Int={
if(nums.length==0){
0
}else{
nums.head+sum(nums.tail:_*)
}
}
}
2.长度可变:ListBuffer
1.创建val l1 = ListBuffer[Int]()
2.添加
l1 +=1
l1 +=(2,3,4)
l1 ++=List(5,6,7)
3.Set 去重
无序 不可重复的集合
val a = Set(1,1,2,2,3,3,4,4,4)
2.
seq
set
Map
8.方法的调用
1.xxx.method
2.xxx method
9.流程控制
1.分支结构
1.if else
val score = 80
if(score >= 90){
println("优秀")
}
else if (score >= 60){
println( "良")
}else {
println("不及格")
}
注意:没有三元运算符 xxx?x:y
2.循环
1.for
for (elem <- arr){
println(elem)}
2.while
val iterator = arr.toIterator
while(iterator.hasNext){
val item = iterator.next()
println(item)
3.算子
arr.foreach(println(_))
10.方法与函数
1.def 方法
1.语法结构
def 方法名(参数名:参数类型):返回值类型={方法体}
def sum(x:Int,Y:Int):In t={
x+y
}
注意:scala里面默认方法体的最后一行作为该方法的返回值,不需要写return
2.调用
val xxx:数据类型=值 ,方法返回值类型 可以进行 类型推断
3.方法 入参
1.默认参数
def write(x: String="null") = {
println(x)}
注意:如果有多个参数,默认参数放到最后
2.可变参数
def size(x:Int*) = {
println(x.size)
}
注意:如果有多个参数,默认参数放到最后
val arr = Array(1, 2, 3, 4)
size("可变参数",arr:_*)
def size(t:String,x:Int*) = {
println(t+"==>"+x.size)
}
2.val 函数
函数:本质就是一种特殊的方法
1.语法结构
val f1=(x:Int,y:Int)=>{
x+y
}
2.调用
println(f1(1, 2))
11.类
1.属性,方法,构造器
object T1 {
def main(args: Array[String]): Unit = {
val dl: _root_.com.bigdaya.scala.T1.Dl2262 = new Dl2262
dl.name="zs"
println(dl.age)
dl.listening("ll")
}
class Dl2262{
var name:String=_
val age:Int=20
private val gender="男"
def listening(teacher:String)={
println(name+"is listening of" + teacher )
}
}
}
2.伴生类和伴生对象
1.基本使用
class 名称 是 object的伴生类
object 名称 是 calss的伴生对象
class A ==》普通类
object A =》静态类
2.常用操作
apply()方法
object T3 {
def main(args: Array[String]): Unit = {
val test = ApplyTest
test.apply()
val test1 = new ApplyTest
test1.apply()
}
class ApplyTest{
def apply() = {
println("class apply...")
}
}
object ApplyTest{
def apply(): ApplyTest = {
println("object apply...")
new ApplyTest()
}
}
}
object apply...
class apply...
3.构造器
1.主构造器
class 类名(参数列表)
参数列表 =》参数名:参数类型
object T4 {
def main(args: Array[String]): Unit = {
val p1= new Person("zs",19)
p1.job="zz"
println(p1.age+"\t"+p1.job+"\t"+p1.name)
}
class Person(val name:String,val age:Int){
var job:String=_
}
}
2.附属构造器
1.添加附属构造器
def this(参数列表):
1.每个附属构造器第一行必须调用主构造器或者 其他的附属构造器
object T4 {
def main(args: Array[String]): Unit = {
val p1= new Person("zs",19)
p1.job="zz"
println(p1.age+"\t"+p1.job+"\t"+p1.name)
val ls = new Person("ls", 20, "NBL")
println(ls.age+"\t"+ls.age+"\t"+ls.team)
}
class Person(val name:String,val age:Int){
var job:String=_
var team=""
def this(name:String,age:Int,team:String)={
this(name,age)
this.team=team
}
}
}
4.继承
extend
需要添加父类元素
class B(name:String,val gender:String) extends A(name)
object T5 {
def main(args: Array[String]): Unit = {
val zs = new B("zs","man")
println(zs.gender)
println(zs.age)
zs.f01("1111")
zs.f02("2222")
}
class A(name:String){
val age:Int=10
def f01(parm:String)={
println(parm+"\t"+name)
}
}
class B(name:String,val gender:String) extends A(name){
def f02(parm: String) = {
println(parm + "\t" + name)
}
}
}
5.抽象类
1.定义一个多个方法 没有实现
2.不能new
object T6 {
def main(args: Array[String]): Unit = {
val p: Person = new p1
p.dosomeing
}
abstract class Person{
def dosomeing
val name:String
}
class p1 extends Person{
override def dosomeing={
println("1111")
}
override val name:String="LS"
}
}
6.特质=> java 接口 =》对一个类的补充+某一类事务的共性
1.定义一个多个方法 可以实现也可以不实现
2.extends A with B with C
object T7 extends TestMethod{
def main(args: Array[String]): Unit = {
rintln(sum(1, 2))
}
override def f1 = {
}
}
trait TestMethod {
val name=""
def sum(x:Int,y:Int)={
x+y
}
def f1
}
12.高阶函数
scala 高阶api 单线程
spark core =》算子 多线程
函数 是特殊的一种方法
方法 是特殊的一种函数
他们之间可以进行相互转换
1.函数的创建
val f1=(x:Int,y:Int)=>{x+y}
val f1:(Int,Int):Int=(x:Int,y:Int)=>{X+Y}
2.他们之间可以进行相互转换
val addFunc2: (Int, Int) => Int = add _
3.自定义高阶函数
当一个方法的参数是函数那么这个方法是高阶函数
def foo(f1: (Int, Int) => Int)={
println(f1(10, 30))
}
foo(addFunc2)
4.高阶函数
1.map 一一映射
val arr = Array(1, 2, 3, 4)
val arr2 = arr.map(_* 2)
2.foreach 遍历/输出
1.打印到控制台
2.mysql
arr.foreach(println(_))
3.filter 过滤
arr.map(x=>x*2).filter(x=>x>4)
4.flatMap = flatten+map
一一映射
flatMap与map的区别
1.flatMap会"打破原来数据结构" => 递归 "压扁操作"
map不会
val ints: Array[Int] = arr.flatMap(x => x.map(x => x * 2))
Array(2,4,6,8,10,12)
5.reduce
归约:按照指定的业务逻辑,两两数据上去
先对元素1 和元素2 做操作 再讲结果 对元素3做操作形成新的结果
arr.reduce((x,y)=>x+y)
x 第一个运输
y 下一个元素
2.补充
reduceLeft
reduceRight
6.groupBy
自定义分组
arr.groupBy(x=>x._1)
以第一个元素分组
7.mapVakyes
一一映射
1.map作用在value上
2.数据为kv数据类型【Map键值对/tuple2】
统计单词次数
val wordGroupBy = arr.groupBy(x => x_1)
wordGroupBy.mapValues(value=>value.map(x=>x._2).sum)
8.sortBy
自定义排序
降序
arr.sortBy(x=> -x)
9.字符串插值
println(s"xxx_${str}")
10.case class 样例类
class 与case class
1.case class 不用new
2.case class默认实现了序列化【重要】
3.case classs equals,toString,hashcode
11.模式匹配
java swith case
scala:
1.匹配内容
xxx match {
case xx =>println
case xxx =>println
case _ =>println
}
2.匹配类型
xxx match {
case xx:Int =>println
case xxx:String =>println
case _ =>println
}
3.匹配集合
xxx match {
case x::y::Nil=>println
case "zs"::Nil =>println
case _ =>println
}
4.匹配case class
xxx match {
case xx =>println
case xxx =>println
case _ =>println
}
12.偏函数
PartialFunction
定一个方法,返回值是偏函数{
方法体:一堆case语句
}
A:表示输入函数类型
B:表示输出函数类型
object T9 {
def main(args: Array[String]): Unit = {
val arr = Array("spark", "hive", "flink")
val item = arr(Random.nextInt((arr.length)))
println(item)
println(teacher(item))
}
def teacher:PartialFunction[String,String]={
case "spark" => "1111"
case "hive" => "222"
case _ => "333"
}
}
13.柯力化 currying
是必然发生的结果
def sum(x:Int,y:Int)
柯力化
def sum(x:Int)(y:Int)
14.io 读写url
拿取后的内容只能操作一次
object T9 {
def main(args: Array[String]): Unit = {
val content: BufferedSource = Source.fromFile("idea/data/wc.data")
val lines= content.getLines()
for (line <- lines){
println(line)
}
}
}
15.隐士转换
A类 =>B类
B对A已有的东西进行增强
1.隐士参数【作用到方法参数上】
2.隐士类型转换【作用到def上】
使man有了suoerman的功能
object T9 {
def main(args: Array[String]): Unit = {
implicit def man2superman(man:Man):SuperMan={
new SuperMan(man.name)
}
val zzx = new SuperMan("zzx")
zzx.fly()
val zs= new Man("zs")
zs.fly()
}
class Man(val name: String)
class SuperMan(name: String) {
def fly() = {
println("${name} can fly ....")
}
}
}
3.隐士类 【作用到class上】【高危】
16.泛型
类型的约束
1. abstract class MSG[S](content:S)
class WeChat(content:String)extends MSG(content)
class QQChat[Int](content:Int)extends MSG(content)
class ZFBChat(content:BigInt)extends MSG[BigInt](content)
2. class GG[A,B,C]( val face:A,val heigh:B,val clother:C){
override def toString: String = face+"\t"+heigh+clother}
3.上界 <T extends Test>
T是Test的子类
4.下界 <T super Test>
T可以是Test的父类
5.逆变 vs 协变
- +
17.枚举
object T10 {
def main(args: Array[String]): Unit = {
val zs = new GG[FaceEnum, Int, Double](FaceEnum.A, 122, 77)
}
class GG[A,B,C]( val face:A,val heigh:B,val clother:C){
override def toString: String = face+"\t"+heigh+clother
}
//枚举的定义
object FaceEnum extends Enumeration{
type FaceEnum=Value
val A,B,C,D=Value
}
}
18.排序
1.Ordering =>Comparator
2.Ordered =>Comparable