在Scala中List| 关于Scala列表的完整教程

Scala | 列表

Scala中的List是一个集合，以喜欢列表的形式存储数据。该列表是一个不可变的集合，这意味着创建列表后不能更改列表的元素。列表具有灵活的数据类型，即它们可以存储多种数据类型的元素。

例：

// 这是Scala中的有效列表
List(34, "Nhooo.com", 12.42)

Scala还允许其程序员使用在scala.collection.mutable包中定义的ListBuffer类创建一个可变列表，即可变列表。有许多为List定义的实用程序方法，以帮助Scala中的List正常运行。

在Scala中定义列表：

有多种语法可用于在Scala中定义列表。让我们看看他们每个人，

方法1：

val list_name: List[type] = List(element1, element2, element3...)

使用此方法声明的列表将具有相同数据类型的所有元素。

方法2：

val list_name = List(element1, element2, element3...)

Scala中的列表示例

让我们探索Scala中的一些有效列表，

• 空列表，

  List()

• 相同类型的值列表，

  List(3, 65, 12, 1451, 99)

• 多种类型的值列表，

  List(1013, "Maths", 97.8)

• 二维列表，即ListofList，

  List(List(123, 41341), List(1, 46))

这些是Scala中各种类型的List。现在，让我们开始一些操作并创建一个列表。

程序1：在Scala中创建数字列表的程序。

object MyClass {
    def main(args: Array[String]) {
        // 创建整数值列表 
        val number_list : List[Integer] = List(10, 25, 17, 93, 77)
        
        // 打印列表 
        println("数字列表是 "+ number_list)
    }
}

输出：

数字列表是 List(10, 25, 17, 93, 77)

程序2：创建二维混合列表的程序。

object MyClass {
    def main(args: Array[String]) {
        // 建立2D列表  
        val list_2d = List(List(1, "C++", 1979), List(2, "JavaScript", 1995), List(3, "Scala", 2004))

        // 打印列表 
        println("带有编程语言发明日期的2D列表是 "+ list_2d)
    }
}

输出：

带有编程语言发明日期的2D列表是 List(List(1, C++, 1979), List(2, JavaScript, 1995), List(3, Scala, 2004))

学习了如何在Scala中创建列表后，让我们对List进行一些操作。

1）isEmpty方法

它用于检查一个空列表，它是一项重要功能，因为在对Scala执行任何复杂操作之前，我们需要确保列表中包含要对其执行操作的元素。

语法：

list_name.isEmpty

此方法返回一个布尔值，如果列表为空，则为true；否则为false。false，否则。

程序3：展示isEmpty工作原理的程序

object MyClass {
    def main(args: Array[String]) {
        // 建立列表  
        val list1 = List(12, 43, 99)
        val list2 = List()
        
        // 打印列表's 
        println("列表1： "+ list1)
        println("列表2： "+ list2)
        
        // 检查列表是否为空...
        println("list1.isEmpty = "+ list1.isEmpty)
        println("list2.isEmpty = "+ list2.isEmpty)        
    }
}

输出：

列表1： List(12, 43, 99)
列表2： List()list1.isEmpty = false
list2.isEmpty = true

2）头法

它用于提示列表的第一个元素。

语法：

List_name.head

此方法返回一个值，即List的第一个元素。

3）尾法

它用于返回列表中除第一个元素外的所有元素。返回的所有元素将以列表的形式。

语法：

List_name.tail

此方法返回一个列表，除第一个元素外的所有元素。

程序4：查找列表头和尾的程序

object MyClass {
    def main(args: Array[String]) {
        // 建立列表  
        val nations = List("India", "America", "Japan", "Russia")

        //打印列表 
        println("列表是： " + nations)

        //列表打印头
        println("List.head : " + nations.head)

        //打印列表尾
        println("List.tail : " + nations.tail)
    }
}

输出：

列表是： List(India, America, Japan, Russia)List.head : India
List.tail : List(America, Japan, Russia)

Scala中的串联列表

串联是将列表合并为一个的过程。您可以追加列表（在另一个列表的末尾添加一个列表）或在列表前面（在另一个列表的末尾添加一个列表）。

在Scala中串联列表的方法和运算符，

1. :::运算符[追加列表]

2. List。:: :(）方法[准备列表]

3. 列表。concat()方法[追加列表]

4）使用:::运算符连接列表

您可以使用:::运算符在Scala中附加列表。

语法：

列表1：:: list2

它返回一个列表，该列表是list1和list2的串联列表。

程序5：使用:::运算符将两个字符串列表连接为一个字符串的程序

object MyClass {
    def main(args: Array[String]) {
        // 建立列表s  
        val bikes1 = List("RE ThunderBird 350" , "YRF R3")
        val bikes2 = List("HD Iron 883" , "BMW S1000RR")

        //打印列表s 
        println("列出Bike1： " + bikes1)
        println("列出Bike2： " + bikes2)

        //连接列表 
        val conList = bikes1 ::: bikes2
        println("串联列表： " + conList)
    }
}

输出：

列出Bike1： List(RE ThunderBird 350, YRF R3)
列出Bike2： List(HD Iron 883, BMW S1000RR)
串联列表： List(RE ThunderBird 350, YRF R3, HD Iron 883, BMW S1000RR)

5）使用List。:: :(）方法连接List

您可以使用List。:: :(）方法在Scala中添加列表。

语法：

list1.:::(list2)

它返回一个列表，该列表在list1之前位于list2之前。

程序6：使用List。:: :(）方法连接两个数字列表的程序

object MyClass {
    def main(args: Array[String]) {
        // 建立列表s  
        val numList1 = List(4, 9, 21, 75)
        val numList2 = List(1, 7, 12, 25)

        //打印列表s 
        println("List num列表1： " + numList1)
        println("List num列表2： " + numList2)

        //连接列表 
        val numList = numList1.:::(numList2)
        println("串联列表： " + numList)
    }
}

输出：

List num列表1： List(4, 9, 21, 75)
List num列表2： List(1, 7, 12, 25)
串联列表： List(1, 7, 12, 25, 4, 9, 21, 75)

6）使用列表连接列表。concat()方法

您可以使用列表在Scala中串联列表。concat()方法。

语法：

List.concat(list1, list2)

它返回串联的列表。

程序7：使用该concat()方法连接两个类型列表的程序

object MyClass {
    def main(args: Array[String]) {
        // 建立列表s  
        val numList = List(4, 9, 21, 75) // 号码列表
        val stringList = List("includehelp" , "programming" , "tutorials") // 字串列表

        //打印列表s 
        println("列表numList： " + numList)
        println("列出stringList： " + stringList)

        //连接列表 
        val concatList = List.concat(numList, stringList)
        println("串联列表： " + concatList)
    }
}

输出：

列表numList： List(4, 9, 21, 75)
列出stringList： List(includehelp, programming, tutorials)串联列表： List(4, 9, 21, 75, includehelp, programming, tutorials)

7）使用填充方法创建列表

您可以使用列表创建元素的多个副本的列表。fill()方法。

语法：

List.fill(repeat_times)(element)

它返回一个列表，其中元素被多次复制。

程序8：通过使用fill()方法重复字符串N次来创建列表的程序

object MyClass {
    def main(args: Array[String]) {
        // 建立列表 
        val newList = List.fill(5)("includehelp")

        //打印列表s 
        println("newList： " + newList)
    }
}

输出：

newList： List(includehelp, includehelp, includehelp, includehelp, includehelp)

8）倒序排列

您可以使用reverse方法在Scala中反转列表的顺序。

语法：

List.reverse

它返回带有相反顺序元素的列表。

程序9：使用反向方法将给定的整数列表反向的程序

object MyClass {
    def main(args: Array[String]) {
        // 建立列表s  
        val newList = 12 :: (54 :: (99 :: (1210 :: Nil)))

        //打印列表 
        println("newList： " + newList)

        //倒车列表 
        val revList = newList.reverse

        // 打印反向列表
        println("反向列表： " + revList)
    }
}

输出：

newList： List(12, 54, 99, 1210)
反向列表： List(1210, 99, 54, 12)

9）制表列表

您可以使用为每个值计算并将结果添加到列表的函数来创建列表。

语法：

List.tabulate(repeat_times)(evaluation_function)

它返回一个包含表格形式元素的列表。

程序10：使用tabulate()方法创建列表的程序

object MyClass {
    def main(args: Array[String]) {
        // 建立列表s  
        val table5 = List.tabulate(10)(i => i*5)

        //打印列表 
        println("table5 ： " + table5)

        // 创建一个二维列表 
        val values = List.tabulate(5, 5)(_+_)

        //打印列表
        println("值： " + values)
    }
}

输出：

table5 ： List(0, 5, 10, 15, 20, 25, 30, 35, 40, 45)
值： List(List(0, 1, 2, 3, 4), List(1, 2, 3, 4, 5), List(2, 3, 4, 5, 6), List(3, 4, 5, 6, 7), List(4, 5, 6, 7, 8))

这全部与List的列表，创建和操作有关。Scala的List类中定义了一些方法来支持List的功能。您可以在Scala List的功能参考中看到它们。