Scala：List集合的使用

1.声明

当前内容主要用于本人学习和复习，当前内容为List集合的使用

当前内容借鉴：菜鸟教程

scala中的List集合的特征：

1. List是同一类型的集合数据
2. List是不可变的，值一旦赋予就不可以改变
3. List具有链接表结构，而数组不是

2.创建List

1.一维列表的创建：

1. var 变量:List[类型]=List(对应类型的值....)
2. var 变量=List(相同类型的值....)
3. var 变量=Nil （当前Nil表示为空的List集合）
4. var 变量=List() (和3一致)
5. var 变量=值 :: 集合； （在集合的基础的左边添加值返回新List）
6. var 变量=值 :: (值:集合)

  // 定义一个空的字符串列表
  var emptyList: List[String] = List();
  // 定义一个具有数据的列表
  var intList = List(1, 2, 3, 4, 5, 6);

  // 定义空列表
  var emptyList2 = Nil;

  var numList = 1 :: (2 :: (3 :: Nil)); // :: 表示是连接的意思，就是说无论如何最里面的那个Nil必须是数组

  var newNumList = 2 :: (3 :: emptyList); // 这里的emptyList也可以换成其他的列表，具有数据的列表

  var newNumList2 = 7 :: intList; // 默认在当前集合的左边添加元素

2.二维列表的创建：

1. var 变量:List[List[类型]]=List(List(对应类型的值...)，....)
2. var 变量=List(List(对应类型的值...)，....)

 var twoList: List[List[Int]] = List(List(1, 2, 3), List(2, 3, 4), List(3, 4, 5));

3.迭代列表

迭代一维列表

  def printList[T](list: List[T]) {
    var iterator = list.iterator;
    var index = 0;
    print("List[");
    while (iterator.hasNext) {
      var item = iterator.next;
      index += 1;
      print(item);
      if (index < list.size) {
        print(",");
      }
    }
    print("]\n");

  }

除了使用iterator还可以使用for循环迭代

迭代二维列表

// 打印二维列表的函数
  def printTwoList[T](twoList: List[List[T]]) {
    var index = 0;
    print("twoList[\n");
    var i = 0;
    var j = 0;
    for (item <- twoList) {
      j = 0;
      print("[");
      for (subItem <- item) {
        print(twoList(i)(j));
        j += 1;
        if (j < item.length) {
          print(",");
        }
      }
      i += 1;
      print("]\n");
    }
    print("]\n");

  }

4.其他的测试

def main(args: Array[String]): Unit = {
    var size = intList.size;
    println("当前列表intList的大小为：" + size);
    println("emptyList是否为空：" + emptyList.isEmpty);
    println("emptyList2是否为空：" + emptyList2.isEmpty);
    printList(newNumList2);
    printList(numList);
    printList(intList);
    println("输出2在intList中的下标：" + intList.indexOf(2));
    println("输出intList中下标为2的数据：" + intList(2));
    printTwoList(twoList);
    // 连接列表
    println("输出连接列表======");
    println(List.concat(intList, numList)); // 这个表示向第一个列表的后面 ，追加后面的列表
    println(intList.:::(numList)); // 这个表示向使用的集合的前面追加列表，形成新的列表并返回
    println(intList.::(2)); // 这个表示向集合的前面追加一个元素
    println(intList.+:(1)); // 向当前的intList集合中的前面预追加一个元素
    println(intList.:+(2)); // 向当前的intList集合中的后面预追加一个元素
    println("head=" + intList.head + ",last=" + intList.last);
    println("删除元素数据.....");
    println(intList);
    println(intList.drop(1)); // drop表示从左边开始删除元素，值为需要删除数据的个数
    println(intList);
    // println(intList.dropWhile((x) => x == 1));
    println("dropWhile=" + intList.dropWhile(_ == 1));// 删除值等于1的元素,这个_==1等价于(x) => x == 1
    println("dropWhile=" + intList.dropWhile(_ == 5)); // 这个却未被删除，只能删除第一个数据且是5的？
    // 过滤数据
    println("过滤元素为1的数据.....");
    println(intList.filter(_ != 1));
    println(intList.find(_ == 1)); // 查找值为1的数据,第一个数据
  }

主要为：

1. 获取List集合长度：list.size
2. 判断集合是否为空：list.isEmpty
3. 获取指定数据的下标：list.indexOf(element)
4. 获取指定下标的数据：list(index)
5. 向集合A的后面追加集合B：List.concat(A,B,...)
6. 在集合A的前面添加集合B：A.:::(B)
7. 在集合A的前面添加元素：A.::(element)或者A.+:(element)
8. 在集合A的后面添加元素：A.:+(element)
9. 获取集合A中的第一个元素：A.head；获取集合A中的最后一个元素：A.last
10. 从左到右，删除指定数量的数据：list.drop(dropNum)
11. filter(boolean表达式)，表示匹配指定条件的数据，返回结果为List集合
12. find(boolean表达式)，表示查找匹配指定条件的第一个数据，有返回Some,没有返回None
13. 注意None不等于null,且Some可以通过get方法获取找到的数据

5.总结

1.当前的List集合和数组完全不同，不能删除指定数据，不像Java中的List集合，scala中的List集合是不可变的

2.List主要通过list(下标)方式获取指定下标的数据

3.List提供了很多方法来实现查找数据,具有的添加数据都是返回一个新的List

以上纯属个人见解，如有问题请联系本人！