Scala面试问题

📌 相关文章

📜 Scala面试问题

📅 最后修改于: 2021-01-09 12:22:54 🧑 作者: Mango

1)什么是Scala?

Scala是一种通用编程语言。它支持面向对象，功能和命令式编程方法。它是一种强大的静态类型语言。在Scala中，无论是函数还是数字，一切都是对象。它是由Martin Odersky在2004年设计的。

Scala程序示例

object MainObject{
    def main(args:Array[String]){
        print("Hello Scala")
    }
}

有关更多信息：单击此处。

2)Scala的功能是什么?

Scala具有以下功能：

类型推断：在Scala中，您不需要明确提及数据类型和函数返回类型。
单例对象： Scala使用单例对象，该对象本质上是类，在源文件中只有一个对象。
不变性： Scala使用不变性概念。不变的数据有助于管理需要管理数据的并发控制。
惰性计算：在Scala中，默认情况下计算是惰性的。您可以使用lazy关键字声明一个惰性变量。它用于提高性能。
案例类和模式匹配：在Scala中，案例类支持模式匹配。因此，您可以编写更多的逻辑代码。
并发控制： Scala提供了一个包含参与者模型的标准库。您可以使用actor编写并发代码。
字符串插值：在Scala中，字符串插值允许用户将变量引用直接嵌入处理后的字符串字面量。
高阶函数：在Scala中，高阶函数允许您创建函数组合，lambda函数或匿名函数等。
特性：特征就像具有部分实现的接口。在Scala中，特征是抽象和非抽象方法的集合。
丰富的集合集： Scala提供了丰富的集合库。它包含用于收集数据的类和特征。这些集合可以是可变的或不可变的。

有关更多信息：单击此处。

3)Scala中的数据类型是什么?

Scala中的数据类型在存储和长度方面与Java非常相似，不同之处在于，在Scala中没有原始数据类型的概念，每种类型都是对象，并以大写字母开头。数据类型表如下。

Scala中的数据类型

Data Type	Default Value	Size
Boolean	False	True or false
Byte	0	8 bit signed value (-2⁷ to 2⁷-1)
Short	0	16 bit signed value(-2¹⁵ to 2¹⁵-1)
Char	‘\u0000’	16 bit unsigned Unicode character(0 to 2¹⁶-1)
Int	0	32 bit signed value(-2³¹ to 2³¹-1)
Long	0L	64 bit signed value(-2⁶³ to 2⁶³-1)
Float	0.0F	32 bit IEEE 754 single-precision float
Double	0.0D	64 bit IEEE 754 double-precision float
String	Null	A sequence of characters

有关更多信息：单击此处。

4)什么是模式匹配?

模式匹配是Scala的功能。它与其他语言的开关盒相同。它与模式中可用的最佳情况相匹配。

例

object MainObject {
   def main(args: Array[String]) {
        var a = 1
        a match{
            case 1 => println("One")
            case 2 => println("Two")
            case _ => println("No")
        }
        }
}

有关更多信息：单击此处。

5)什么是对Scala的理解?

在Scala中，for循环称为for-comprehension。它可用于迭代，过滤和返回迭代的集合。在命令式语言中，for理解有点像for循环，只是它构造了所有迭代结果的列表。

例

object MainObject {
   def main(args: Array[String]) {
        for( a <- 1 to 10 ){
         println(a);
      }
   }
}

有关更多信息：单击此处。

6)Scala中的易碎方法是什么?

在Scala中，没有break语句，但是您可以通过使用break方法并导入Scala.util.control.Breaks._包来实现。它可能会破坏您的代码。

例

import scala.util.control.Breaks._                    // Importing  package
object MainObject {
   def main(args: Array[String]) {
        breakable {                                 // Breakable method to avoid exception
            for(i<-1 to 10 by 2){
                if(i==7) 
                    break                            // Break used here
                else
                    println(i)
            }
        }
    }
}

有关更多信息：单击此处。

7)如何在Scala中声明一个函数?

在Scala中，函数是一等值。您可以存储函数值，将函数作为参数传递，并将函数作为其他函数的值返回。您可以使用def关键字创建一个函数。必须提到的参数，返回类型，同时定义一个函数，并返回类型的函数是可选的。如果未指定函数的返回类型，则默认返回类型为Unit。

Scala函数声明语法

def functionName(parameters : typeofparameters) : returntypeoffunction = {
// statements to be executed
}

有关更多信息：单击此处。

8)为什么在Scala函数使用=(等于)运算符?

您可以创建带有或不带有=(等于)运算符的函数。如果使用它，该函数将返回值。如果不使用它，您的函数将不会返回任何内容，并且将像子例程一样工作。

例

object MainObject {
   def main(args: Array[String]) {
        var result = functionExample()         // Calling function
        println(result)
    }
    def functionExample() = {            // Defining a function
          var a = 10
          a
    }
}

有关更多信息：单击此处。

9)Scala中具有默认值的Function参数是什么?

Scala提供了为功能参数分配默认值的函数。在函数调用期间不传递值的情况下，它会很有帮助。它使用参数的默认值。

例

object MainObject {
   def main(args: Array[String]) = {
        var result1 = functionExample(15,2)     // Calling with two values
        var result2 = functionExample(15)    // Calling with one value
        var result3 = functionExample()        // Calling without any value
        println(result1+"\n"+result2+"\n"+result3)
    }
    def functionExample(a:Int = 0, b:Int = 0):Int = {    // Parameters with default values as 0
        a+b
    }
}

有关更多信息：单击此处。

10)在Scala中一个名为参数的函数是什么?

在Scala函数，可以在调用函数时指定参数的名称。您可以以任何顺序传递命名参数，也可以仅传递值。

例

object MainObject {
   def main(args: Array[String]) = {
        var result1 = functionExample(a = 15, b = 2)    // Parameters names are passed during call
        var result2 = functionExample(b = 15, a = 2)    // Parameters order have changed during call
        var result3 = functionExample(15,2)             // Only values are passed during call
        println(result1+"\n"+result2+"\n"+result3)
    }
    def functionExample(a:Int, b:Int):Int = {
        a+b
    }
}

有关更多信息：单击此处。

11)Scala中的高阶函数是什么?

高阶函数是一个函数，或者需要一个函数作为参数或返回的函数。换句话说，我们可以说这与函数工作的函数称为高阶函数。

例

object MainObject {
   def main(args: Array[String]) = {
     functionExample(25, multiplyBy2)                      // Passing a function as parameter
    }
    def functionExample(a:Int, f:Int=>AnyVal):Unit = {
        println(f(a))                                   // Calling that function 
    }
    def multiplyBy2(a:Int):Int = {
        a*2
    }
}

有关更多信息：单击此处。

12)Scala中的函数组成是什么?

在Scala中，功能可以由其他功能组成。这是一个组合过程，其中一个函数代表两个组合函数的应用。

例

object MainObject {
   def main(args: Array[String]) = {
     var result = multiplyBy2(add2(10))      // Function composition
     println(result)
    }
    def add2(a:Int):Int = {
        a+2
    }
    
    def multiplyBy2(a:Int):Int = {
        a*2
    }
}

有关更多信息：单击此处。

13)Scala中的匿名(lambda)函数是什么?

匿名函数是没有名称的函数，但可以用作函数。当您不想以后再使用它时，最好创建一个匿名函数。您可以在Scala中使用⇒(火箭)或_(下划线)通配符来创建匿名函数。

例

object MainObject {
   def main(args: Array[String]) = {
     var result1 = (a:Int, b:Int) => a+b        // Anonymous function by using => (rocket)
     var result2 = (_:Int)+(_:Int)              // Anonymous function by using _ (underscore) wild card
     println(result1(10,10))
     println(result2(10,10))
    }
}

有关更多信息：单击此处。

14)Scala中的多行表达式是什么?

用多行编写的表达式称为多行表达式。在Scala中，使用多行表达式时要小心。

例

def add1(a:Int, b:Int) = {
        a
        +b
    }

上面的程序不评估完整的表达式，并在此处返回b。

有关更多信息：单击此处。

15)Scala中的函数是什么?

在Scala中，该方法可能具有多个参数列表。当一个方法被调用以较少的参数列表中，这将产生一个函数取缺少参数列表作为参数。

例

object MainObject {
    def add(a:Int)(b:Int) = {
        a+b
    }
    def main(args: Array[String]) = {
        var result = add(10)(10)
        println("10 + 10 = "+result)
        var addIt = add(10)_
        var result2 = addIt(3)
        println("10 + 3 = "+result2)
    }
}

有关更多信息：单击此处。

16)Scala中的下一步函数是什么?

在Scala中，您可以定义可变长度参数的函数。它允许您在调用函数时传递任意数量的参数。

例

object MainObject {
    def add(a:Int, b:Int, c:Int) = {
        def add2(x:Int,y:Int) = {
            x+y
        }
        add2(a,add2(b,c))
    }
    def main(args: Array[String]) = {
        var result = add(10,10,10)
        println(result)
    }
}

有关更多信息：单击此处。

17)Scala中的对象是什么?

该对象是真实世界的实体。它包含状态和行为。笔记本电脑，汽车，手机是现实世界中的对象。一个对象通常具有两个特征：

1)状态：对象的数据值称为其状态。

2)行为：对象执行的功能称为其行为。

Scala中的对象是类的实例。也称为运行时实体。

有关更多信息：单击此处。

18)Scala中的一门课是什么?

该类是模板或蓝图。也称为相似类型的对象的集合。

在Scala中，一个类可以包含：

数据成员
会员方法
建设者
块
嵌套类
超类信息等

例

class Student{
    var id:Int = 0;                            // All fields must be initialized
    var name:String = null;
}
object MainObject{
    def main(args:Array[String]){
        var s = new Student()                // Creating an object
        println(s.id+" "+s.name);
    }
}

有关更多信息：单击此处。

19)什么是Scala中的匿名对象?

在Scala中，您可以创建一个匿名对象。没有引用名称的对象称为匿名对象。当您不想进一步重用匿名对象时，最好创建一个匿名对象。

例

class Arithmetic{
    def add(a:Int, b:Int){
        var add = a+b;
        println("sum = "+add);
    }
}

object MainObject{
    def main(args:Array[String]){
        new Arithmetic().add(10,10);

    }
}

有关更多信息：单击此处。

20)Scala中的构造函数是什么?

在Scala中，构造函数不是一种特殊的方法。 Scala提供主要的和任意数量的辅助构造函数。也称为默认构造函数。

在Scala中，如果不指定主构造函数，则编译器会创建一个默认的主构造函数。类主体的所有语句均视为构造函数的一部分。

Scala主要构造函数示例

class Student(id:Int, name:String){
    def showDetails(){
        println(id+" "+name);
    }
}

object MainObject{
    def main(args:Array[String]){
        var s = new Student(101,"Rama");
        s.showDetails()
    }
}

有关更多信息：单击此处。

21)什么是Scala中的方法重载?

Scala提供了方法重载功能，该功能使我们可以定义相同名称但具有不同参数或数据类型的方法。它有助于优化代码。您可以通过使用不同的参数列表或不同类型的参数来实现方法重载。

例

class Arithmetic{
    def add(a:Int, b:Int){
        var sum = a+b
        println(sum)
    }
    def add(a:Int, b:Int, c:Int){
        var sum = a+b+c
        println(sum)
    }
}

object MainObject{
    def main(args:Array[String]){
        var a  = new Arithmetic();
        a.add(10,10);
        a.add(10,10,10);
    }
}

有关更多信息：单击此处。

22)这在Scala中是什么?

在Scala中，这是一个关键字，用于引用当前对象。您可以使用此关键字调用实例变量，方法，构造函数。

例

class ThisExample{
    var id:Int = 0
    var name: String = ""
    def this(id:Int, name:String){
        this()
        this.id = id
        this.name = name
    }
    def show(){
        println(id+" "+name)
    }
}

object MainObject{
    def main(args:Array[String]){
        var t = new ThisExample(101,"Martin")
        t.show()
    }
}

有关更多信息：单击此处。

23)什么是继承?

继承是一个面向对象的概念，用于代码的可重用性。您可以使用extends关键字实现继承。为了实现继承，一个类必须扩展到其他类。扩展的类称为父类或父类。扩展类的类称为派生类或基类。

例

class Employee{
    var salary:Float = 10000
}

class Programmer extends Employee{
    var bonus:Int = 5000
    println("Salary = "+salary)
    println("Bonus = "+bonus)
}

object MainObject{
    def main(args:Array[String]){
        new Programmer()
    }
}

有关更多信息：单击此处。

24)在Scala中什么是方法重写?

当子类具有与父类中定义的相同的名称方法时，则称为方法覆盖。当子类想要为父类中定义的方法提供特定的实现时，它将覆盖父类中的方法。

在Scala中，您必须使用override关键字或override批注来覆盖父类中的方法。

例

class Vehicle{
    def run(){
        println("vehicle is running")
    }
}

class Bike extends Vehicle{
     override def run(){
        println("Bike is running")
    }
}

object MainObject{
    def main(args:Array[String]){
        var b = new Bike()
        b.run()
    }
}

有关更多信息：单击此处。

25)Scala中的final是什么?

Scala中的Final关键字用于防止将超类成员继承到派生类中。您也可以声明最终变量，方法和类。

Scala最终变量示例

class Vehicle{
     final val speed:Int = 60
}
class Bike extends Vehicle{
   override val speed:Int = 100
    def show(){
        println(speed)
    }
}

object MainObject{
    def main(args:Array[String]){
        var b = new Bike()
        b.show()
    }
}

有关更多信息：单击此处。

26)Scala的最后一堂课是什么?

在Scala中，您可以使用final关键字创建一个最终类。最终类不能被继承。如果您将课程定为最终课程，则无法进一步扩展。

Scala决赛课程示例

final class Vehicle{
     def show(){
         println("vehicle is running")
     }

}

class Bike extends Vehicle{
       override def show(){
        println("bike is running")
    }
}

object MainObject{
    def main(args:Array[String]){
        var b = new Bike()
        b.show()
    }
}

有关更多信息：单击此处。

27)Scala中的抽象类是什么?

用abstract关键字声明的类称为抽象类。抽象类也可以具有抽象方法和非抽象方法。抽象类用于实现抽象。

例

abstract class Bike{
    def run()
}

class Hero extends Bike{
    def run(){
        println("running fine...")
    }
}

object MainObject{
    def main(args: Array[String]){
        var h = new Hero()
        h.run()
    }
}

有关更多信息：单击此处。

28)什么是Scala特性?

特征就像具有部分实现的接口。在Scala中，特征是抽象和非抽象方法的集合。您可以创建一个特征，该特征可以具有所有抽象方法，也可以具有某些抽象和一些非抽象方法。

例

trait Printable{
    def print()
}

class A4 extends Printable{
    def print(){
        println("Hello")
    }
}

object MainObject{
    def main(args:Array[String]){
        var a = new A4()
        a.print()
    }
}

有关更多信息：单击此处。

29)Scala中的特征mixins是什么?

在Scala中，“特征混合”是指您可以使用类或抽象类扩展任意数量的特征。您只能扩展特征或特征与类的组合或特征与抽象类的组合。

必须保持mixin的顺序，否则编译器将引发错误。

例

trait Print{
    def print()
}

abstract class PrintA4{
    def printA4()
}

class A6 extends PrintA4 {
    def print(){                                // Trait print
        println("print sheet")
    }
    def printA4(){                              // Abstract class printA4
        println("Print A4 Sheet")
    }
}

object MainObject{
    def main(args:Array[String]){
        var a = new A6() with Print                // You can also extend trait during object creation
        a.print()
        a.printA4()
    }
}

有关更多信息：单击此处。

30)Scala中的访问修饰符是什么?

访问修饰符用于定义数据和我们的代码对外界的可访问性。您可以可访问地应用于类，特征，数据成员，成员方法和构造函数等。Scala提供了对所有对象的访问性最少的访问。您可以根据需要将任何访问修饰符应用于代码。

在Scala中，只有三种类型的访问修饰符。

没有修饰符
受保护的
私人的

有关更多信息：单击此处

31)Scala中的数组是什么?

在Scala中，数组是可变值的组合。它是基于索引的数据结构。它从0索引开始到n-1，其中n是数组的长度。

Scala数组可以是通用的。这意味着，您可以拥有Array [T]，其中T是类型参数或抽象类型。 Scala数组与Scala序列兼容-您可以在需要Seq [T]的地方传递Array [T]。 Scala数组还支持所有序列操作。

例

class ArrayExample{
    var arr = Array(1,2,3,4,5)         // Creating single dimensional array
    def show(){
        for(a<-arr)                        // Traversing array elements
            println(a)
        println("Third Element  = "+ arr(2))        // Accessing elements by using index
    }
}

object MainObject{
    def main(args:Array[String]){
        var a = new ArrayExample()
        a.show()
    }
}

有关更多信息：单击此处。

32)Scala中的ofDim方法是什么?

Scala提供了ofDim方法来创建多维数组。多维数组是一个以矩阵形式存储数据的数组。您可以根据需要创建二维到三个，四个或更多维的数组。

例

class ArrayExample{
    var arr = Array.ofDim[Int](2,2)           // Creating multidimensional array
    arr(1)(0) = 15                             // Assigning value
    def show(){
        for(i<- 0 to 1){                       // Traversing elements by using loop
           for(j<- 0 to 1){
                print(" "+arr(i)(j))
            }
            println()
        }
        println("Third Element = "+ arr(1)(1))        // Accessing elements by using index
    }
}

object MainObject{
    def main(args:Array[String]){
        var a = new ArrayExample()
        a.show()                     
    }
}

有关更多信息：单击此处。

33)Scala中的String是什么?

在Scala中，字符串是字符的组合，或者我们可以说它是字符序列。它是基于索引的数据结构，并使用线性方法将数据存储到内存中。字符串在Scala中像Java一样是不可变的。

例

class StringExample{
    var s1 = "Scala string example"
    def show(){
        println(s1)
    }
}

object MainObject{
    def main(args:Array[String]){
        var s = new StringExample()
        s.show()
    }
}

有关更多信息：单击此处。

34)什么是Scala中的字符串插值?

从Scala 2.10.0开始，Scala提供了一种从数据创建字符串的新机制。这称为字符串插值。字符串插值允许用户将变量引用直接嵌入处理后的字符串字面量。 Scala提供了三种字符串插值方法：s，f和raw。

例

class StringExample{
    var pi = 3.14
    def show(){
        println(s"value of pi = $pi")
    }
}

object MainObject{
    def main(args:Array[String]){
        var s = new StringExample()
        s.show()
    }
}

有关更多信息：单击此处。

35)Scala字符串插值中的s方法是什么?

字符串插值的s方法允许我们在字符串对象中传递变量。您不需要使用+运算符来格式化输出字符串。该变量由编译器求值并由值替换。

例

class StringExample{
    var s1 = "Scala string example"
    def show(){
        println(s"This is $s1")
    }
}

object MainObject{
    def main(args:Array[String]){
        var s = new StringExample()
        s.show()
    }
}

有关更多信息：单击此处。

36)Scala字符串插值中的f方法是什么?

f方法用于格式化字符串输出。就像C语言的printf函数，用于产生格式化输出。您可以在打印函数传递任何类型的变量。

例

class StringExample{
    var s1 = "Scala string example"
    var version = 2.12
    def show(){
        println(f"This is $s1%s, scala version is $version%2.2f")
    }
}


object MainObject{
    def main(args:Array[String]){
        var s = new StringExample()
        s.show()
    }
}

有关更多信息：单击此处。

37)Scala字符串插值中的原始方法是什么?

字符串插值的原始方法用于生成原始字符串。它不解释字符串存在的特殊字符。

例

class StringExample{
    var s1 = "Scala \tstring \nexample"    
    var s2 = raw"Scala \tstring \nexample"    
    def show(){
        println(s1)
        println(s2)
    }
}

object MainObject{
    def main(args:Array[String]){
        var s = new StringExample()
        s.show()
    }
}

有关更多信息：单击此处。

38)什么是Scala中的异常处理?

异常处理是一种用于处理异常情况的机制。您还可以避免程序意外终止。

Scala使“已检查与未检查”变得非常简单。它没有检查的异常。在Scala中，所有异常都未经检查，甚至是SQLException和IOException。

例

class ExceptionExample{
    def divide(a:Int, b:Int) = {
            a/b                // Exception occurred here
        println("Rest of the code is executing...")
    }
}
object MainObject{
    def main(args:Array[String]){
        var e = new ExceptionExample()
        e.divide(100,0)
 
    }
}

有关更多信息：单击此处。

39)在Scala中什么是尝试捕获?

Scala提供了try and catch块来处理异常。 try块用于封装可疑代码。 catch块用于处理try块中发生的异常。根据需要，您的程序中可以包含任意数量的try-catch块。

例

在此示例中，我们的catch处理程序中有两种情况。第一种情况将仅处理算术类型异常。第二种情况是Throwable类，它是异常层次结构中的超类。第二种情况可以处理程序中的任何类型的异常。有时，当您不知道异常的类型时，可以使用超类。

class ExceptionExample{
    def divide(a:Int, b:Int) = {
        try{
            a/b
            var arr = Array(1,2)
            arr(10)
        }catch{
            case e: ArithmeticException => println(e)
            case ex: Throwable =>println("found a unknown exception"+ ex)
        }
        println("Rest of the code is executing...")
    }
}
object MainObject{
    def main(args:Array[String]){
        var e = new ExceptionExample()
        e.divide(100,10)
 
    }
}

有关更多信息：单击此处。

40)Scala的最终结果是什么?

finally块用于在异常期间释放资源。资源可以是文件，网络连接，数据库连接等。可以保证finally块的执行。

例

class ExceptionExample{
    def divide(a:Int, b:Int) = {
        try{
            a/b
            var arr = Array(1,2)
            arr(10)
        }catch{
            case e: ArithmeticException => println(e)
            case ex: Exception =>println(ex)
            case th: Throwable=>println("found a unknown exception"+th)
        }
        finally{
            println("Finaly block always executes")
        }
        println("Rest of the code is executing...")
    }
}
object MainObject{
    def main(args:Array[String]){
        var e = new ExceptionExample()
        e.divide(100,10)
 
    }
}

有关更多信息：单击此处。

41)Scala会抛出什么?

您可以在代码中显式引发异常。 Scala提供了throw关键字来引发异常。 throw关键字主要用于引发自定义异常。

例

class ExceptionExample2{
    def validate(age:Int)={
        if(age<18)
            throw new ArithmeticException("You are not eligible")
        else println("You are eligible")
    }
}

object MainObject{
    def main(args:Array[String]){
        var e = new ExceptionExample2()
        e.validate(10)
 
    }
}

有关更多信息：单击此处。

42)什么是Scala中的异常传播?

在Scala中，您可以在调用链中传播异常。当任何函数发生异常时，它将查找处理程序。如果那里没有处理程序，它将转发到调用方方法并在那里寻找处理程序。如果处理程序存在，处理程序将捕获该异常。如果处理程序不存在，它将移至调用链中的下一个调用方方法。这整个过程称为异常传播。

43)Scala中有哪些抛出?

Scala提供了throws关键字来声明异常。您可以使用方法定义声明异常。它向调用方函数提供此方法可能引发此异常的信息。它有助于调用者函数处理该代码并将其封装在try-catch块中，以避免程序异常终止。在Scala中，您可以使用throws关键字或throws注释来声明异常。

例

class ExceptionExample4{
    @throws(classOf[NumberFormatException])
    def validate()={
        "abc".toInt
    }
}

object MainObject{
    def main(args:Array[String]){
        var e = new ExceptionExample4()
        try{
            e.validate()
        }catch{
            case ex : NumberFormatException => println("Exception handeled here")
        }
        println("Rest of the code executing...")
    }
}

有关更多信息：单击此处。

44)Scala中的自定义异常是什么?

在Scala中，您可以创建例外。也称为自定义例外。在声明自定义异常类时，必须将Exception类扩展到。您可以在自定义类中创建消息。

例

class InvalidAgeException(s:String) extends Exception(s){}
class ExceptionExample{
    @throws(classOf[InvalidAgeException])
    def validate(age:Int){
        if(age<18){
            throw new InvalidAgeException("Not eligible")
        }else{
            println("You are eligible")
        }
    }
}
object MainObject{
    def main(args:Array[String]){
        var e = new ExceptionExample()
        try{
            e.validate(5)
        }catch{
            case e : Exception => println("Exception Occured : "+e)
        }
    }
}

有关更多信息：单击此处。

45)Scala中的收藏是什么?

Scala提供了一组丰富的集合库。它包含用于收集数据的类和特征。这些集合可以是可变的或不可变的。您可以根据需要使用它们。

有关更多信息：单击此处。

46)Scala集合中可遍历的是什么?

它是一个特征，用于遍历集合元素。它是所有Scala集合的基本特征。它包含所有集合通用的方法。

有关更多信息：单击此处。

47)在Scala集合中设置什么?

它用于在集合中存储唯一元素。它不维护任何存储元素的顺序。您可以对它们执行各种操作。它在Scala.collection.immutable包中定义。

例

在此示例中，我们创建了一个集合。您也可以创建一个空集。让我们看看如何创建一个集合。

import scala.collection.immutable._
object MainObject{
    def main(args:Array[String]){
        val set1 = Set()                            // An empty set
        val games = Set("Cricket","Football","Hocky","Golf")     // Creating a set with elements
        println(set1)
        println(games)
    }
}

有关更多信息：单击此处。

48)Scala集合中的SortedSet是什么?

在Scala中，SortedSet扩展了Set trait并提供了已排序的set元素。当您要对Set集合中的元素进行排序时，此功能很有用。您还可以对整数值和字符串进行排序。

它是一个特征，您可以应用在可遍历特征和Set特征中定义的所有方法。

例

import scala.collection.immutable.SortedSet            
object MainObject{
    def main(args:Array[String]){
        var numbers: SortedSet[Int] = SortedSet(5,8,1,2,9,6,4,7,2)
        numbers.foreach((element:Int)=> println(element))
    }   
}

有关更多信息：单击此处。

49)Scala集合中的HashSet是什么?

HashSet是一个密封的类。它扩展了AbstractSet和不可变的Set特性。它使用哈希码存储元素。它既不保持插入顺序也不对元素进行排序。

例

import scala.collection.immutable.HashSet
object MainObject{
    def main(args:Array[String]){
        var hashset = HashSet(4,2,8,0,6,3,45)
        hashset.foreach((element:Int) => println(element+" "))   
   }
}

有关更多信息：单击此处。

50)Scala中的BitSet是什么?

位集是一组非负整数，它们表示为打包为64位字的位的可变大小数组。存储在其中的最大数字确定位集的内存占用量。它扩展了Set特质。

例

import scala.collection.immutable._
object MainObject{
    def main(args:Array[String]){
        var numbers = BitSet(1,5,8,6,9,0)
        numbers.foreach((element:Int) => println(element))
    }
}

有关更多信息：单击此处。

51)Scala集合中的ListSet是什么?

在Scala中，ListSet类使用基于列表的数据结构实现不可变集。在ListSet中，类元素以相反的插入顺序在内部存储，这意味着最新元素位于列表的开头。该集合仅适用于少量元素。它保持插入顺序。

例

import scala.collection.immutable._
object MainObject{
    def main(args:Array[String]){
        var listset = ListSet(4,2,8,0,6,3,45)
        listset.foreach((element:Int) => println(element+" "))
    }
}

有关更多信息：单击此处。

52)Scala集合中的Seq是什么?

Seq是一个特征，代表可以保证不变的索引序列。您可以使用元素索引来访问元素。它保持元素的插入顺序。

序列支持许多方法来查找元素或子序列的出现。它返回一个列表。

例

import scala.collection.immutable._
object MainObject{
    def main(args:Array[String]){
        var seq:Seq[Int] = Seq(52,85,1,8,3,2,7)
        seq.foreach((element:Int) => print(element+" "))
        println("\nAccessing element by using index")
        println(seq(2))
    }
}

有关更多信息：单击此处。

53)Scala集合中的Vector是什么?

向量是一种通用的，不变的数据结构。它提供元素的随机访问。它适用于大量元素。

它扩展了抽象类AbstractSeq和IndexedSeq特质。

例

import scala.collection.immutable._
object MainObject{
    def main(args:Array[String]){
        var vector:Vector[Int] = Vector(5,8,3,6,9,4) //Or
        var vector2 = Vector(5,2,6,3)
        var vector3 = Vector.empty
        println(vector)
        println(vector2)
        println(vector3)
    }
}

有关更多信息：单击此处。

54)Scala集合中的列表是什么?

该列表用于存储有序元素。它扩展了LinearSeq特征。这是不可变链表的类。此类对于后进先出(LIFO)，类似堆栈的访问模式很有用。它保持顺序，可以包含重复元素。

例

import scala.collection.immutable._
object MainObject{
    def main(args:Array[String]){
       var list = List(1,8,5,6,9,58,23,15,4)
        var list2:List[Int] = List(1,8,5,6,9,58,23,15,4)
        println(list)
        println(list2)
    }
}

有关更多信息：单击此处。

55)Scala集合中的队列是什么?

队列实现了一种数据结构，该结构允许以先进先出(FIFO)的方式插入和检索元素。

在Scala中，队列被实现为一对列表。一种用于插入元素，第二种用于包含已删除的元素。元素将添加到第一个列表中，并从第二个列表中删除。

例

import scala.collection.immutable._
object MainObject{
    def main(args:Array[String]){
        var queue = Queue(1,5,6,2,3,9,5,2,5)
        var queue2:Queue[Int] = Queue(1,5,6,2,3,9,5,2,5)
        println(queue)  
        println(queue2)
    }
}

有关更多信息：单击此处。

56)Scala中的流是什么?

流是一个惰性列表。它仅在需要时评估元素。这是Scala的功能。 Scala支持延迟计算。它可以提高程序的性能。

例

object MainObject{
    def main(args:Array[String]){
        val stream = 100 #:: 200 #:: 85 #:: Stream.empty
        println(stream)
    }
}

有关更多信息：单击此处。

57)Scala Collection中的Map有什么功能?

该地图用于存储元素。它以键和值对的形式存储元素。在Scala中，您可以创建一个地图，通过使用两种方式或者通过使用逗号分隔成对或使用火箭运算符。

例

object MainObject{
    def main(args:Array[String]){
        var map = Map(("A","Apple"),("B","Ball"))
        var map2 = Map("A"->"Aple","B"->"Ball")
        var emptyMap:Map[String,String] = Map.empty[String,String] 
        println(map)
        println(map2)
        println("Empty Map: "+emptyMap)
    }
}

有关更多信息：单击此处。

58)Scala中的ListMap是什么?

此类通过使用基于列表的数据结构实现不可变的映射。您可以通过调用其构造函数或使用ListMap.empty方法来创建空的ListMap。它保持插入顺序并返回ListMap。此系列适合小物件。

例

import scala.collection.immutable._
object MainObject{
    def main(args:Array[String]){
        var listMap = ListMap("Rice"->"100","Wheat"->"50","Gram"->"500")    // Creating listmap with elements
        var emptyListMap = new ListMap()            // Creating an empty list map
        var emptyListMap2 = ListMap.empty           // Creating an empty list map
        println(listMap)
        println(emptyListMap)
        println(emptyListMap2)
    }
}

有关更多信息：单击此处。

59)Scala中的元组是什么?

元组是有序形式的元素的集合。如果不存在任何元素，则称为空元组。您可以使用元组来存储任何数据。您可以存储类似类型的混合类型数据。您可以通过使用元组in函数返回多个值。

例

object MainObject{
    def main(args:Array[String]){
        var tuple = (1,5,8,6,4)                     // Tuple of integer values
        var tuple2 = ("Apple","Banana","Gavava")        // Tuple of string values
        var tuple3 = (2.5,8.4,10.50)                // Tuple of float values
        var tuple4 = (1,2.5,"India")                // Tuple of mix type values
        println(tuple)
        println(tuple2)
        println(tuple3)
        println(tuple4)
    }
}

有关更多信息：单击此处。

60)Scala中的单例对象是什么?

单例对象是通过使用object关键字而不是通过类声明的对象。调用单例对象内部声明的方法不需要任何对象。

在Scala中，没有静态概念。因此，Scala创建一个单例对象以为您的程序执行提供入口点。

例

object Singleton{
    def main(args:Array[String]){
        SingletonObject.hello()         // No need to create object.
    }
}
object SingletonObject{
    def hello(){
        println("Hello, This is Singleton Object")
    }
}

有关更多信息：单击此处。

61)什么是Scala中的伴随对象?

在Scala中，当您拥有与单例对象同名的类时，该类称为伴随类，而单例对象称为伴随对象。伴随类及其伴随对象都必须在同一源文件中定义。

例

class ComapanionClass{
    def hello(){
        println("Hello, this is Companion Class.")
    }
}
object CompanoinObject{
    def main(args:Array[String]){
        new ComapanionClass().hello()
        println("And this is Companion Object.")
    }
}

有关更多信息：单击此处。

62)Scala中的案例类是什么?

Scala case类只是常规类，默认情况下是不变的，并且可以通过模式匹配将其分解。它使用equal方法在结构上比较实例。它不使用new关键字实例化该对象。

例

case class CaseClass(a:Int, b:Int)

object MainObject{
    def main(args:Array[String]){
        var c =  CaseClass(10,10)       // Creating object of case class
        println("a = "+c.a)               // Accessing elements of case class
        println("b = "+c.b)
    }
}

有关更多信息：单击此处。

63)Scala中的文件处理是什么?

文件处理是一种用于处理文件操作的机制。 Scala提供了预定义的方法来处理文件。您可以创建，打开，写入和读取文件。 Scala提供了一个完整的软件包scala.io用于文件处理。

例

import scala.io.Source
object MainObject{
  def main(args:Array[String]){
    val filename = "ScalaFile.txt"
    val fileSource = Source.fromFile(filename)
    for(line<-fileSource.getLines){
      println(line)
    }
    fileSource.close()
  }
}

有关更多信息：单击此处。