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 列表轉換為字符串

 

 來自菜鳥教程