Colección Scala
Scala ofrece un buen implementaciones colección, las ofertas de recolección de algún tipo de abstracción.
conjunto Scala en una variable (lo mutable) y sin indicación (lo inmutable) se convierte
.
- conjunto Variable: longitud variable, contenido variable de
- colección inmutable: longitud inmutable, el contenido no es variable
El conjunto de variables puede ser actualizada o extendida en su caso. Esto significa que se pueden modificar, añadir, eliminar elementos de una colección.
Sin colecciones de variables, por el contrario, nunca va a cambiar. Sin embargo, todavía se puede simular añadir, quitar, o la operación de actualización. Sin embargo, estas operaciones volverán un nuevo conjunto en cada caso, mientras que el conjunto original no cambia.
A continuación, se presentará una colección de varios tipos comunes de aplicaciones:
-
Lista Scala (Lista)
función de lista es su elemento almacenado de forma lineal, repetir la recolección de objetos se puede almacenar.
-
Scala Conjunto (recopilación)
Set es el tipo más simple de colección. Los objetos de la colección no está ordenada por una forma específica, y ningún objeto duplicado.
-
Scala mapa (mapa)
Mapa es la clave para una colección de objetos y valores de la asignación de objeto, cada elemento de los cuales comprende un par de valor de clave de objetos y objetos.
-
tupla Scala
Una tupla es un conjunto de valores para diferentes tipos de
ejemplos
El código siguiente es determinado, todos los ejemplos anteriores demuestra el conjunto de definición del tipo:
// 定义整型 List
val x = List(1,2,3,4)
// 定义 Set
val x = Set(1,3,5,7)
// 定义 Map
val x = Map("one" -> 1, "two" -> 2, "three" -> 3)
// 创建两个不同类型元素的元组
val x = (10, "Runoob")
Lista Scala (Lista)
lista Scala es similar a la matriz, todos los elementos son del mismo tipo, pero son diferentes: la lista es inmutable, una vez definido el valor no puede ser alterado, seguido de una lista de estructura recursiva (es decir, ligado estructura de la lista) y la matriz No.
En Scala lista está vacía (lista vacía indica cero) más o bien un elemento de cabeza de una cola de lista.
9 :: List(5, 2)
:: operador se da cabeza y la cola para crear una nueva lista
tal como
Lista (9,10,6,4,1)
el primer elemento 9 de la cabeza
de la cola lista de cola es 10,6,4,1
Nil representa una lista vacía
lista inmutable
Crear una lista
En Scala lista está vacía (lista vacía indica cero) más o bien un elemento de cabeza de una cola de lista.
val list=List（9,5,2） //创建一个不可变的集合
val list2= :: List(5, 2) // :: 操作符是将给定的头和尾创建一个新的列表
val list3=100：Nil //表示List(100)
val list4=Nil //表示空列表
Una lista de las operaciones básicas
//将 0 插入到 lst1 的前面生成一个新的 List
val lst2 = 0 :: lst1
val lst3 = lst1.::(0)
val lst4 = 0 +: lst1
val lst5 = lst1.+:(0)
//将一个元素添加到 lst1 的后面产生一个新的集合
val lst6 = lst1 :+ 3
val lst0 = List(4,5,6)
//将 2 个 list 合并成一个新的 List
val lst7 = lst1 ++ lst0
//将 lst0 插入到 lst1 前面生成一个新的集合
val lst8 = lst1 ++: lst0
//将 lst0 插入到 lst1 前面生成一个新的集合
val lst9 = lst1.:::(lst0)
// 使用 concat 方法，site1在前，site2在后
fruit = List.concat(site1, site2)
site1在前，site2在后
list.count //返回个数
list.filter（x=>x>=3） //过滤，过滤大于等于3的元素，生成一个新的集合
list.sorted() //默认升序排序，生成一个新的集合
wps=List（（"a",1），（"c",3））
wps.sortBy(t=>-t._2) //根据什么排序升序，参数为函数
wps.sortWith(（x,y）=>x._2>y._2) //根据需求排序，有点像compare to，参数是boolean
grouped（）让组内的多少分一组，比如两个分一组
list.grouped（2）//List(List(1,2),List(3,4),List(1,2))
看到55分
}
Una lista de los métodos comúnmente utilizados
list=List(3,5,1)
fold(初始值)（叠加的函数）
list.fold（0）((x,y)=>x+y)
/*计算过程
*（0+3）//0是初始值
*(3+5)
*(8+1)=9
*结果为9,9+3+5+1
*
*foldLeft
*foldRight
*只是整合的方向不停
*第一个下划线代表初始值，第二个代表集合中操作的元素
*简写 list.fold(0)(_+_)
*
*/
-----------------------------------------------------------
list.reduce((x,y)=>x+y)
也是整合
---------------------------------------
List.union(list2)
求两个集合的并集
--------------------------
交集
list.intersect(list2)
——————————————
差集
list.diff(list2 )
-----------------
list(0,8,6)
list2(3,5,1)
list.zip(list2) //对应位置组成元组
//得结果
//list((3,0),(5,8),(1,6))
r.map(x=>(x._1+x._2)) //元组相加
----------------------------
list2.mkString("|")
//生成字符串，可指定分割符
0|8|6|3
-----------------------
list.length()
list.size()
//求长度，一样的
----------------------------------
//列表截取 前闭后开
list.slice(1,3)
list.slice(1,list.length-1)
lista de variables
// Si se desea utilizar una matriz de variables, es necesario importar importar paquete scala.collection.mutable.ListBuffer
import scala.collection.mutable.ListBuffer
object MutListTest extends App{
//构建一个可变列表， 初始有 3 个元素 1,2,3
val lst0 = ListBuffer[Int](1,2,3)
//创建一个空的可变列表
val lst1 = new ListBuffer[Int]
//向 lst1 中追加元素， 注意： 没有生成新的集合
lst1 += 4
lst1.append(5)
//将 lst1 中的元素最近到 lst0 中， 注意： 没有生成新的集合
lst0 ++= lst1
//将 lst0 和 lst1 合并成一个新的 ListBuffer 注意： 生成了一个集合
val lst2= lst0 ++ lst1
//将元素追加到 lst0 的后面生成一个新的集合
val lst3 = lst0 :+ 5
}
Scala Conjunto (recopilación)
Scala Conjunto (recopilación) no se repite colección de objetos, todos los elementos son únicos.
Scala variable de conjunto en un conjunto e inmutable.
Por defecto, el Scala es un conjunto inmutable de su uso si desea utilizar la colección de variables, es necesario paquete scala.collection.mutable.Set referencia.
El scala.collection.immutable.Set de referencia por defecto, colección inmutable de ejemplos son los siguientes:
Un conjunto de operaciones básicas de la variable
import scala.collection.immutable.HashSet //导入包
val set1 = new HashSet[Int](1,3,4) //生成一个可变的set
set1.add(5) //添加元素
set+=(3) //添加元素
set1.remove(1) //移除元素
set-=(3) //移除元素
set ++=Set(0,9) //拼接两个Set
// 查找集合中最大与最小元素
min = num.min
max=num.max
Un conjunto de operaciones básicas inmutables
al set =Set(1,2,3) //生成一个不可变的set
//方法类似，只是不可变，需要新生成一个set
Scala mapa (mapa)
-
Mapa (cartografía) es un valor par iterativo (clave / valor) estructura.
-
Todos los valores se pueden obtener a través de la llave.
-
Mapa de la llave es única.
-
Mapa también se llama una tabla hash (tablas hash).
-
Mapa Existen dos tipos de variables y no variables, excepto que el objeto variable puede modificarlo sin objetos mutables no.
-
Por defecto Scala Mapa inmutable. Si es necesario utilizar una colección variables, es necesario introducir explícitamente la clase scala.collection.mutable.Map importación
-
En Scala se puede usar tanto variables e inmutable Mapa, inmutable directamente a través del mapa, el uso variable de mutable.Map. Los siguientes ejemplos demuestran la aplicación de Mapa inmutable:
demostración:
// 空哈希表，键为字符串，值为整型
var A:Map[Char,Int] = Map()
// Map 键值对演示
val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF")
Cuando se define mapa, necesidad de definir el tipo de pares de valores clave. Si es necesario agregar los pares de valores clave, el signo + se puede utilizar, de la siguiente manera:
A += ('I' -> 1)
A += ('J' -> 5)
A += ('K' -> 10)
A += ('L' -> 100)
Mapeo operación inmutable
定义一个定长的映射
val mp=Map[String,Int]（"a"->1,"b"->2）
operación de mapeo Variable
import scala.collection.mutable
val map1 = mutable.HashMap[String, Int]()
//向 map 中添加数据
map1("spark") = 1
map1 += (("hadoop", 2))
map1.put("storm", 3)
println(map1)
// 取值 get getOrElse()
//从 map 中移除元素
map1 -= "spark"
map1.remove("hadoop")
println(map1)
map1.get("hadoop").get //取value,如果是null，则异常
map1.get("hadoop",0).getOrElse //取value,如果没有就传默认值，可设定，这里是0
map1.MapValue(t=>t+100)) //对map的value进行操作，然后返回值是操作后的map
//区别于
map1.map(x=>x._2+100)
tupla Scala
tuplas Scala fijos número de artículos juntos, de manera que se pueden pasar como un todo.
Con diferentes matrices o listas, tuplas pueden acomodar diferentes tipos de objetos, pero son inmutables.
Tuplas puede poner cualquier tipo de datos
Actualmente el máximo apoyo Scala longitud es de 22 tupla.
La definición de una tupla
Los siguientes ejemplos se definen en la tupla de tres elementos, que corresponden respectivamente al tipo [Int, Doble, java.lang.String].
Además, también se puede definir de la siguiente manera:
val t = (1, 3.14, "Fred")
val t = new Tuple3(1, 3.14, "Fred")
Acceso tupla de elementos
Podemos utilizar la primera t._1 elemento de acceso, t._2 el acceso al segundo elemento, de la siguiente manera:
println(t._2) // 访问元组总的第二个元素
Dual-tupla
// 对偶元组
val tuple2 = (1, 3)
// 交换元组的元素位置, tuple2 没有变化, 生成了新的元组
val swap = tuple2.swap
Caso 2 palabra Scala en cuenta para lograr
Análisis:
Paso 1: Mapa de (x => ( x, 1) // elemento en la tupla (palabra 1)
Paso 2 :. GroupBy (X = X 1) // hacer primero elemento de la tupla de acuerdo agrupación
. paso 3: mapValue (T => t.foldLeft (0) ( + . 2)) para asignar el valor extraído, a continuación, el valor es el elemento de matriz del grupo que consiste de, subrayado representa un primer valor inicial, el segundo elemento representativo el segundo grupo de elementos, es decir, el recuento, entonces t.foldLeft (0) ( + tupla ._2) añadir el segundo elemento, el número de adiciones es
arr.flatMap(_.split(" ")).map(x=>(x,1).groupBy(x=x._1).mapValue(t=>t.foldLeft(0)(_+_._2))
//返回值Map(scala->1,holo->1,lin->2)
