Scala入门

Scala简介

Scala源自Java

  • Scala构建在JVM之上
  • Scala与Java兼容、互通
    在这里插入图片描述

Scala的优势

  • 多范式编程：面向对象编程、函数式编程
  • 表达能力强，代码精简
    在这里插入图片描述

大数据与Scala

  • Spark采用Scala语言设计

     提供的API更加优雅
 基于JVM的语言更融入Hadoop生态圈

在这里插入图片描述

安装Scala编译器和开发环境

Scala编译器安装和开发环境安装

Scala交互式编程（REPL）

在这里插入图片描述

Scala初体验

  • 编写HelloWorld
object HelloWorld {
  def main(args: Array[String]): Unit = {
  var a = "HelloWorld"
    println(a)
  }
}
//def：定义一个方法
//Unit：代表没有返回值
  • 结果展示：
    在这里插入图片描述

Scala概述

面向对象特性

  • 每个值都是对象
  • 对象的数据类型和行为由类（Class）和特征（Trait，类似于interface）描述
  • 利用特征实现混入式多重继承

函数式编程

  • 每个函数都是一个值
  • 支持高阶函数、柯里化（currying）、样例化（case class）及模式匹配…

Scala是静态类型语言

扩展性：隐式类、字符串插值

Scala变量与常量

变量

  • 赋值后可以改变，生命周期中可以被多次赋值
var 变量名称:类型=xxx
//一般无需显示指定类型，Scala编译器会自动推断出类型

在这里插入图片描述
在这里插入图片描述

常量

  • 赋值后不可变，类似于Java中的final变量
val 常量名称:类型=xxx

在这里插入图片描述
定义多行字符串用三个双引号来表示分隔符，格式为：""" … “”"

var a ="""
我爱学习，
我爱Java，
我爱Scala
"""

在这里插入图片描述

使用类型别名定义变量

type关键字

type 类型别名=类型
var 变量名称:类型别名=xxx
val 常量名称:类型别名=xxx

在这里插入图片描述

Scala关键字列表

abstract case catch class
def do else extends
false final finally for
forSome if implicit import
lazy match new null
object overwrite package private
protected return seailed super
this throw trait try
true type val var
while with yield （空格）
- : = =>
<- <: <% >:
# @

Scala数据类型

Scala与Java有着相同的原始数据类型

数据类型 描述
Byte 8位有符号整数。数值区间-128~127
Short 16位有符号整数。数值区间-32768~32767
Int 32位有符号整数。数值区间-2147483648 ~ 2147483647
Long 64位有符号整数。数值区间-9223372036854775808 ~ 9223372036854775807
Float 32位IEEE754单精度浮点数
Double 64位IEEE754双精度浮点数
Char 16位无符号Unicode字符。区间值为U+0000 ~ U+FFFF
Boolean true或false
String 等于java.lang.String

Scala数据类型层次结构

  • Any：所有类型的超类（顶级类型）
  • AnyVal：表示值类型的超类
  • AnyRef：表示引用类型的超类，对应java.lang.Object
  • Unit：表示无值，类似Java中void
  • Nothing：所有类型的子类
  • Null：表示null或空引用
    在这里插入图片描述
    null是Null类型的唯一实例；nothing没有实例

字符串插值

s插值器：允许将变量引用、表达式直接插入字面字符中

val nam="James"
println(s"Hello,Sname")
//Hello,James
println(s"1+1=${1+1}")
//1+1=2

在这里插入图片描述
f值插值器

val height=1.9d
val name="James"
println(f"$name%s is $height%2.2f meters tall")
//%s：后面连接的字符串可以不加空格
//%2.2f：第一个2代表数值>=2不做变化，数值<2用空格补足,相差几就补足几个空格；第二个2代表保留两位小数

在这里插入图片描述
raw插值器

s"a\nb"			//将输出换行符
raw"a\nb"		//输出原始字符

在这里插入图片描述

Scala条件控制

if语句

val x=10
if(x>0){
	print("x大于0")
}

Scala中换行等同于分号，所以分号可以省略

示例

object test {
  def main(args: Array[String]): Unit = {
    val x=10
    if(x>0){
      print("x大于0")
    }
  }
}

输出结果：
在这里插入图片描述

if…else语句

val x=10
if(x>10){
	print("x大于10")	
}else{
	print("x小于等于10")
}

示例

object test {
  def main(args: Array[String]): Unit = {
    val x=10
    if(x>10){
      print("x大于10")
    }else{
      print("x小于等于10")
    }
  }
}

结果展示：
在这里插入图片描述

if…else if…else语句

val x=10
if(x>10){
    print("x大于10")
}else if(x==10){
    print("x等于10")
}else{print("x小于10")
}

示例

object test {
  def main(args: Array[String]): Unit = {
    val x=10
    if(x>10){
      print("x大于10")
    }else if(x==10){
      print("x等于10")
    }else{print("x小于10")
    }
  }
}

结果展示：
在这里插入图片描述

条件语句返回值

Scala任何表达式都有返回值

val x=10
val y=if(x==10) x+1 else x	//单行表达式可以省略{}
//y=?
示例
object test {
  def main(args: Array[String]): Unit = {
    val x=10
    val y=if(x==10) x+1 else x	//单行表达式可以省略{}
    println(y)
  }
}

结果展示：
在这里插入图片描述

代码块“{…}”也是表达式，返回值为最后一个表达式结果

val x=10
val y={
   print("我是代码块")
   x+1
}
//y=11

在这里插入图片描述

val x=10
val y={
    x+1;print("我是代码块")
}
//多个表达式使用“;”分隔
//y=?

在这里插入图片描述

Scala循环控制

while循环

var num: Int = 0;
while ( num < 100 ) {
    println( num );
    num = num + 1;
}

示例

object test {
  def main(args: Array[String]): Unit = {
    var num: Int = 0;
    while ( num < 100 ) {
      println( num );
      num = num + 1;
    }
  }
}

输出结果：
在这里插入图片描述
在这里插入图片描述

do…while

var num: Int = 0;
do {
    println( num ); 
     num = num + 5;
} while ( num < 200 )

示例

object test {
  def main(args: Array[String]): Unit = {
    var num: Int = 0;
    do {
      println( num );
      num = num + 5;
    } while ( num < 200 )
  }
}

结果展示：
在这里插入图片描述
在这里插入图片描述

for循环

val num:Int = 10;
for ( i: Int <- 1 to num ) 
{     
    println( i * 100 );
}

for { i: Int <- 1 until 100 }
{
    val y = 2*i;
    println( y );
}

"i to j"或者"i until j"均表示创建一个区间Range
区别：to表示=这个数字；until表示<这个数字

示例

object test {
  def main(args: Array[String]): Unit = {
    val num:Int = 10;
    for ( i: Int <- 1 to num )
    {
      println( i * 100 );
    }
  }
}

结果展示：
在这里插入图片描述

object test {
  def main(args: Array[String]): Unit = {
    for { i: Int <- 1 until 100 }
    {
      val y = 2*i;
      println( y );
    }
  }
}

结果展示：
在这里插入图片描述
在这里插入图片描述

打印直角在左下的直角三角形
object test {
  def main(args: Array[String]): Unit = {
    //打印直角在左下的直角三角形
    for(i<-1 to 5) {
      for(j<-1 to i) {
        print("*")
      }
      println()
    }
  }
}

结果展示：
在这里插入图片描述

打印直角在左上的直角三角形
object test {
  def main(args: Array[String]): Unit = {
    //打印直角在左上的直角三角形
    for(i<-5 to 1 by -1) {
      for(j<-i to 1 by -1) {
        print("*")
      }
      println()
    }
  }
}

结果展示：
在这里插入图片描述

打印直角在右下的直角三角形
object test {
  def main(args: Array[String]): Unit = {
    //打印直角在右下的直角三角形
    for(i<-1 to 5 ) {
      for(j<-1 to 5-i ) {
        print(" ")
      }
      for(j<-1 to i){
      print("*")
      }
      println()
    }
  }
}

结果展示：
在这里插入图片描述

打印直角在右上的直角三角形
object test {
  def main(args: Array[String]): Unit = {
    //打印直角在右下的直角三角形
    for(i<-1 to 5  ) {
      for(j<-1 to i-1 ) {
        print(" ")
      }
      for(j<-1 to 6-i){
      print("*")
      }
      println()
    }
  }
}

结果展示：
在这里插入图片描述

打印等腰三角形
object test {
  def main(args: Array[String]): Unit = {
    //打印等腰三角形
    for(i<-1 to 5){
      for (j<-1 to 5-i) {
        print(" ")
      }
     for(j<-1 to 2*i-1){
print("*")
     }
      println()
    }

  }
}

结果展示：
在这里插入图片描述

打印空心等腰三角形
object test {
  def main(args: Array[String]): Unit = {
  //外循环决定行，内循环决定列 共5行 固 i为1-5
    for(i<-1 to 5) {
    //空格数从 4-0 固 5-i
      for(j<-1 to 5-i) {
        print(" ")
      }
      //*的数量 为 1 3 5 7 固 2*i-1
      for(j<-1 to 2*i-1) {
      //空心 顾名思义 只留最边的*号
        if(j==1 || j==2*i-1 ||i==5){
          print("*")
        }else{
          print(" ")
        }
      }
      //后续空白 有无无所谓 同第一个内循环
      for(1<-1 to 5-i){
        print(" ")
      }
      println()
    }
  }
}

结果展示：
在这里插入图片描述

九九乘法表
object test {
  def main(args: Array[String]): Unit = {
    for(i<-1 until 10) {
      for(j<-1 to i) {
        print(i+"*"+j+"="+(i*j)+"\t")
      }
      println()
    }
  }
}

结果展示：
在这里插入图片描述

中断

import.scala.util.control.Breaks._
val num:Int = 10;
for ( i: Int <- 1 to num by 2 ) {
    if(i>=5) break; 
    println( i * 100 );
}

by表示步长

import scala.util.control.Breaks
    var num=10
    val loop=new Breaks
    loop.breakable(
      for(x<-num to 1 by -1) {
        if(x<3)loop.break
        println(x)
      }
    )

示例

object test {
  def main(args: Array[String]): Unit = {
    import scala.util.control.Breaks._
    var num=10
    breakable{
      for(x<-num to 1 by -1) {
        if(x<3)break
        println(x)
      }
    }
  }
}

结果展示：
在这里插入图片描述

for循环过滤

val num:Int = 10;
for ( i: Int <- 1 to num; if i%2==0;if i>5 ) //多个条件时使用分号(;)
{     
    println( i * 100 );
}

for循环返回值

for循环中的yield会把元素记下来，保存在集合中，循环结束后将返回该集合。也称for推导式

val num:Int = 10;
var retVal=for ( i: Int <- 1 to num; if i%2==0;if i>5 ) yield i;	//for循环使用yield将具有返回值
for(a<-retVal){
    println(a);
}
//输出6 8 10

示例

var i=100
    val resValue = for (x <- 1 to i; if x % 2 == 0; if x % 5 == 0) yield x
    println(resValue)
    for(i<-resValue) {
      println(i)
    }

结果展示：
在这里插入图片描述
使用Scala编程输出如图所示加法表
在这里插入图片描述

object test {
  def main(args: Array[String]): Unit = {
    for(i<-0 to 6 by 1) {
      println(s"$i+${6-i}=6")
    }
  }
}

结果展示：
在这里插入图片描述

Scala数组

存储固定大小的元素
数组索引从0开始

//数组创建方式一
var a1:Array[String] = new Array[String](3)	//泛型使用方括号
a1(0)="Jason"	//数组元素访问使用圆括号
a1(1)="Marie"
a1(2)="Jimmy"

//数组创建方式二
var a2=Array("Jason","Marie","Jimmy")	//调用Array的伴生对象中的apple()返回Array实例

//数据创建方式三：区间数组
var a3=Array.range(1,10,2)

Scala元组

可以包含不同类型的元素
最多支持22个元素（Tuple1~Tuple22）
使用下划线“_”访问元素，“_1”表示第一个元素

//元组声明方式一
var tp1 = ("Mike", "123 ABC street", 58)
println(tp1._1)
println(tp1._2)
println(tp1._3)

//迭代元组
tp1.productIterator.foreach{ i =>println("Value = " + i )}

//元组声明方式二
var tp2 = new Tuple3("Mike", "123 ABC street", 58)

//元组声明方式三
def mike = "Mike" -> 5

//输出scala.Tuple2
mike.getClass

//将元组元素依次赋给三个变量
val(name, address, age) = tp1
println(name)
println(address)
println(age)

输出结果：
在这里插入图片描述

Scala集合（一）

Seq

  • 序列，元素按顺序排序

Set

  • 集合，元素不重复

Map

  • 映射，键值对集合
    在这里插入图片描述

Scala集合（二）

不可变集合

  • scala.collection.immutable，默认Scala选择不可变集合

可变结合：可以修改、添加或移除一个集合的元素

  • scala.collection.mutable
var a=scala.collection.mutable.ListBuffer(1,2,3)
a(1)=1
a
var b=List(1,2,3)
b.getClass
b.drop(1)
a
b

在这里插入图片描述

Scala集合（三）

Scala.collection.immutable

Set：ListSet、HashSet、TreeSet
Map：ListMap、HashMap、TreeMap
Seq：Vector、String、Range、List、Stack、Stream、Queue

在这里插入图片描述

Scala集合（四）

scala.collection.mutable
在这里插入图片描述

Scala集合（五）

常用集合

名称 可变/不可变 示例
Buffer mutable val buffer=scala.collection.mutable.ArrayBuffer[Int](10,20,30); buffer+=(2,3)
Array mutable val arr=Array(1,2,3)
List immutable val lst=List(1,2,3)
Map mutable val stu=Map(“name”->“Jason”,“age”->“18”)
Set mutable/immutable val set=Set(1,2,3)
Vector immutable val v=Vector(1,3,5,7,11,13)
Stack mutable/immutable val st=scala.collection.mutable.Stack(1,2,3) //堆栈，先进后出
Queue mutable/immutable val q=scala.collection.mutable.Queue(1,2,3) //队列，先进先出
BitSet mutable/immutable val bit=scala.collection.mutable.BitSet(3,2,0) //位集合
ListMap immutable val map=scala.collection.mutable.ListMap(1->“one”,2->“two”)
HashSet mutable val set=scala.collection.mutable.HashSet(1,2,3)
HashMap mutable val stu=scala.collection.mutable.HashMap(“name”->“Jason”,“age”->“18”)

Scala List常用操作

var c = List[Char]('a', 'b', 'c')
var x = 'x' +: c    // (x, a, b, c)
var y = c :+ 'x'   // (a, b, c, x)
import scala.collection.mutable._
var lb = ListBuffer[Int](1, 2, 3, 4)
lb += 100    //1, 2, 3, 4, 100
lb += (21, 33)//    
88 +=: lb   //88, 1, 2, 3, 4, 100, 21, 33
List(77, 66) ++=: lb     

var l = List[Int](2, 3, 4, 6, 8, 9, 11, 20)
var x = l grouped 3   //等价l.grouped(3)
x.next()    //(2, 3, 4)
x.next()   //(6, 8, 9) 
var y = l sliding 2
y.next()  // (2, 3)
y.next()  // (3, 4)

var a1 = Array[Int](1, 2, 3, 4)
var a2 = Array[Int](100, 200, 300, 400)
var a = List.concat(a1, a2)//Array->List
a3=a1++a2  //Arrays->Array
a(3) = 333    //Error
a3(3)=333    //OK
var b = Array(333, "333", '3', false )
var c = List.concat(a, b)  
val x = a.filter( _ %2 != 0 )
val y = a.reverse 
var m = a.groupBy(t => t%2 == 0)
var n = a.slice(2, 4)
a.sorted   //1, 2, 3, 4, 100, 200, 300, 400
a.sorted( Ordering.Int.reverse )
a.sortWith( _ > _ )
a.sortBy( x => x )   //升序
a.sortBy( x => x*(-1) )   //降序

Scala Set常用操作

var s = Set("ab", "yz")
s += "mn"    //mn, ab, yz
s += "mn"    //??
s -= "yz"       //mn, ab
var t = Set("ab", "gh", "mn", "st", "yz" )
t -- s       //gh, st, yz   
t ++ s    //ab, gh, mn, st, ya

var os = SortedSet(1, 99, 66, 54, 77 )
os  //1, 54, 66, 77, 99
os += 33
os  //1, 33, 54, 66, 7

var s = Set("ab", "yz")
var t = Set("ab", "gh", "mn", "st", "yz" )
//求交集
t & s       
t intersect s
//求并集
t | s
t union s
//求差集
t &~ s
t diff s

Scala Map常用操作

var m = Map[String, Int]("a"->1, "b"->2, "c"->3, "d"->4, "e"->5, "f"->6, "g"->7, "h"->8, "i"->9)
m("a")        //1
m += ("j"->0)
m += ("j"->0)   //??
m += ("j"->11)   //??
var n = m ++ Map[String, Int]("a"->3, "j"->99)    //??
n -= ("g", "e")

Scala Stream & Vector

Stream是List惰性版（需要的时候再去调用）

val stream = (1 to 1000).toStream
stream     // Stream(1, ?)
stream.head // 1
stream.tail  // Stream(2, ?)
stream(3)
stream.tail  // Stream(2,3,4,?)

Vector拥有连续的内存空间，利于随机存取（直接访问）

val v = Vector.empty :+ 2 :+ 2
val v1 = v ++ Vector[Int](3)
v.length
v1.length
# scala # 大数据 # spark
Logo
魔乐社区

魔乐社区（Modelers.cn) 是一个中立、公益的人工智能社区，提供人工智能工具、模型、数据的托管、展示与应用协同服务，为人工智能开发及爱好者搭建开放的学习交流平台。社区通过理事会方式运作，由全产业链共同建设、共同运营、共同享有，推动国产AI生态繁荣发展。

更多推荐

cover

全家桶集齐！Qwen3.5四款小模型上线魔乐社区，附昇腾全套实践教程

avatar 魔乐社区

Pont - 搭建前后端之桥：高效、灵活的接口管理工具

Pont 是一款强大的数据服务层解决方案，它能够帮助开发者快速搭建前后端之间的桥梁，实现接口的高效管理和代码自动生成。无论是新手还是有经验的开发者，都能通过 Pont 轻松处理接口文档、生成类型安全的 API 代码，从而显著提升开发效率。[![Pont 工具标志](https://raw.gitcode.com/gh_mirrors/po/pont/raw/3f1b7d4bbba3fd2dda

avatar 魔乐社区

如何快速上手 hvac：HashiCorp Vault Python 客户端零基础入门指南

**hvac** 是 HashiCorp Vault 的 Python 3.X 客户端库，专为开发者提供简单高效的 Vault 交互方式。无论你是需要管理密钥、配置身份验证，还是实现安全的秘密数据存储，hvac 都能帮助你轻松搞定 Vault 的各项操作。本文将带你零基础快速入门，从安装到基础操作，让你在几分钟内即可上手使用这个强大的工具。[![hvac 客户端 Logo](https://r

avatar 魔乐社区