Scala基础1

本文深入讲解Scala编程语言的基础概念,包括方法、函数、参数、数组、Map集合和元组的使用,以及lazy懒加载机制,适合初学者入门和进阶。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

基本概念:

//方法

Object Demo01Method{
    
    def main(args:Array[String]) : Unit ={

        println(method01())
        println(method01)

        println(method02)
        println(method03("yubanmeiqin"))
        println(method04("xuenai",18))

}

    //使用def定义一个方法。

    //方法的定义:  def 方法名(参数列表):返回值={方法体}


    def method01():String ={

       "this is method01"
}


//没有方法参数,可以省略 ,不写返回值类型,可以自动推导。

    def method02 ={

       "this is method02"
}

//指定一个参数的方法
    
    def method03(name:String):String={

         name
    }
    
    //方法重载
    def method03(name:String,age,Int):String={

        //字符串内取值
        s "name is $name,age is $age"
    }    

}


//函数

 object Demo02Function {

     def mian(args:Array[String]):Unit={

           println(function01(10))

           println(function02(10,20))

           println(method01(10,function01))//110

           println(method02(10,function02))//30

}

//函数的定义: val /var  函数名称=(函数的参数列表)=>函数体

val func01 = (a:Int) =>{

  a*10

}

val func02=(a:Int,b:Int)=>{

   if(a>b) a else b

}

//a:Int 常量

//func:Int=>Int  函数   一个Int类型参数  返回值是Int

def method01(a:Int,func(Int)=>Int):Int={

a+func(a)

}

 

def method02(a:Int,func:(Int,Int)=>Int):Int ={

     val m=10

     val n=20

     a+func(m,n)

}

}

 

//方法参数

object Demo03MethodArguments{

def main(args:Array[String]):Unit={

method01("yuban","nv")

method01("yuban")

method02("xiamuguizhi",16)

//可以不按照给定参数顺序,但必须带上参数名

method02(age=16,name="xiamuguizhi")

method03(1,2,3)

method03(1,2,3,4,5,6)

}

//声明参数给定默认值  调用时不传值  就使用默认值

def method01(name:String,sex:String="nv"):Unit={

println(s"$name $sex")

}

def method02(name:String,age:Int):Unit ={

println(s"$name $age" )

}

//变长参数指 参数个数不确定

def method03(num:Int*):Unit ={

println(num.toBuffer)

}

}

 

//lazy 懒加载

object Demo04Lazy

def main(args:Array[String]):Unit={

  //lazy 懒加载,当调用的时候被执行

 val age=18

var study ="unknow"

println(study) //unknow

 lazy val res= if(age>17){

         study="资深码农"

         study

}else{

       study="小白"

       study

}

 println("执行前:"+study)

println(res) //lazy 执行

println("执行后:"+study)

 

应用场景:scala 从本地读取文件

lazy val lines=Source.fromFile("E://file/a.txt").getLines()

for(line <-lines){

  println(line)

   }

  }

}

//Array数组

 

object Demo05Array{

  def main(args:Array[String]):Unit={

    //array  可变和不可变

    //不可变

val arr01:Array[Int] =new Array[Int](10)

println(arr01.toBuffer)

arr01(0)=0//给对应下标元素 赋值

arr01(1)=1

arr01(2)=2

println(arr01(1))

println(arr01.toBuffer)

//arr01(10)=2 //报错:ArrayIndexOutOfBoundsException: 10  长度不可变

val arr02:Array[Int]=Array(1,2,5,3,7)//通过apply的方式添加

//遍历

// for(i <- arr02)

//println(i)

arr02.length
    println(arr02.filter(_%2==0).toBuffer)  //_ 代表每个元素, filter会留下返回为true 的元素
    arr02.size
    println(arr02.sorted.reverse.toBuffer)
    arr02.max
    arr02.min
    println(arr02.mkString)
    println(arr02.mkString(","))

    //_+_  第一个_ 代表累加的和  第二个_ 代表累加的元素
    println(arr02.reduce(_+_))  //累加
    println(arr02.toBuffer) //转换成成可变数组

    println("------------------------------")

 // ---------ArrayBuffer  可变的数组

val arrBuffer01 = ArrayBuffer(1,2,3,4)

val arrBuffer02 =new ArrayBuffer[Int]()

arrayBuffer02+=0

arrayBuffer02+=1

arrayBuffer02+=2

arrayBuffer02+=3

arrayBuffer02.append(4)
    arrayBuffer02.remove(0)
    arrayBuffer02.length
    arrayBuffer02.size
    arrayBuffer02.sorted.reverse
    arrayBuffer02.insert(0,1,2,3,5) //指定位置插入多个元素

arrayBuffer02.foreach(println(_))

println("---------------------------")

arrayBuffer02.foreach(num=>println(num))

println(arrayBuffer02)

}

}

//Map集合

/**
  * Created by young on 2019.3.1.
  * desc: Map(映射)是一种可迭代的键值对(key/value)结构。
  * 所有的值都可以通过键来获取。
  * Map 中的键都是唯一的。
  * Map 也叫哈希表(Hash tables)。
  * Map 有两种类型,可变与不可变,区别在于可变对象可以修改它,而不可变对象不可以。
  * 默认情况下 Scala 使用不可变 Map。如果你需要使用可变集合,你需要显式的引入 import scala.collection.mutable.Map 类
  * 在 Scala 中 你可以同时使用可变与不可变 Map,不可变的直接使用 Map,可变的使用 mutable.Map。
  */

object Demo06Map{

def main(args:Array[String]):Unit={

//map 可变  不可变

//不可变: 以元组的形式创建map ("hadoop1",10000)

val map01:Map[String,Int]=Map(("hadoop1",10000),("hadoop2",18000),("hadoop3",23333))

val v1:Int=map01("hadoop1")

println(v1)

//Option 有两个子类 Some none

val option:Option[Int]=map01.get("hadoop1")

println(option.get)                //Some(10000).get

val option01:Option[Int]=map01.get("hadoop3")  //none

//推荐使用

println(map01.getOrElse("hadoop4",0))

//遍历

for(ele<- map01){   // ele 是一个元组

println(ele._1+"  "+ele._2)

}

println("-------------------------")

for((k,v)<-map01){

println(k+" "+v)

}

//使用映射的方式

val map03 =Map("lao"->1,"zi"->2,"le"->3,"yi"->4)

map03("lao")=100

map03.contains("")

}

}

 

//元组 Tuple

object DemoTuple{

  def main(args:Array[String]):Unit={

//元组

val tuple=(1,"name",100.0,235151515L)

println(tuple._1)

println(tuple._2)

for(i<- tuple.productIterator){

println(i)

}

val tuple01=((1,"name",100.0,1434134148L),(2,"name1",200.0,341341378L))

println(tuple01._1._2)

//特殊的元组  对偶元组  只有两元素的元组

val tuple02=(1,2)

}

}

 

 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值