Scala基础语法 一

时间:2021-6-7 作者:qvyue

1.类型层次结构

=> 用在函数
-> 用在二元元组

Scala基础语法 一
image.png

2.条件表达式

2.1 表达式
   if ( ){ }else if(){ }.....else{  }
   块表达式 { } 
    #有默认返回值,有值得就是最后一行就是值
    for(i 
2.2 break和continue

break()跳出breakable()的生命周期范围

#break功能的实现
breakable{
    for(i=5) break()
    }
}
#continue功能的实现
for(i

3.方法

#def 定义, Unit 返回值类似void
def methodName (name:String , age:String) Unit= {
}
#简写
def methodName(name:String,age:String)={println(name)}
#变长参数
def methodName(name:String*)={println(name)}
#点调用
a.b
#中缀调用
Math abs -1
#花括号调用 
#方法只有一个参数,才能使用花括号调用法
Math.abs{-1}
#省略括号调用
def printHello()={println("hello")}
printHello

4.函数

#函数可以被传递.可以赋值给变量
#def 定义, Unit 返回值类似void
var func =(name:String , age:String) =>{
name + age}
func("张三","王五")
###1)方法是加载到JVM方法区. 函数在堆中
###2)方法可以转换为一个函数赋值给变量

5.数组

#定长数组
val a =new Array[Int](100)
Array("java","scala","python")

#变长数组
val a = ArrayBuffer[Int]()
val a = ArrayBuffer("hadoop", "storm", "spark")

#常用方法
sum,  max,  min,  sorted , reverse反转

6.元组

val stu=(1,"zhangsan",20,"beijing")
val stu = "zhangsan"->20#或者箭头
#访问 
stu._1  stu._2
#元组不可变不能重新赋值

7.列表

#有先后顺序
####不可变列表
//创建一个不可变列表,存放以下几个元素(1,2,3,4)
val a = List(1,2,3,4)
//使用Nil创建一个不可变的空列表
val a =Nil
//使用::方法创建列表,包含-2、-1两个元素
val a = -2 :: -1 :: Nil

####可变列表
val a = ListBuffer[Int]()
//创建一个可变列表,包含以下元素:1,2,3,4
val a = ListBuffer(1,2,3,4)

#常用方法
a.toList #转换为List
a.toArray#转换为Array

#常用操作
     · 扁平化(flaten)***
· 判断列表是否为空(isEmpty)
· 拼接两个列表(++)
· 获取列表的首个元素(head)和剩余部分(tail)
· 反转列表(reverse)
· 获取前缀(take)、获取后缀(drop)
· 拉链(zip)和拉开(unzip)
· 转换字符串(toString)
· 生成字符串(mkString)
· 并集(union)
· 交集(intersect)
· 差集(diff)

8.集(Set)

#获取集的大小 
a.size
#不可变集合
//定义一个空的不可变集
val a = Set[Int]()
//定义一个不可变集,保存以下元素:1,1,3,2,4,8
val a = Set(1,1,3,2,4,8)
#可变集合
//1.定义一个可变集,包含以下元素: 1,2,3, 4
import scala.collection.mutable.Set
val a = Set(1,2,3,4)
#常用方法
· 添加一个元素,生成一个Set(+)
· 拼接两个集,生成一个Set(++)
· 拼接集和列表,生成一个Set(++)

9.映射(类似HashMap)

#不可变映射
val a = Map("zhangsan"->30,"lisi"->40)
//2.获取zhangsan的年龄
a("zhangsan")
#可变映射
import scala.collection.mutable.Map
val a = Map("zhangsan"->30,"lisi"->40)

#基本操作
· 获取值(map(key))
· 获取所有key(map.keys)
· 获取所有value(map.values)
· 遍历map集合
· getOrElse判断在不在不在返回-1
 a += "wangwu"->35

//2.使用while循环和迭代器,遍历打印该列表
val ite = a.iterator
while(ite.hasNext){println(ite.next)}

//3.使用for 表达式和迭代器,遍历打印该列表
val ite = a.iterator
for(i 

10.函数式编程

#遍历的功能跟for表达式是一样的,都是对集合的每个元素进行迭代
List(1,2,3,4).foreach( println) #遍历(foreach)

val b = a.map(_+1) #映射(map)

val list3 = List("hadoop hive spark flink flume", 
"kudu hbase sqoop storm").flatMap((x)=>{x.split(" ")})#映射扁平化flatmap

val b = a.filter( _%2==0 ) #过滤(filter)

val b = List(3,1,2,9,7).sorted #排序(sorted、sortBy、sortWith)
List("01 hadoop", "02 flume", "03 hive", "04 spark")
.sortBy( x=>{x.split(" ")(1)}) #sortBy按照特性排序,不能降序

List(2,3,1,6,4,5).sortWith( _>_ )#使用sortWith对列表进行降序排序

val i = (1 to 10).toList.reduce(_ + _) #聚合计算(reduce)

val i = (1  to 10).toList.foldLeft(10)(_+_) #折叠(fold)
#定义一个元组列表来保存学生姓名和性别
//"张三", "男"
//"李四", "女"
//"王五", "男"
val a = List(("张三", "男"),("李四", "女"),("王五", "男"))
//2.按照性别进行分组
val b = a.groupBy((x)=>{x._2})

//3.将分组后的Map转换为列表:List(("男" -> 2), ("女" -> 1))
val c = b.map(x=> { x._1->x._2.length }  )
 c.toList

11.类跟对象

 class Person #简写方法
11.1成员变量
 class Person{ var name="" var age=0} #类型推断
 class Person{var name:String=_var age :Int=_}# 万能下划线
11.2.成员方法
 def printHello(msg:String)={println(s"${msg},我叫${name}")}
11.3.修饰符关键字
  • protected,提供给子类访问
  • private,只能在本类中进行访问。子类继承不了。
  • private[this]:修饰的变量,任何对象都不能访问
  • scala没有public关键字,除开protected,private以外,都是公共的。
11.4.主构造器 (除了关键字外都是构造)
 //整个class中除了字段定义和方法定义的代码都是构造代码
 class Person(var name:String="",var age:Int=0){
    //在主构造器中输出"调用主构造器"
    println("调用主构造器")
  }
11.5.辅助构造器
  def this(arr:Array[String]){
      //第一行需要调用主构造器或者其他构造器
      //使用数组参数来初始化成员变量
      this(arr(0),arr(1))
    }

12.单例对象(类似Static)

#定义单例对象和定义类很像,就是把class换成object
#单例对象也就是伴生类
#单例对象只有一个实例, 不能被重复NEW
#单例对象所有属性方法都是静态的
#访问它的属性或方法不用new直接类型.成员
#单例对象成员方法
object PrintUtil{def printSpliter()= println("-"*15)}
#object类

13.定义main方法

object 单例对象名 extends App {
    // 方法体继承App特质,来实现一个入口。同样输出"hello, scala"
}

14.伴生对象

#伴生对象必须要和伴生类一样的名字
#伴生对象和伴生类在同一个scala源文件中
#伴生对象和伴生类可以互相访问private属性
  class Hero{def fight()= println(s"本类")}
  object Hero{private val WEAPON:String="伴生类"}

private[this]#添加访问权限半生类也无法访问

#使用伴生对象 免NEW方式定义类
  class Person(var name:String,var age:Int)
  //定义伴生对象,重写apply方法,使用Person类名就可以创建对象
  object Person{
    def apply(name:String,age:Int)=new Person(name,age)
  }
#apply方法

15.继承

15.1 类继承 跟java一样
子类(class 或 object) extends 父类{ 
}
15.2 单例对象继承 跟java一样
15.3 override和super
- override:重写父类的属性或方法。
- overload:一个类可以有多个同名的方法,但是他们的参数列
表内容不同。方法的重载。
15.4 isInstanceOf/asInstanceOf
 if(stu.isInstanceOf[Student]){  #判断obj是否是类型
      # 将obj1转换成类型A,类似于java的强制转换。
      val stu2: Student = stu.asInstanceOf[Student]
      println(stu2)
    }
15.5 getClass和classOf
obj.getClass  获取obj的精确类型的模板
classOf[obj]  获取已知的泛型A类的模板

16 . 抽象类

16.1 抽象方法
跟java一样
 abstract class Person{
    def sayHello()
  }

17 .匿名内部类

跟java一样
object Demo24Anonymous {
  //1.创建一个Person抽象类,并添加一个sayHello抽象方法
  abstract class Person{
    def sayHello()
  }
  //2.添加main方法,通过创建匿名内部类的方式来实现Person
  def main(args: Array[String]): Unit = {
    val p = new Person {
      override def sayHello(): Unit = println("你好")
    }
    //3.调用匿名内部类对象的sayHello方法
    p.sayHello()
  }
}

18 .特质(trait)类似接口

class 类 extends 特质1 with 特质2 {}

//在方法中混入接口类调用方法
val service = new UserService with Logger

//在类定义上
1. 执行父类A的构造器
2. 从左到右依次执行trait的构造器
3. 如果trait有父trait,先构造父trait,如果多个trait有同样的父trait,则只初始化一次
4. 执行子类构造器
 trait Student extends Logger with Mylogger
  {println("执行Student构造器!")}

特质trait=包含抽象类的所有功能(既有抽象属性和方法,又有具体属性和方法)
+被子类继承多个trait 。
声明:本文内容由互联网用户自发贡献自行上传,本网站不拥有所有权,未作人工编辑处理,也不承担相关法律责任。如果您发现有涉嫌版权的内容,欢迎发送邮件至:qvyue@qq.com 进行举报,并提供相关证据,工作人员会在5个工作日内联系你,一经查实,本站将立刻删除涉嫌侵权内容。