Scala语言的学习

var和val

var 变量

val 值 final

在面向对象编程时,var 标识的变量会生成getter、setter;val标识的变量会生成getter方法

val money:Int=100;//相当于final 不可以变 不写类型 会自动推导
var name:String="zhangsan";//可变
name="zhangsan1";
Scala基本数据类型

Byte/Char

Short/Int/Long/Float/Double

val a:Int=10;
var b:Boolean=true;
val d=1.1;//double类型
var e:Float=1.1f//float类型
val f-10;
//将f转为double类型
val g=10.asInstanceOf[Double];
//判断是不是某个类型
val h=10.isInstanceOf[Int];//==>返回true/false
lazy在scala中的使用 延迟加载
var i=1;
lazy val a=1 //==>返回 a:Int=<lazy> 只有在使用该变量的时候 才会初始化,换言之只有在使用的时候 才真正执行该语句,示例如下
print(a)==>1
//scala读取文件
import scala.io.Source._
lazy val info=fromFile("Scana.md").mkString
print(info)//报错 no such file
//上面给出一个错误的文件路径,但是并没有报错,在使用的时候才报错

Scala函数

def max(x:Int,y:Int):Int={
if(x>y)
  x
 else y
}

def 开始函数定义;max 函数名;x,y 括号中的参数列表;Int 函数返回值类型;if/else 大括号中的函数体

函数、方法的定义

def 方法名(参数名:参数类型):返回值类型={

//括号内的叫做方法体

//方法体内的最后一行为返回值,不需要使用return

}

object Main {
  def main(args: Array[String]): Unit = {
    println(sum(1, 2))
    println(test())
    //没有入参的函数,调用时括号是可以省略的
    println(test)
  }

  def sum(x: Int, y: Int): Int = {
    x + y
  }

  //当方法体只有一行时 可以去掉大括号
  def test() = 1 + 2
}
Scala 默认参数的使用

默认参数:在函数定义时,允许指定参数的默认值

 def sayName(name:String="wojiushiwo"): Unit ={
    println(name)
  }

//调用时
sayName()
sayName("hello scala")
命名参数
def speed(distance:Float,time:Float):Float={
  distance/time
}
//调用时 除了按位置为变量赋值,还可以按照变量名匹配
println(speed(100,10))
println(speed(distance-100,time=10))
println(speed(time=10,distance=100))
可变参数
def sum(numbers:Int*)={
  var result=0
  for(number<-numbers){
    result+=number
  }
}
println(sum(1,2))
println(sum(1,2,3))
条件表达式

if…else

if(x>0){
  true
}else{
  false
}
//也可以把if...else赋值给变量
val a=if(x>0) true else false
循环表达式
  • to

    1 to 10==>(1,2,3,4,5,6,7,8,9,10) 左闭右闭的区间
    //等价于
    1.to(10)
    
  • Range

    Range(1,10)==>(1,2,3,4,5,6,7,8,9) 左闭右开

    Range(1,10,2)==>(1,3,5,7,9) 其中2表示步长

    Range(10,1,-1)==>(10,9,8,7,6,5,4,3,2)

  • util

    1 until 10 等同于1.until(10) 同样不包含end

for(i <- 1 to 10 if i%2==0){
  println(i)
}
val courses=Array("hadoop","Spark SQL","Spark")
courses.foreach(course=>println(course))
//1-100求和
var (num,sum)=(100,0)
while(num>0){
  sum=sum+num
  num=num-1
}
println(sum)

面向对象

类的定义

class People{
  var name:String=_
  var age:Int=10
  private [this]var gender="gender"
  def eat():String={
    name+"eat..."
  }
}
//使用时
val people=new People()
people.name="wojiushiwo"//相当于setter
println(people.name+".."+people.age)

_ 表示占位符,有为变量赋初始值的含义

主构造器和附属构造器
//主构造器 参数是val
class Person(val name:String,val age:Int){
  println("Person constructor enter")
  val school="abcd"
  var gender:String=_
  //附属构造器
  def this(name:String,age:Int,gender:String){
    //附属构造器的第一行代码必须要调用主构造器或者其他附属构造器
    this(name,age)
    this.gender=gender
  }
}
//Demo
object Main {
  def main(args: Array[String]): Unit = {
    val person = new Person("zhangsan",30)
    val person1=new Person("abc",20,"male")
  }

  class Person(val name:String,val age:Int){
    println("Person Constructor enter...")

    var school="ustc"
    var gender:String=_
    println("Person Constructor leave...")

    def this(name:String,age:Int,gender:String){
      this(name,age)
      this.gender=gender
    }
  }

}
继承

子类继承父类,如果子类中的成员变量是父类里有的,则不用var/val,否则必须带上var或val

class Person(val name:String,val age:Int){
  println("Person constructor begin")
  
  var gender:String=_
  def this(name:String,age:Int,gender:String){
    this(name,age)
    this.gender=gender
  }
  
}



//创建子类 并继承Person
class Student(name:String,age:Int,var major:String)extends Person(name:String,age:Int){
  println("Studeng constructor begin")
}

//使用时
object App{
  def main(args:Array[String]):Unit={
    var people=new People("zhangsan",23);
    var student=new Student("lisi",20,"Java")
  }
}
重写 对父类的属性和方法进行重写
class Student(name:String,age:Int,var major:String)extends Person(name:String,age:Int){
  println("Studeng constructor begin")
  override var school="peking"
  override def toString:String="Person:override def toString"
  
}
抽象类
object App{
  def main(args:Array[String]):Unit={
    var student=new Student()
  }
  
  abstract class Person{
    def speak
    val name:String
    val age:String
  }
  
  class Student extends Person{
    override def speak:Unit={
      println("speak")
    }
    override val name:String="hello"//不能使用占位符_
    override val age:String="18"
  }
  
}
伴生类与伴生对象
object App{
  
}
class App{
  
}
//如果有一个class,还有一个与class同名的object,那么就称这个
//object是class的伴生对象,class是object的伴生类
//我们说class App是object App的伴生类,Object App是class APp的伴生对象
apply方法
object App{
  def apply: Unit ={
    println("object App apply")
  }

class App{
  def apply: Unit ={
    println("class App apply")
  }
}

def main(args:Array[String]):Unit={
  App.apply()//类名() 调用的是object apply
  new App().apply()//对象() 调用的是class apply
}
  
}

//最佳实践 在Object 的apply方法中去new class

object App{
  def apply: Unit ={
    //最佳实践
    new App()
    println("object App apply")
  }

class App{
  def apply: Unit ={
    println("class App apply")
  }
}

def main(args:Array[String]):Unit={
  App.apply()//类名() 调用的是object apply
  new App().apply()//对象() 调用的是class apply
}
  
}
case class
//通常用在模式匹配
object App{
  def main(args:Array[String]):Unit={
  println(Dog("dog").name)//==>输出dog
}
  //case class 不用new
  case class Dog(name:String)
}
trait

Xxx extends ATrait with BTrait

数组

//定义object 在main方法中写代码 运行
//另一种方式,object直接继承App 随后直接写代码 不需要main
object ArrayApp extends App{
  println("abcd")
  //声明一个5个元素的数组
  var a=new Array[String](5)
  a(1)="hello"//为下表是1的位置赋值
  a(1)//取值
  var b=Array(1,2,3,4)//直接写
  //Int类型的数组 可以求和 求最大值、最小值 API已经有了
  b.sum
  b.min
  b.max
  b.mkString(",")==>使用,来分割数组
}

可变数组

val c=scala.collection.mutable.ArrayBuffer[Int]()//mutable可变
c+=1
c+=2//往数组中添数据
c+=(3,4,5)
c++=Array(6,7,8)
c.remove(1)
c.remobe(0,3)//从0开始删除3个
c.toArray==》转为Array

for(i<-(0 until 10).reverse){==》倒序输出
  println(c(i))
}
List

Nil 空的List

object ListApp extends App{
  val l=List(1,2,3,4,5)
  l.head==>1
  l.tail==>2,3,4,5 除head之外的都是tail
  l.tail.head==>2
  //构造List
  val l2=1::Nil==>1当做head Nil当做tail List(1)
  val l3=2::l2==>List(2,1)
  val l5=scala.collection.mutable.ListBuffer[Int]()
  l5+=2
  l5+=(3,4,5) //add element
  l5-=2 
  l5-=(3,4)//remove element
  l5--=List(1,2,3,4)
  //转换
  l5.toList
  l5.toArray
  l5.isEmpty==》是否为空
  
  //递归求和
  def sum(nums:Int*):Int={
    if(nums.length==0){
      0
    }else{
      nums.head+sum(nums.tail:_*)
    }
  }
}
Set
val set=Set(1,2,2,1,4,3)==>1,2,4,3
val set1=scala.collection.mutable.Set[Int]()
set1+=1
set1+=(1,2,3)
Map

Map(映射)是一种可迭代的键值对(key/value)结构。

所有的值都可以通过键来获取。

Map 中的键都是唯一的。

Map 也叫哈希表(Hash tables)。

Map 有两种类型,可变与不可变,区别在于可变对象可以修改它,而不可变对象不可以。

默认情况下 Scala 使用不可变 Map。如果你需要使用可变集合,你需要显式的引入 import scala.collection.mutable.Map 类

在 Scala 中 你可以同时使用可变与不可变 Map,不可变的直接使用 Map,可变的使用 mutable.Map。以下实例演示了不可变 Map 的应用:

// 空哈希表,键为字符串,值为整型

var A:Map[Char,Int] = Map()

// Map 键值对演示

val colors = Map(“red” -> “#FF0000”, “azure” -> “#F0FFFF”)

定义 Map 时,需要为键值对定义类型。如果需要添加 key-value 对,可以使用 + 号,如下所示:

A += (‘I’ -> 1)

A += (‘J’ -> 5)

A += (‘K’ -> 10)

A += (‘L’ -> 100)

object Test { 
def main(args: Array[String]) { 
val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF", "peru" -> "#CD853F") 
val nums: Map[Int, Int] = Map() 
println( "colors 中的键为 : " + colors.keys ) println( "colors 中的值为 : " + colors.values ) 
println( "检测 colors 是否为空 : " + colors.isEmpty ) 
println( "检测 nums 是否为空 : " + nums.isEmpty ) 
}
}

keys 返回 Map 所有的键(key)

values 返回 Map 所有的值(value)

isEmpty 在 Map 为空时返回true

Map 合并

你可以使用 ++ 运算符或 Map.++() 方法来连接两个 Map,Map 合并时会移除重复的 key。以下演示了两个 Map 合并的实例:

object Test {

def main(args: Array[String]) {

val colors1 = Map(
“red” -> “#FF0000”,

“azure” -> “#F0FFFF”,

“peru” -> “#CD853F”)

val colors2 = Map(
“blue” -> “#0033FF”,

“yellow” -> “#FFFF00”,

“red” -> “#FF0000”)

// ++ 作为运算符 
var colors = colors1 ++ colors2 
println( "colors1 ++ colors2 : " + colors ) 
// ++ 作为方法 
colors = colors1.++(colors2) 
println( "colors1.++(colors2)) : " + colors )
}
}
//输出
colors1 ++ colors2 : Map(blue -> #0033FF, azure -> #F0FFFF, peru -> #CD853F, yellow -> #FFFF00, red -> #FF0000)

colors1.++(colors2)) : Map(blue -> #0033FF, azure -> #F0FFFF, peru -> #CD853F, yellow -> #FFFF00, red -> #FF0000)
object MapApp extends App {

  var map = mutable.HashMap[String, Int]()
  map += ("1" -> 1)
  map += ("2" -> 2)
  //如果没有这个Key 则返回第二个参数
  private val i: Int = map.getOrElse("3",3)
  println(i)==>输出3
}

模式匹配

Java: 对一个值进行条件判断,返回针对不同的条件进行不同的处理

scala:

变量 match{

case valu1 =>代码1

case value2=>代码2

case _=>代码N

}

object MatchApp {

  var numList = List(1, 2, 3, 4)

  var num = numList(Random.nextInt(numList.length))

  num match {
    //简单的模式匹配类似于switch case
    case 1 => println("1")
    case 2 => println("2")
    case 3 => println("3")
    case 4 => println(4)
    case _ => println("nothings")
  }

  def matchNum(x: Int): Int = {
    x match {
      case 1 => 1
      case 2 => 2
      case _ => -1
    }

  }


  def main(args: Array[String]): Unit = {
    val i = matchNum(1)
    println(i)
  }
}
加条件进行匹配

类似于双重过滤,均满足才会走到对应分支

def judgeGrade(name:String,grade:String):Unit={
  grade match{
    case "A"=>println("A")
    case "B"=>println("B")
    case "c"=>println("C")
    case _ if(name=="lisi")=>println("lisi")
    case _=>println("hello")
  }
}
//在main里调用时
judgeGrade("zhangsan","A")==>输出A 因为先匹配到了A
judgeGrade("zhangsan","D")==>名称和grade均未匹配到,所以输出hello
Array模式匹配
def main(args: Array[String]): Unit = {
    greeting(Array("zhangsan"))//hi zhangsan
    greeting(Array("zhangsan","lisi"))//hi:zhangsan ,lisi
    greeting(Array("zhangsan","lisi","wangwu"))//hi
    greeting(Array("1","zhangsan","lisi","wangwu"))//hi everybody
  }

  def greeting(array: Array[String]): Unit = {
    array match {
      case Array("zhangsan") => println("hi zhangsan")
      case Array(x, y) => println("hi:" + x + " ," + y)
      case Array("zhangsan", _*) => println("hi ")
      case _ => println("hi everybody")
    }
  }
List模式匹配
def main(args: Array[String]): Unit = {
    greeting(List("zhangsan"))//hi zhangsan
    greeting(List("zhangsan","lisi"))//hi:zhangsan ,lisi
    greeting(List("zhangsan","lisi","wangwu"))//hi
    greeting(List("1","zhangsan","lisi","wangwu"))//hi everybody
  }

  def greeting(list: List[String]): Unit = {
    list match {
      case "zhangsan"::Nil => println("hi zhangsan")
      case x::y::Nil => println("hi:" + x + " ," + y)
      case "zhangsan"::tail => println("hi ")
      case _ => println("hi everybody")
    }
  }
类型匹配
def matchType(obj:Any): Unit ={
    obj match {
      case x:Int=>println("Int")
      case s:String=>println("String")
      case m:Map[_,_]=>m.foreach(println)
      case _=>println("other type")
    }
  }
异常处理
try {
      var i = 10 / 0
      println(i)
    } catch {
      case e: ArithmeticException => println(e.getMessage)
      case e: Exception => println(e.getCause)
    }
case class 模式匹配
class Person

  case class Student(name: String, age: Int) extends Person

  case class Employee(name: String, job: String) extends Person

  case class other(name: String) extends Person

  def caseClassMatch(person: Person): Unit = {
    person match {
      case Student(name, age) => println("student=>" + name)
      case Employee(name, job) => println("Employee=>" + job)
      case _ => println("other")
    }
  }


def main(args: Array[String]): Unit = {
    caseClassMatch(Student("wojiushiwo",12))//student=>wojiushiwo
    caseClassMatch(Employee("wojiushiwo","work"))//Employee=>work
    caseClassMatch(other("hi"))//other

  }
var map=Map("zhangsan"->"A","lisi"->"B")
  def getGrade(name:String): Unit ={
    val grade = map.get(name)
    grade match {
       //Scala 语言中包含一个标准类型 Option 类型,代表可选值。Option 类型的值有两个可能的值,
      // 一个为 Some(x) 其中 x 为有效值,另外一个为 None 对象,代表空值
      case Some(grade)=>println("grade")
      case none=>println("none")
    }
  }

  getGrade("zhangsan")
  getGrade("lisi1")
函数高级操作
object StringApp extends App{
  val s="Hello"
  val name="PK"
  //字符串插值
  println(s"hello:$name")//输出HelloPK
  
  val margin =
      """
多行字符串
    """.stripMargin
    println(margin)
}

#####匿名函数

val m1=(x:Int)=>x+1
def add=(x:Int,y:Int)=>{x+y}
//使用时
add(2,3)
curring函数 颗粒化函数
def sum(x:Int,y:Int)=a+b
//将原来接收两个参数的一个函数,转换成2个每个接收一个参数的函数
def sum2(x:Int)(y:Int)=a+b
//调用时
println(sum2(2)(3))
高阶函数
  • map 逐个去操作集合中的每个元素

    val l=List(2,3,4)
    l.map((x:Int)=>x+1) 或 l.map(x=>x+1)
    l.map(_*2).foreach(println)//每个元素*2
    
  • filter

    val l=List(2,3,4)
    l.map(_*2).filter(_>8).foreach(println)
    //取集合中的前几个元素
    l.take(n)
    l.max
    l.min
    l.sum
    
  • reduce

    val l=List(2,3,4)
    l.reduce(_+_)//两辆相加 求和
    l.reduceLeft(_-_)
    l.reduceRight(_-_)
    l.fold(0)(_-_)
    
  • flatten&flatmap

    var l=List(List(1,2),List(3,4),List(5,6))
    l.flatten//类似于flatmap ==>得到List(1,2,3,4,5,6)
    l.flatmap(_.map(_*2))
    //从文件读
    val txt=scan.io.Source.fromFile("hello.txt").mkString
    
发布了84 篇原创文章 · 获赞 21 · 访问量 8万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 精致技术 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览