Lista Scala (lista)
Lista Scala (lista)
Lista Scala è simile a una matrice, sono dello stesso tipo di tutti gli elementi, ma sono diversi: La lista è immutabile, il valore non può essere cambiato una volta che sono definiti, seguita da un elenco con struttura ricorsiva (cioè, la struttura della tabella link) e un array No. .
Elemento tipo T può essere scritta come una lista di List [T]. Ad esempio, il seguente mostra un elenco di vari tipi:
// 字符串列表 val site: List[String] = List("w3big", "Google", "Baidu") // 整型列表 val nums: List[Int] = List(1, 2, 3, 4) // 空列表 val empty: List[Nothing] = List() // 二维列表 val dim: List[List[Int]] = List( List(1, 0, 0), List(0, 1, 0), List(0, 0, 1) )
Due struttura di unità di base della lista èpari a zeroe::
Nil può anche essere espresso come una lista vuota.
Possiamo scrivere esempi precedenti sono le seguenti:
// 字符串列表 val site = "w3big" :: ("Google" :: ("Baidu" :: Nil)) // 整型列表 val nums = 1 :: (2 :: (3 :: (4 :: Nil))) // 空列表 val empty = Nil // 二维列表 val dim = (1 :: (0 :: (0 :: Nil))) :: (0 :: (1 :: (0 :: Nil))) :: (0 :: (0 :: (1 :: Nil))) :: Nil
Elenco dei operativo di base
Lista Scala ha tre operazioni di base:
-
head
restituisce il primo elemento della lista -
tail
restituisce un elenco che contiene in aggiunta agli altri elementi del primo elemento -
isEmpty
restituisce true se la lista è vuota
Per list Scala qualunque operazione può essere usata per esprimere le tre operazioni di base. Esempi sono i seguenti:
object Test { def main(args: Array[String]) { val site = "w3big" :: ("Google" :: ("Baidu" :: Nil)) val nums = Nil println( "第一网站是 : " + site.head ) println( "最后一个网站是 : " + site.tail ) println( "查看列表 site 是否为空 : " + site.isEmpty ) println( "查看 nums 是否为空 : " + nums.isEmpty ) } }
L'attuazione del codice di cui sopra, l'output è:
$ vim Test.scala $ scala Test.scala 第一网站是 : w3big 最后一个网站是 : List(Google, Baidu) 查看列表 site 是否为空 : false 查看 nums 是否为空 : true
Elenco connessioni
È possibile utilizzarel'::: dell'operatore o List. :: :()Metodo o il metodoList.concat ()per collegare due o più liste. Esempi sono i seguenti:
object Test { def main(args: Array[String]) { val site1 = "w3big" :: ("Google" :: ("Baidu" :: Nil)) val site2 = "Facebook" :: ("Taobao" :: Nil) // 使用 ::: 运算符 var fruit = site1 ::: site2 println( "site1 ::: site2 : " + fruit ) // 使用 Set.:::() 方法 fruit = site1.:::(site2) println( "site1.:::(site2) : " + fruit ) // 使用 concat 方法 fruit = List.concat(site1, site2) println( "List.concat(site1, site2) : " + fruit ) } }
L'attuazione del codice di cui sopra, l'output è:
$ vim Test.scala $ scala Test.scala site1 ::: site2 : List(w3big, Google, Baidu, Facebook, Taobao) site1.:::(site2) : List(Facebook, Taobao, w3big, Google, Baidu) List.concat(site1, site2) : List(w3big, Google, Baidu, Facebook, Taobao)
List.fill ()
Possiamo usare List.fill () per creare un determinato numero di ripetizioni di una lista di elementi:
object Test { def main(args: Array[String]) { val site = List.fill(3)("w3big") // 重复 w3big 3次 println( "site : " + site ) val num = List.fill(10)(2) // 重复元素 2, 10 次 println( "num : " + num ) } }
L'attuazione del codice di cui sopra, l'output è:
$ vim Test.scala $ scala Test.scala site : List(w3big, w3big, w3big) num : List(2, 2, 2, 2, 2, 2, 2, 2, 2, 2)
List.tabulate ()
Metodo List.tabulate () viene utilizzato per creare l'elenco per la funzione data.
Il primo argomento è il numero di elementi, che può essere bidimensionale, il secondo parametro per la funzione specificata, si calcola il risultato specificando la funzione e restituisce il valore inserito nella lista, il valore iniziale è 0, gli esempi sono i seguenti:object Test { def main(args: Array[String]) { // 通过给定的函数创建 5 个元素 val squares = List.tabulate(6)(n => n * n) println( "一维 : " + squares ) // 创建二维列表 val mul = List.tabulate( 4,5 )( _ * _ ) println( "多维 : " + mul ) } }
L'attuazione del codice di cui sopra, l'output è:
$ vim Test.scala $ scala Test.scala 一维 : List(0, 1, 4, 9, 16, 25) 多维 : List(List(0, 0, 0, 0, 0), List(0, 1, 2, 3, 4), List(0, 2, 4, 6, 8), List(0, 3, 6, 9, 12))
List.reverse
Sequenza List.reverse per la lista invertita, gli esempi sono i seguenti:
object Test { def main(args: Array[String]) { val site = "w3big" :: ("Google" :: ("Baidu" :: Nil)) println( "site 反转前 : " + site ) println( "site 反转前 : " + site.reverse ) } }
L'attuazione del codice di cui sopra, l'output è:
$ vim Test.scala $ scala Test.scala site 反转前 : List(w3big, Google, Baidu) site 反转前 : List(Baidu, Google, w3big)
Elenco Scala metodi comuni
Nella tabella seguente sono elencati i metodi comuni Elenco Scala:
No. | Metodo e Descrizione |
---|---|
1 | DEF + :( elem: A): Lista [A] Aggiungere alla lista dei pre-elementi 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): Lista [A] All'inizio della lista per aggiungere elementi |
3 | DEF :: :( prefisso: Lista [A ]): Lista [A] All'inizio della lista per aggiungere l'elemento della lista specificata |
4 | DEF: + (elem: A) : Lista [A] Dopo aver copiato la lista per aggiungere elementi. 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 Aggiungere tutti gli elementi della lista di StringBuilder |
6 | def AddString (B: StringBuilder, settembre : String): StringBuilder Aggiungere tutti gli elementi della lista di StringBuilder, e specificare il delimitatore |
7 | applicare DEF (n: Int): A Ottenere un elenco di elementi di indice |
8 | DEF contiene (elem: Qualsiasi): booleano Rilevare se l'elenco contiene l'elemento specificato |
9 | def copyToArray (xs: Array [A ], avviare: Int, len: Int): Unità Copia gli elementi della lista in un array. |
10 | DEF distinti: Lista [A] Rimuovere gli elementi duplicati della lista, e restituisce una nuova lista |
11 | def cadere (n: Int): Lista [A] Scartare i primi n elementi, e restituisce una nuova lista |
12 | def dropRight (n: Int): Lista [A] Eliminare gli ultimi n elementi, e restituisce una nuova lista |
13 | def dropWhile (p: (A) => booleano): Lista [A] elemento di scarto da sinistra a destra, fino a quando la condizione non è soddisfatta p |
14 | DEF endswith [B] (che: Seq [B]): booleano Rilevare se l'elenco alla fine della sequenza specificata |
15 | DEF è uguale (che: Qualsiasi): booleano Determinare se stesso |
16 | def esiste (p: (A) => booleana): booleano Analizzando le condizioni specificate nella lista di elementi esiste. L determinare se vi è un elemento: scala> l.exists(s => s == "Hah") res7: Boolean = true |
17 | def filtrare (p: (A) => booleano): Lista [A] Tutti gli elementi di simboli di uscita specificato condizione. La lunghezza dell'elemento filtrante 3: scala> l.filter(s => s.length == 3) res8: List[String] = List(Hah, WOW) |
18 | def forall (p: (A) => booleana): booleano Rilevamento di tutti gli elementi. Per esempio: per determinare se tutti gli elementi di "H" in questo inizio: scala> l.forall (s => s.startsWith ( "H")) res10: Boolean = false |
19 | def foreach (f: (A) => Unità): Unità Tutti gli elementi della funzione alla lista |
20 | testa DEF: A Ottenere il primo elemento della lista |
21 | def indexOf (elem: A, da : Int): Int Trovare la posizione della prima occorrenza dell'elemento dalla posizione specificata dal |
22 | def init: Lista [A] Restituisce tutti gli elementi, tranne l'ultimo |
23 | def intersecano (che: Seq [A ]): Lista [A] Calcolare una pluralità di intersezione di insiemi |
24 | DEF isEmpty: booleano Rilevare se l'elenco è vuoto |
25 | DEF iteratore: Iterator [A] Creare un nuovo iteratore per iterare gli elementi |
26 | DEF ultima: A Restituisce l'ultimo elemento |
27 | def lastIndexOf (elem: A, fine : Int): Int Alla posizione finale posizione specificata iniziare a cercare l'ultima occorrenza dell'elemento |
28 | Lunghezza DEF: Int Torna alla lunghezza lista |
29 | DEF mappa [B] (f: (A) => B): Lista [B] Attraverso un determinato metodo ricalcolerà tutti gli elementi |
30 | DEF max: A Trova l'elemento massimo |
31 | min DEF: A Trova l'elemento più piccolo |
32 | DEF mkString: String Visualizzare un elenco di tutti gli elementi come una stringa |
33 | def mkString (Set: String): String Separatori verrà visualizzato un elenco di tutti gli elementi come una stringa |
34 | DEF inversa: Lista [A] lista Reverse |
35 | DEF ordinata [B>: A] : Lista [A] lista ordinamento |
36 | DEF startsWith [B] (che: Seq [B], offset: Int): booleano Rilevare se l'elenco contiene la sequenza specificata nella posizione specificata |
37 | somma DEF: A Calcolo e raccolta di elementi |
38 | coda DEF: Lista [A] Restituisce tutti gli elementi, ad eccezione del primo |
39 | def prendere (n: Int): Lista [A] Estrazione dei primi n elementi della lista |
40 | def takeRight (n: Int): Lista [A] n elementi lista estratti |
41 | DEF toArray: Array [A] Lista ad un array |
42 | DEF toBuffer [B>: A] : Buffer [B] back buffer contiene un elenco di tutti gli elementi |
43 | DEF toMap [T, U]: mappa [T, U] Lista convertito Map |
44 | DEF toSeq: Seq [A] Lista convertire Seq |
45 | DEF Toset [B>: A] : Impostare [B] Lista convertito Set |
46 | def toString (): String Convertito in un elenco di stringhe |
Altri modi per fare riferimento alla documentazione delle API