Scala基本使用

Posted 飞鸟码农

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Scala基本使用相关的知识，希望对你有一定的参考价值。

一. scala简介

scala是运行在JVM上的多范式编程语言，同时支持面向对象和面向函数编程


早期，scala刚出现的时候，并没有怎么引起重视，随着Spark和Kafka这样基于scala的大数据框架的兴起，scala逐步进入大数据开发者的眼帘。scala的主要优势是它的表达性。

  • 为什么要使用scala?

  • 通过两个案例对比Java语言和scala语言




为什么使用scala

  • 开发大数据应用程序（Spark程序、Flink程序）

  • 表达能力强，一行代码抵得上Java多行，开发速度快

  • 兼容Java，可以访问庞大的Java类库，例如：操作mysql、redis、freemarker、activemq等等



scala对比Java

下面通过两个案例，分别使用java和scala实现的代码数量



案例

定义三个实体类（用户、订单、商品）

Java代码

/**
 * 用户实体类
 */
public class User {
    private String name;
    private List<Order> orders;

    public String getName() {
     return name;
    }

    public void setName(String name) {
     this.name = name;
    }

    public List<Order> getOrders() {
     return orders;
    }

    public void setOrders(List<Order> orders) {
     this.orders = orders;
    }
}
/**
 * 订单实体类
 */
public class Order {
    private int id;
    private List<Product> products;

    public int getId() {
     return id;
    }

    public void setId(int id) {
     this.id = id;
    }

    public List<Product> getProducts() {
     return products;
    }

    public void setProducts(List<Product> products) {
     this.products = products;
    }
}
/**
 * 商品实体类
 */
public class Product {
    private int id;
    private String category;

    public int getId() {
     return id;
    }

    public void setId(int id) {
     this.id = id;
    }

    public String getCategory() {
     return category;
    }

    public void setCategory(String category) {
     this.category = category;
    }
}


scala代码

case class User(var name:String, var orders:List[Order]) // 用户实体类
case class Order(var id:Int, var products:List[Product]) // 订单实体类
case class Product(var id:Int, var category:String)    // 商品实体类

二. 声明变量

我们将来每一天编写scala程序都会定义变量。那scala语言如何定义变量呢？




语法格式

Java变量定义

int a = 0;


在scala中，可以使用val或者var来定义变量，语法格式如下:

val/var 变量标识:变量类型 = 初始值

其中

  • val定义的是不可重新赋值的变量

  • var定义的是可重新赋值的变量


[!NOTE]

  • scala中定义变量类型写在变量名后面

  • scala的语句最后不需要添加分号



在解释器中定义一个变量

示例：定义一个变量保存一个人的名字"tom"


步骤

  1. 打开scala解释器

  2. 定义一个字符串类型的变量用来保存名字


参考代码

scala> val name:String = "tom"
name: String = tom



val和var变量

示例

给名字变量进行重新赋值为Jim，观察其运行结果


参考代码

scala> name = "Jim"
<console>:12: error: reassignment to val
       name = "Jim"



示例

使用var重新定义变量来保存名字"tom"，并尝试重新赋值为Jim，观察其运行结果


参考代码

scala> var name:String = "tom"
name: String = tom

scala> name = "Jim"
name: String = Jim


[!TIP]

优先使用val定义变量，如果变量需要被重新赋值，才使用var



使用类型推断来定义变量

scala的语法要比Java简洁，我们可以使用一种更简洁的方式来定义变量。


示例

使用更简洁的语法定义一个变量保存一个人的名字"tom"


参考代码

scala> val name = "tom"
name: String = tom


scala可以自动根据变量的值来自动推断变量的类型，这样编写代码更加简洁。



惰性赋值

在企业的大数据开发中，有时候会编写非常复杂的SQL语句，这些SQL语句可能有几百行甚至上千行。这些SQL语句，如果直接加载到JVM中，会有很大的内存开销。如何解决？


当有一些变量保存的数据较大时，但是不需要马上加载到JVM内存。可以使用惰性赋值来提高效率。


语法格式：

lazy val/var 变量名 = 表达式



示例

在程序中需要执行一条以下复杂的SQL语句，我们希望只有用到这个SQL语句才加载它。

"""insert overwrite table adm.itcast_adm_personas
    select
    a.user_id,
    a.user_name,
    a.user_sex,
    a.user_birthday,
    a.user_age,
    a.constellation,
    a.province,
    a.city,
    a.city_level,
    a.hex_mail,
    a.op_mail,
    a.hex_phone,
    a.fore_phone,
    a.figure_model,
    a.stature_model,
    b.first_order_time,
    b.last_order_time,
      ...
    d.month1_hour025_cnt,
    d.month1_hour627_cnt,
    d.month1_hour829_cnt,
    d.month1_hour10212_cnt,
    d.month1_hour13214_cnt,
    d.month1_hour15217_cnt,
    d.month1_hour18219_cnt,
    d.month1_hour20221_cnt,
    d.month1_hour22223_cnt
    from gdm.itcast_gdm_user_basic a
      left join gdm.itcast_gdm_user_consume_order b on a.user_id=b.user_id
    left join gdm.itcast_gdm_user_buy_category c on a.user_id=c.user_id
    left join gdm.itcast_gdm_user_visit d on a.user_id=d.user_id;"""



参考代码

scala> lazy val sql = """insert overwrite table adm.itcast_adm_personas
     |     select
     |     a.user_id,
 ....
     |     left join gdm.itcast_gdm_user_buy_category c on a.user_id=c.user_id
     |     left join gdm.itcast_gdm_user_visit d on a.user_id=d.user_id;"""
sql: String = <lazy>

三. 字符串

scala提供多种定义字符串的方式，将来我们可以根据需要来选择最方便的定义方式。

  • 使用双引号

  • 使用插值表达式

  • 使用三引号




使用双引号

语法

val/var 变量名 = “字符串”



示例

有一个人的名字叫"hadoop"，请打印他的名字以及名字的长度。


参考代码

scala> println(name + name.length)
hadoop6



使用插值表达式

scala中，可以使用插值表达式来定义字符串，有效避免大量字符串的拼接。

语法

val/var 变量名 = s"${变量/表达式}字符串"


[!TIP]

  • 在定义字符串之前添加s

  • 在字符串中，可以使用${}来引用变量或者编写表达式



示例

请定义若干个变量，分别保存："zhangsan"、30、"male"，定义一个字符串，保存这些信息。

打印输出：name=zhangsan, age=30, sex=male


参考代码

scala> val name = "zhangsan"
name: String = zhangsan

scala> val age = 30
age: Int = 30

scala> val sex = "male"
sex: String = male

scala> val info = s"name=${name}, age=${age}, sex=${sex}"
info: String = name=zhangsan, age=30, sex=male

scala> println(info)
name=zhangsan, age=30, sex=male



使用三引号

如果有大段的文本需要保存，就可以使用三引号来定义字符串。例如：保存一大段的SQL语句。三个引号中间的所有字符串都将作为字符串的值。


语法

val/var 变量名 = """字符串1
字符串2"""



示例

定义一个字符串，保存以下SQL语句

select
*
from
    t_user
where
    name = "zhangsan"

打印该SQL语句


参考代码

val sql = """select
     | *
     | from
     |     t_user
     | where
     |     name = "zhangsan""""

println(sql)

四. 数据类型与操作符

scala中的类型以及操作符绝大多数和Java一样，我们主要来学习

  • 与Java不一样的一些用法

  • scala类型的继承体系




数据类型

基础类型 类型说明
Byte 8位带符号整数
Short 16位带符号整数
Int 32位带符号整数
Long 64位带符号整数
Char 16位无符号Unicode字符
String Char类型的序列（字符串）
Float 32位单精度浮点数
Double 64位双精度浮点数
Boolean true或false

注意下 scala类型与Java的区别

[!NOTE]

  1. scala中所有的类型都使用大写字母开头

  2. 整型使用Int而不是Integer

  3. scala中定义变量可以不写类型，让scala编译器自动推断



运算符

类别 操作符
算术运算符 +、-、*、/
关系运算符 >、<、==、!=、>=、<=
逻辑运算符 &&、||、!
位运算符 &、||、^、<<、>>


  • scala中没有，++、--运算符

  • 与Java不一样，在scala中，可以直接使用==、!=进行比较，它们与equals方法表示一致。而比较两个对象的引用值，使用eq


示例

有一个字符串"abc"，再创建第二个字符串，值为：在第一个字符串后拼接一个空字符串。

然后使用比较这两个字符串是否相等、再查看它们的引用值是否相等。


参考代码

val str1 = "abc"
val str2 = str1 + ""
str1 == str2
str1.eq(str2)



scala类型层次结构



类型 说明
Any 所有类型的父类，,它有两个子类AnyRef与AnyVal
AnyVal 所有数值类型的父类
AnyRef 所有对象类型（引用类型）的父类
Unit 表示空，Unit是AnyVal的子类，它只有一个的实例{% em %}() {% endem %}
它类似于Java中的void，但scala要比Java更加面向对象
Null Null是AnyRef的子类，也就是说它是所有引用类型的子类。它的实例是{% em %}null{% endem %}
可以将null赋值给任何对象类型
Nothing 所有类型的子类
不能直接创建该类型实例，某个方法抛出异常时，返回的就是Nothing类型，因为Nothing是所有类的子类，那么它可以赋值为任何类型


nothing

def main(args: Array[String]): Unit = {
    val c = m3(1,0)
}

def m3(x:Int, y:Int):Int = {
    if(y == 0) throw new Exception("这是一个异常")
    x / y
}


问题

以下代码是否有问题？

val b:Int = null


scala会解释报错：

Null类型并不能转换为Int类型，说明Null类型并不是Int类型的子类


五. 条件表达式

条件表达式就是if表达式，if表达式可以根据给定的条件是否满足，根据条件的结果（真或假）决定执行对应的操作。scala条件表达式的语法和Java一样。


有返回值的if

与Java不一样的是，

[!NOTE]

  • 在scala中，条件表达式也是有返回值的

  • 在scala中，没有三元表达式，可以使用if表达式替代三元表达式


示例

定义一个变量sex，再定义一个result变量，如果sex等于"male"，result等于1，否则result等于0


参考代码

scala> val sex = "male"
sex: String = male

scala> val result = if(sex == "male") 1 else 0
result: Int = 1



块表达式

  • scala中，使用{}表示一个块表达式

  • 和if表达式一样，块表达式也是有值的

  • 值就是最后一个表达式的值


问题

请问以下代码，变量a的值是什么？

scala> val a = {
     | println("1 + 1")
     | 1 + 1
     | }


六. 循环

在scala中，可以使用for和while，但一般推荐使用for表达式，因为for表达式语法更简洁




for表达式

语法

for(i <- 表达式/数组/集合) {
    // 表达式
}


简单循环

使用for表达式打印1-10的数字


步骤

  1. 生成1-10的数字（提示：使用to方法）

  2. 使用for表达式遍历，打印每个数字


参考代码1

scala> val nums = 1.to(10)                                                              
nums: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) 
                                                                                        
scala> for(i <- nums) println(i)                                                                                                                                          



简写方式


参考代码2

// 中缀调用法
scala> for(i <- 1 to 10) println(i)

嵌套循环

使用for表达式，打印以下字符

*****
*****
*****


步骤

  1. 使用for表达式打印3行，5列星星

  2. 每打印5个星星，换行


参考代码

for(i <- 1 to 3; j <- 1 to 5) {print("*");if(j == 5) println("")}



守卫

for表达式中，可以添加if判断语句，这个if判断就称之为守卫。我们可以使用守卫让for表达式更简洁。


语法

for(i <- 表达式/数组/集合 if 表达式) {
    // 表达式
}


示例

使用for表达式打印1-10之间能够整除3的数字


参考代码

// 添加守卫，打印能够整除3的数字
for(i <- 1 to 10 if i % 3 == 0) println(i)

for推导式

  • 将来可以使用for推导式生成一个新的集合（一组数据）

  • 在for循环体中，可以使用yield表达式构建出一个集合，我们把使用yield的for表达式称之为推导式


示例

生成一个10、20、30...100的集合


参考代码

// for推导式：for表达式中以yield开始，该for表达式会构建出一个集合
val v = for(i <- 1 to 10) yield i * 10



while循环

scala中while循环和Java中是一致的


示例

打印1-10的数字


参考代码

scala> var i = 1
i: Int = 1

scala> while(i <= 10) {
     | println(i)
     | i = i+1
     | }


七. break和continue

  • 在scala中，类似Java和C++的break/continue关键字被移除了

  • 如果一定要使用break/continue，就需要使用scala.util.control包的Break类的breable和break方法。




实现break

用法

  • 导入Breaks包import scala.util.control.Breaks._

  • 使用breakable将for表达式包起来

  • for表达式中需要退出循环的地方，添加break()方法调用

示例

使用for表达式打印1-100的数字，如果数字到达50，退出for表达式

参考代码

// 导入scala.util.control包下的Break
import scala.util.control.Breaks._

breakable{
    for(i <- 1 to 100) {
        if(i >= 50) break()
        else println(i)
    }
}



实现continue

用法

continue的实现与break类似，但有一点不同：

[!NOTE]

实现break是用breakable{}将整个for表达式包起来，而实现continue是用breakable{}将for表达式的循环体包含起来就可以了



示例

打印1-100的数字，使用for表达式来遍历，如果数字能整除10，不打印

// 导入scala.util.control包下的Break    
import scala.util.control.Breaks._

for(i <- 1 to 100 ) {
    breakable{
        if(i % 10 == 0) break()
        else println(i)
    }
}



八. 方法

一个类可以有自己的方法，scala中的方法和Java方法类似。但scala与Java定义方法的语法是不一样的。




定义方法

语法

def methodName (参数名:参数类型, 参数名:参数类型) : [return type] = {
    // 方法体：一系列的代码
}


[!NOTE]

  • 参数列表的参数类型不能省略

  • 返回值类型可以省略，由scala编译器自动推断

  • 返回值可以不写return，默认就是{}块表达式的值


示例

  1. 定义一个方法，实现两个整形数值相加，返回相加后的结果

  2. 调用该方法


参考代码

scala> def add(a:Int, b:Int) = a + b
m1: (x: Int, y: Int)Int

scala> add(1,2)
res10: Int = 3



返回值类型推断

scala定义方法可以省略返回值，由scala自动推断返回值类型。这样方法定义后更加简洁。


[!DANGER]

定义递归方法，不能省略返回值类型


示例

定义递归方法（求阶乘）

10 * 9 * 8 * 7 * 6 * ... * 1


参考代码

scala> def m2(x:Int) = {
     | if(x<=1) 1
     | else m2(x-1) * x
     | }
<console>:13: error: recursive method m2 needs result type
       else m2(x-1) * x


九. 方法参数

scala中的方法参数，使用比较灵活。它支持以下几种类型的参数：

  • 默认参数

  • 带名参数

  • 变长参数


默认参数

在定义方法时可以给参数定义一个默认值。


示例

  1. 定义一个计算两个值相加的方法，这两个值默认为0

  2. 调用该方法，不传任何参数


参考代码

// x，y带有默认值为0 
def add(x:Int = 0, y:Int = 0) = x + y
add()



带名参数

在调用方法时，可以指定参数的名称来进行调用。


示例

  1. 定义一个计算两个值相加的方法，这两个值默认为0

  2. 调用该方法，只设置第一个参数的值


参考代码

def add(x:Int = 0, y:Int = 0) = x + y
add(x=1)



变长参数

如果方法的参数是不固定的，可以定义一个方法的参数是变长参数。

语法格式：

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


[!NOTE]

在参数类型后面加一个*号，表示参数可以是0个或者多个



示例

  1. 定义一个计算若干个值相加的方法

  2. 调用方法，传入以下数据：1,2,3,4,5


参考代码

scala> def add(num:Int*) = num.sum
add: (num: Int*)Int

scala> add(1,2,3,4,5)
res1: Int = 15




十. 方法调用方式

在scala中，有以下几种方法调用方式，

  • 后缀调用法

  • 中缀调用法

  • 花括号调用法

  • 无括号调用法

在后续编写spark、flink程序时，我们会使用到这些方法调用方式。



后缀调用法

这种方法与Java没有区别。

语法

对象名.方法名(参数)


示例

使用后缀法Math.abs求绝对值


参考代码

scala> Math.abs(-1)
res3: Int = 1



中缀调用法

语法

对象名 方法名 参数

例如：1 to 10


[!TIP]

如果有多个参数，使用括号括起来


示例

使用中缀法Math.abs求绝对值


scala> Math abs -1
res4: Int = 1


操作符即方法

来看一个表达式

1 + 1

大家觉得上面的表达式像不像方法调用？


在scala中，+ - * / %等这些操作符和Java一样，但在scala中，

  • 所有的操作符都是方法

  • 操作符是一个方法名字是符号的方法




花括号调用法

语法

Math.abs{ 
    // 表达式1
    // 表达式2
}


[!DANGER]

方法只有一个参数，才能使用花括号调用法


示例

使用花括号调用法Math.abs求绝对值

参考代码

scala> Math.abs{-10}
res13: Int = 10




无括号调用法

如果方法没有参数，可以省略方法名后面的括号


示例

  • 定义一个无参数的方法，打印"hello"

  • 使用无括号调用法调用该方法

参考代码

def m3()=println("hello")
m3()


十一. 函数

scala支持函数式编程，将来编写Spark/Flink程序中，会大量使用到函数




定义函数

语法

val 函数变量名 = (参数名:参数类型, 参数名:参数类型....) => 函数体


[!TIP]

  • 函数是一个对象（变量）

  • 类似于方法，函数也有输入参数和返回值

  • 函数定义不需要使用def定义

  • 无需指定返回值类型


示例

  1. 定义一个两个数值相加的函数

  2. 调用该函数


参考代码

scala> val add = (x:Int, y:Int) => x + y
add: (Int, Int) => Int = <function2>

scala> add(1,2)
res3: Int = 3



方法和函数的区别

  • 方法是隶属于类或者对象的，在运行时，它是加载到JVM的方法区中

  • 可以将函数对象赋值给一个变量，在运行时，它是加载到JVM的堆内存中

  • 函数是一个对象，继承自FunctionN，函数对象有apply，curried，toString，tupled这些方法。方法则没有


示例

方法无法赋值给变量

scala> def add(x:Int,y:Int)=x+y
add: (x: Int, y: Int)Int

scala> val a = add
<console>:12: error: missing argument list for method add
Unapplied methods are only converted to functions when a function type is expected.
You can make this conversion explicit by writing `add _` or `add(_,_)` instead of `add`.
       val a = add



方法转换为函数

  • 有时候需要将方法转换为函数，作为变量传递，就需要将方法转换为函数

  • 使用_即可将方法转换为函数


示例

  1. 定义一个方法用来进行两个数相加

  2. 将该方法转换为一个函数，赋值给变量


参考代码

scala> def add(x:Int,y:Int)=x+y
add: (x: Int, y: Int)Int

scala> val a = add _
a: (Int, Int) => Int = <function2>


十二. 数组

scala中数组的概念是和Java类似，可以用数组来存放一组数据。scala中，有两种数组，一种是定长数组，另一种是变长数组




定长数组

  • 定长数组指的是数组的长度是不允许改变的

  • 数组的元素是可以改变的


语法

// 通过指定长度定义数组
val/var 变量名 = new Array[元素类型](数组长度)

// 用元素直接初始化数组
val/var 变量名 = Array(元素1, 元素2, 元素3...)


[!NOTE]

  • 在scala中，数组的泛型使用[]来指定

  • 使用()来获取元素



示例一

  1. 定义一个长度为100的整型数组

  2. 设置第1个元素为110

  3. 打印第1个元素

参考代码

scala> val a = new Array[Int](100)
a: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)

scala> a(0) = 110

scala> println(a(0))
110



示例二

  1. 定义一个包含以下元素的数组

    "java", "scala", "python"

  2. 获取数组长度

参考代码

// 定义包含jave、scala、python三个元素的数组
scala> val a = Array("java", "scala", "python")
a: Array[String] = Array(java, scala, python)

scala> a.length
res17: Int = 3




十三. 变长数组

变长数组指的是数组的长度是可变的，可以往数组中添加、删除元素




定义变长数组

创建变长数组，需要提前导入ArrayBuffer类import scala.collection.mutable.ArrayBuffer


语法

  • 创建空的ArrayBuffer变长数组，语法结构：

    val/var a = ArrayBuffer[元素类型]()

  • 创建带有初始元素的ArrayBuffer

    val/var a = ArrayBuffer(元素1，元素2，元素3....)



示例一

定义一个长度为0的整型变长数组


参考代码

val a = ArrayBuffer[Int]()


示例二

定义一个包含以下元素的变长数组

"hadoop", "storm", "spark"


参考代码

scala> val a = ArrayBuffer("hadoop", "storm", "spark")
a: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer(hadoop, storm, spark)



添加/修改/删除元素

  • 使用+=添加元素

  • 使用-=删除元素

  • 使用++=追加一个数组到变长数组


示例

  1. 定义一个变长数组，包含以下元素: "hadoop", "spark", "flink"

  2. 往该变长数组添加一个"flume"元素

  3. 从该变长数组删除"hadoop"元素

  4. 再将一个数组，该数组包含"hive", "sqoop"追加到变长数组中


参考代码

// 定义变长数组
scala> val a = ArrayBuffer("hadoop", "spark", "flink")
a: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer(hadoop, spark, flink)

// 追加一个元素
scala> a += "flume"
res10: a.type = ArrayBuffer(hadoop, spark, flink, flume)

// 删除一个元素
scala> a -= "hadoop"
res11: a.type = ArrayBuffer(spark, flink, flume)

// 追加一个数组
scala> a ++= Array("hive", "sqoop")
res12: a.type = ArrayBuffer(spark, flink, flume, hive, sqoop)




十四. 遍历数组

可以使用以下两种方式来遍历数组：

  • 使用for表达式直接遍历数组中的元素

  • 使用索引遍历数组中的元素





示例一

  1. 定义一个数组，包含以下元素1,2,3,4,5

  2. 使用for表达式直接遍历，并打印数组的元素


参考代码

scala> val a = Array(1,2,3,4,5)
a: Array[Int] = Array(1, 2, 3, 4, 5)

scala> for(i<-a) println(i)
1
2
3
4
5


示例二

  1. 定义一个数组，包含以下元素1,2,3,4,5

  2. 使用for表达式基于索引下标遍历，并打印数组的元素


参考代码

scala> val a = Array(1,2,3,4,5)
a: Array[Int] = Array(1, 2, 3, 4, 5)

scala> for(i <- 0 to a.length - 1) println(a(i))
1
2
3
4
5

scala> for(i <- 0 until a.length) println(a(i))
1
2
3
4
5



[!NOTE]

0 until n——生成一系列的数字，包含0，不包含n

0 to n ——包含0，也包含n


十五. 数组常用算法

scala中的数组封装了一些常用的计算操作，将来在对数据处理的时候，不需要我们自己再重新实现。以下为常用的几个算法：

  • 求和——sum方法

  • 求最大值——max方法

  • 求最小值——min方法

  • 排序——sorted方法




求和

数组中的sum方法可以将所有的元素进行累加，然后得到结果


示例

  1. 定义一个数组，包含以下几个元素（1,2,3,4)

  2. 请计算该数组的和


参考代码

scala> val a = Array(1,2,3,4)
a: Array[Int] = Array(1, 2, 3, 4)

scala> a.sum
res49: Int = 10



最大值

数组中的max方法，可以获取到数组中的最大的那个元素值


示例

  1. 定义一个数组，包含以下几个元素（4,1,2,4,10）

  2. 获取数组的最大值


参考代码

scala> val a = Array(4,1,2,4,10)
a: Array[Int] = Array(4, 1, 2, 4, 10)

scala> a.max
res50: Int = 10



最小值

数组的min方法，可以获取到数组中最小的那个元素值


示例

  1. 定义一个数组，包含以下几个元素（4,1,2,4,10）

  2. 获取数组的最小值


参考代码

scala> val a = Array(4,1,2,4,10)
a: Array[Int] = Array(4, 1, 2, 4, 10)

scala> a.min
res51: Int = 1



排序

数组的sorted方法，可以对数组进行升序排序。而reverse方法，可以将数组进行反转，从而实现降序排序


示例

  1. 定义一个数组，包含以下几个元素（4,1,2,4,10）

  2. 对数组进行升序排序、降序排序


参考代码

// 升序排序
scala> a.sorted
res53: Array[Int] = Array(1, 2, 4, 4, 10)

// 降序
scala> a.sorted.reverse
res56: Array[Int] = Array(10, 4, 4, 2, 1)


以上是关于Scala基本使用的主要内容，如果未能解决你的问题，请参考以下文章

为什么Scala是可扩展的？

初学scala4——trait混入

如何在 Scala 中使用 java.String.format？

html PHP代码片段： - AJAX基本示例：此代码演示了使用PHP和JavaScript实现的基本AJAX功能。

Scala的面向对象与函数编程

基本目录中缺少 build.scala