scala-03-list操作

列表

Scala 列表类似于数组，它们所有元素的类型都相同，但是它们也有所不同：列表是不可变的，值一旦被定义了就不能改变，其次列表 具有递归的结构（也就是链接表结构）而数组不是。。

1, 创建 list

/**
    * 创建list
    * 构建列表的2个基本单位:   ::  和 Nil
    */
  def createList(): List[String] = {
    // 直接创建
    var site: List[String] = List("Runnbo", "google", "Baidu")
    var site2 = "Runnbo" :: ("google" :: ("baidu" :: Nil))

    // 空列表
    var list1 = Nil

    // 二维列表
    var dim1: List[List[Int]] = List(List(1, 2), List(2, 3))
    var dim2: List[List[Int]] = (1::(2::(3::Nil)))::
     (0::(1::(2::(3::(4::Nil)))))::
      (3::(3::Nil))::Nil

    // 通过给定的函数创建列表
    val mul = List.tabulate(4, 5)(_*_)

    site
  }

2, 获取list中的值

  def getValue(list: List[String]): Unit = {
    println(list(0))

    for (x <- list) {
      println(x)
    }
  }

3, 列表链接; 

/**
  * 列表链接
  */
def concatList(list1: List[String])(list2: List[String]):Unit = {
　　// 将元素放进 list2中
  println(list1(0) :: list2)
　　// 将list1 作为一个 元素, 和list2(0) 组成新的list
  println(list1:: list2(0):: Nil)
　　// list1 作为一个元素, 放进 list2 中, List(List(Runnbo, google, Baidu), aaa, bbb)
  println(list1:: list2)
　　// list拼接
  println(list1::: list2)

  println(list1.+:("gqwere"))

// 使用concat链接 var fruit = List.concat(list1, list2) println(fruit) }

 4, list常用操作

 /**
    * list常用操作
    */
  def userMethod = {
    val list = List("a", "b", "c", "d", "e", "e")
    // 判断为空
    val isEmpty = list.isEmpty

    // 获取第一个  a
    val firstElement = list.head

    // 获取第二个  b
    val secondElement = list.tail.head

    // 获取除第一个以外的   ("b", "c", "d", "e", "e")
    val tailSeq: immutable.Seq[String] = list.tail

    // 获取最后一个   e
    val lastElement = list.last

    // 除最后一个元素外的元素   ("a", "b", "c", "d", "e")
    val initSeq = list.init

    // 元素倒置   ("e", "e", "d", "c", "b", "a")
    val revertSeq = list.reverse

    // 获取前n个  ("a", "b")
    val firstSeq = list.take(2)

    // 丢弃前n个   ("c", "d", "e", "e")
    val lastSeq = list.drop(2)

    // 列表进行分割  (List[Int], List[Int]) = (List("a", "b"),List("c", "d", "e", "e"))
    val spilitSeq = list.splitAt(2)
    // 等同于
    val splitSeq2 = (list.take(2), list.drop(2))

    // 转字符串
    val listStr = list.mkString

    // 转数组
    val listArray = list.toArray


    list.foreach(x => println(x))
  }

scala中可以直接使用 java中的类, 需要导包即可食用

package scala.com.wenbronk.traits

import java.util

object TestArrayList {

  def main(args: Array[String]): Unit = {

    var arr = new util.ArrayList[Any]
    arr.add(123)
    arr.add("gaga")

    var it = arr.iterator()
    while (it.hasNext) {
      println(it.next())
    }
  }

}

元组

与列表一样，元组也是不可变的，但与列表不同的是元组可以包含不同类型的元素。

元组的值是通过将单个的值包含在圆括号中构成的

1, 创建元组

val t = (1, 3.14, "Fred")  
val t = new Tuple3(1, 3.14, "Fred")

目前 Scala 支持的元组最大长度为 22。对于更大长度你可以使用集合，或者扩展元组。

2, 元组元素的访问: 

   def main(args: Array[String]) {
      val t = (4,3,2,1)

      val sum = t._1 + t._2 + t._3 + t._4

      println( "元素之和为: "  + sum )
   }

3, 元组的迭代

   def main(args: Array[String]) {
      val t = (4,3,2,1)
      
      t.productIterator.foreach{ i =>println("Value = " + i )}
   }

4, 元组转为字符串

   def main(args: Array[String]) {
      val t = new Tuple3(1, "hello", Console)
      
      println("连接后的字符串为: " + t.toString() )
   }

1	def +:(elem: A): List[A] 为列表预添加元素 scala> val x = List(1) x: List[Int] = List(1) scala> val y = 2 +: x y: List[Int] = List(2, 1) scala> println(x) List(1)
2	def ::(x: A): List[A] 在列表开头添加元素
3	def :::(prefix: List[A]): List[A] 在列表开头添加指定列表的元素
4	def :+(elem: A): List[A] 复制添加元素后列表。 scala> val a = List(1) a: List[Int] = List(1) scala> val b = a :+ 2 b: List[Int] = List(1, 2) scala> println(a) List(1)
5	def addString(b: StringBuilder): StringBuilder 将列表的所有元素添加到 StringBuilder
6	def addString(b: StringBuilder, sep: String): StringBuilder 将列表的所有元素添加到 StringBuilder，并指定分隔符
7	def apply(n: Int): A 通过列表索引获取元素
8	def contains(elem: Any): Boolean 检测列表中是否包含指定的元素
9	def copyToArray(xs: Array[A], start: Int, len: Int): Unit 将列表的元素复制到数组中。
10	def distinct: List[A] 去除列表的重复元素，并返回新列表
11	def drop(n: Int): List[A] 丢弃前n个元素，并返回新列表
12	def dropRight(n: Int): List[A] 丢弃最后n个元素，并返回新列表
13	def dropWhile(p: (A) => Boolean): List[A] 从左向右丢弃元素，直到条件p不成立
14	def endsWith[B](that: Seq[B]): Boolean 检测列表是否以指定序列结尾
15	def equals(that: Any): Boolean 判断是否相等
16	def exists(p: (A) => Boolean): Boolean 判断列表中指定条件的元素是否存在。 判断l是否存在某个元素: scala> l.exists(s => s == "Hah") res7: Boolean = true
17	def filter(p: (A) => Boolean): List[A] 输出符号指定条件的所有元素。 过滤出长度为3的元素: scala> l.filter(s => s.length == 3) res8: List[String] = List(Hah, WOW)
18	def forall(p: (A) => Boolean): Boolean 检测所有元素。 例如：判断所有元素是否以"H"开头： scala> l.forall(s => s.startsWith("H")) res10: Boolean = false
19	def foreach(f: (A) => Unit): Unit 将函数应用到列表的所有元素
20	def head: A 获取列表的第一个元素
21	def indexOf(elem: A, from: Int): Int 从指定位置 from 开始查找元素第一次出现的位置
22	def init: List[A] 返回所有元素，除了最后一个
23	def intersect(that: Seq[A]): List[A] 计算多个集合的交集
24	def isEmpty: Boolean 检测列表是否为空
25	def iterator: Iterator[A] 创建一个新的迭代器来迭代元素
26	def last: A 返回最后一个元素
27	def lastIndexOf(elem: A, end: Int): Int 在指定的位置 end 开始查找元素最后出现的位置
28	def length: Int 返回列表长度
29	def map[B](f: (A) => B): List[B] 通过给定的方法将所有元素重新计算
30	def max: A 查找最大元素
31	def min: A 查找最小元素
32	def mkString: String 列表所有元素作为字符串显示
33	def mkString(sep: String): String 使用分隔符将列表所有元素作为字符串显示
34	def reverse: List[A] 列表反转
35	def sorted[B >: A]: List[A] 列表排序
36	def startsWith[B](that: Seq[B], offset: Int): Boolean 检测列表在指定位置是否包含指定序列
37	def sum: A 计算集合元素之和
38	def tail: List[A] 返回所有元素，除了第一个
39	def take(n: Int): List[A] 提取列表的前n个元素
40	def takeRight(n: Int): List[A] 提取列表的后n个元素
41	def toArray: Array[A] 列表转换为数组
42	def toBuffer[B >: A]: Buffer[B] 返回缓冲区，包含了列表的所有元素
43	def toMap[T, U]: Map[T, U] List 转换为 Map
44	def toSeq: Seq[A] List 转换为 Seq
45	def toSet[B >: A]: Set[B] List 转换为 Set
46	def toString(): String 列表转换为字符串

 来自菜鸟教程