Scala 中的 List 列表详解

r囧r小猫 2023-09-26 21:31 19阅读 0赞

**目录**

一、不可变长的List列表

1.List列表的声明与遍历

2.List列表的map、flatMap函数

3.List列表的filter过滤函数

4.List列表的count计数函数

二、可变长的List列表

1.可变长List声明

2.可变长List的添加方法

三、List列表其余的方法与函数

--------------------

## 一、不可变长的List列表 ##

### 1.List列表的声明与遍历 ###

//一、不可变长的list
        //声明List时可以不给定泛型，但有时会推断不出来，所以使用时一般要给泛型
       val list = List[Int](1,2,3)
    
        //list的遍历
        for (elem <- list){
          println(elem)
        }
    
        list.foreach(println)

### 2.List列表的map、flatMap函数 ###

val list1 = List[String]("hello scala","hello java","hello spark")
    
        /**
         * map 与 flatMap 的区别：
         * map：map是将list按需求划分之后，返回的是一个个数组，最后每个数组作为元素在一起成为List
         * flatMap：flatMap比map多一步，就是将每个数组转为了一个个的元素，最终是一个由每个单个元素组成的list
         */
        //list的map方法：
        val result : List[Array[String]] = list1.map(s => {
          s.split(" ")
        })
        result.foreach(arr => arr.foreach(println))
    
        //list的flatMap方法：
        val result1: List[String] = list1.flatMap(s => {
          s.split(" ")
        })
        result1.foreach(println)

![4d1ce34387c54022bb77f82ce9e7aeda.png][]

### 3.List列表的filter过滤函数 ###

匹配上的会被留下

//list的filter方法：过滤掉不需要的元素
        val result2: List[String] = list1.filter(s => {
          "hello spark".equals(s)//返回true，将true的结果返回
        })
        result2.foreach(println)

### 4.List列表的count计数函数 ###

//list的count方法：计算符合条件的元素有几条
        val i: Int = list1.count(s => {
          s.length > 4
        })
        println(i)

## 二、可变长的List列表 ##

### 1.可变长List声明 ###

### 2.可变长List的添加方法 ###

//可变长的list列表
        val list4 = ListBuffer[Int](1,2,3)
        list4.append(4,5,6)//在list尾部添加元素
        list4.+=(20)//在list尾部添加元素
        list4.+=:(100)//在list头部添加元素
        list.foreach(println)

## 三、List列表其余的方法与函数 ##

def +(elem: A): List[A]
    前置一个元素列表
    
    def ::(x: A): List[A]
    在这个列表的开头添加的元素。
    
    def :::(prefix: List[A]): List[A]
    增加了一个给定列表中该列表前面的元素。
    
    def ::(x: A): List[A]
    增加了一个元素x在列表的开头
    
    def addString(b: StringBuilder): StringBuilder
    追加列表的一个字符串生成器的所有元素。
    
    def addString(b: StringBuilder, sep: String): StringBuilder
    追加列表的使用分隔字符串一个字符串生成器的所有元素。
    
    def apply(n: Int): A
    选择通过其在列表中索引的元素
    
    def contains(elem: Any): Boolean
    测试该列表中是否包含一个给定值作为元素。
    
    def copyToArray(xs: Array[A], start: Int, len: Int): Unit
    列表的副本元件阵列。填充给定的数组xs与此列表中最多len个元素，在位置开始。
    
    def distinct: List[A]
    建立从列表中没有任何重复的元素的新列表。
    
    def drop(n: Int): List[A]
    返回除了第n个的所有元素。
    
    def dropRight(n: Int): List[A]
    返回除了最后的n个的元素。
    
    def dropWhile(p: (A) => Boolean): List[A]
    丢弃满足谓词的元素最长前缀。
    
    def endsWith[B](that: Seq[B]): Boolean
    测试列表是否使用给定序列结束。
    
    def equals(that: Any): Boolean
    equals方法的任意序列。比较该序列到某些其他对象。
    
    def exists(p: (A) => Boolean): Boolean
    测试谓词是否持有一些列表的元素。
    
    def filter(p: (A) => Boolean): List[A]
    返回列表满足谓词的所有元素。
    def forall(p: (A) => Boolean): Boolean
    测试谓词是否持有该列表中的所有元素。
    
    def foreach(f: (A) => Unit): Unit
    应用一个函数f以列表的所有元素。
    
    def head: A
    选择列表的第一个元素
    
    def indexOf(elem: A, from: Int): Int
    经过或在某些起始索引查找列表中的一些值第一次出现的索引。
    
    def init: List[A]
    返回除了最后的所有元素
    
    def intersect(that: Seq[A]): List[A]
    计算列表和另一序列之间的多重集交集。
    
    def isEmpty: Boolean
    测试列表是否为空
    
    def iterator: Iterator[A]
    创建一个新的迭代器中包含的可迭代对象中的所有元素
    
    def last: A
    返回最后一个元素
    
    def lastIndexOf(elem: A, end: Int): Int
    之前或在一个给定的最终指数查找的列表中的一些值最后一次出现的索引
    
    def length: Int
    返回列表的长度
    
    def map[B](f: (A) => B): List[B]
    通过应用函数以g这个列表中的所有元素构建一个新的集合
    
    def max: A
    查找最大的元素
    
    def min: A
    查找最小元素
    
    def mkString: String
    显示列表的字符串中的所有元素
    
    def mkString(sep: String): String
    显示的列表中的字符串中使用分隔串的所有元素
    
    def reverse: List[A]
    返回新列表，在相反的顺序元素
    
    def sorted[B >: A]: List[A]
    根据排序对列表进行排序
    
    def startsWith[B](that: Seq[B], offset: Int): Boolean
    测试该列表中是否包含给定的索引处的给定的序列
    
    def sum: A
    概括这个集合的元素
    
    def tail: List[A]
    返回除了第一的所有元素
    
    def take(n: Int): List[A]
    返回前n个元素
    
    def takeRight(n: Int): List[A]
    返回最后n个元素
    
    def toArray: Array[A]
    列表以一个数组变换
    
    def toBuffer[B >: A]: Buffer[B]
    列表以一个可变缓冲器转换
    
    def toMap[T, U]: Map[T, U]
    此列表的映射转换
    
    def toSeq: Seq[A]
    列表的序列转换
    
    def toSet[B >: A]: Set[B]
    列表到集合变换
    
    def toString(): String
    列表转换为字符串

[4d1ce34387c54022bb77f82ce9e7aeda.png]: https://img-blog.csdnimg.cn/4d1ce34387c54022bb77f82ce9e7aeda.png