Scala入门到放弃—04—集合

集合

数组

• 可变数组

package org.example
object ArrayApp extends App{
  //继承App后直接直接调用函数，不需要main
  //println("hello")
  val a = new Array[String](5)
  a(0)="hello"
  println(a(0))
  val b = Array("hello","world")
  val c = Array(1,2,3,4,5,67)
  c.sum
  c.max
  c.mkString("/")
}

• 可变数组

  val d=scala.collection.mutable.ArrayBuffer[Int]()
  d+=1
  d+=2
  d+=(2,33,4)
  d++=Array(33,45,22)
  println(d+"-------------------")
  d.insert(0,999)
  d.remove(1,2)
  d.trimEnd(2)
  println(d+"-------------------")
  //转化成不可变的
  d.toString()
  d.toArray
  for(i<-0 until d.length){
    println(c(i))
  }
  for(i<-c){
     println(i)
  }
  // 逆序输出
  for(i<- (0 until c.length).reverse){
     println(i)
  }

hello
ArrayBuffer(1, 2, 2, 33, 4, 33, 45, 22)
-------------------
ArrayBuffer(999, 2, 33, 4, 33)
-------------------
1
2
3
4
5

List

list是不可变的，对list进行添加删除或者取值等操作均会返回一个新的list。

Scala数组是一个拥有相同类型的对象的可变序列。例如一个Array[String]只能包含字符串。虽然无法在数组实例化以后改变其长度，却可以改变它的元素值。因此，数组是可变的对象。

List有个方法叫:::，用于列表拼接
操作是::，读作cons。它在一个已有列表的最前面添加一个新的元素，并返回这个新的列表。
表示空列表的快捷方式是Nil，初始化一个新的列表的另一种方式是用::将元素串接起来，并将Nil作为最后一个元素

// 可以理解为一个C语言的\0
scala> Nil
res4: scala.collection.immutable.Nil.type = List()

scala> val l= List(1,2,3,4,5,56)
l: List[Int] = List(1, 2, 3, 4, 5, 56)

scala> l.head
head   headOption
// 一个list由一个head和一个tail组成 
scala> l.head
res5: Int = 1

scala> l.tail
res6: List[Int] = List(2, 3, 4, 5, 56)

scala> l.tails
res7: Iterator[List[Int]] = non-empty iterator

scala> val l1=List(2,3);
l1: List[Int] = List(2, 3)

scala> val l2=List(4,5,6)
l2: List[Int] = List(4, 5, 6)

scala> val l3=l1:::l2
l3: List[Int] = List(2, 3, 4, 5, 6)

scala> val l4=List(1,1)
l4: List[Int] = List(1, 1)

scala> val l5=1::l4
l5: List[Int] = List(1, 1, 1)

scala> val l6= 1:: 2 :: 3:: Nil
l6: List[Int] = List(1, 2, 3)

为什么不在列表末尾追加元素？
List类的确提供“追加”（append）操作，写作: +，但这个操作很少被使用，因为往列表（末尾）追加元素的操作所需要的时间随着列表的大小线性增加，而使用::在列表的前面添加元素只需要固定的时间（constant time）。
如果想通过追加元素的方式高效地构建列表，可以依次在头部添加完成后，再调用reverse。
也可以用ListBuffer，这是个可变的列表，它支持追加操作，完成后调用toList即可。

Scala中List的常用方法和作用

方法名	方法作用
List() 或者Nil	空List
List(“one”,“two”,“three”)	创建带有三个值的新List[String]
val number=“one”::“two”::“three”	创建带有三个值的新List[String]
List(“a”,“b”):::List(“c”,“d”)	叠加两个列表
number(2)	返回在number列表上索引为2(基于0)的元素
number.count(v=>v.length==4)	计算长度为4的String元素个数
number.drop(2)	返回去掉前两个元素的number列表
number.dropRight(2)	返回去掉后两个元素的number列表
number.exists(v=>v==“one”)	判断是否有值为one的字符串的元素在number里
number.filter(v=>v.length==4)	返回长度为4的元素一次组成的新列表
number.forall(s=>s.endwith(“l”))	判断是否number列表里所有元素都以l结尾
number.foreach(v=>print(v))	对number列表每个字符串执行print语句
number.foreach(print)	同上，更简洁
number.head	返回number列表的第一个元素
number.init	返回number列表除最后一个以外其他元素组成的列表
number.isempty	判断列表是否为空
number.last	返回列表的最后一个元素
number.map(v=>v+“y”)	返回列表里，每个string元素都加上y构成的列表
number.mkString(“,”)	返回用列表的元素组成的字符串
numbe.remove(s=>s.length==4)	返回除了number列表中长度为4的元素后的元素依次组成的新列表
number.reverse	返回逆序组成的新列表
number.sort((s,t)=>s.charAT(0). toLowerCase<t.charAt(0).toLowderCase)	返回列表元素按照第一个字符的字母小写排序之后依次组成的元素的列表
number.tail	返回列表中除了第一个元素之外依次组成的新列表

def sum(nums : Int*):Int = {
	if(nums .length ==){
	  0
	else{
	  nums.head + sum ( nums.tail:_*)}
	}
}

:_* 可以将Seq转变一个可变参数

Set

set是一个非重复的集合，若有重复数据，则会自动去重。

scala> val set = Set(1,2,3,1,2,5)
set: scala.collection.immutable.Set[Int] = Set(1, 2, 3, 5)

Scala同时还提供了集（set）和映射（map）的可变和不可变的不同选

通过调用Set伴生对象的名为apply的工厂方法，实际上调用了scala.collection.immutable.Set的伴生对象的apply方法

要向不可变集添加新元素，可以对集调用+方法，传入这个新元素，+方法会创建并返回一个新的包含了新元素的不可变集。虽然可变集提供了一个实际的+=方法，但不可变集并不直接提供这个方法。

package com.hiszm.scala
object ClassAndObj {
  def  main(args:Array[String]):Unit={
    import scala.collection.mutable
    val s=mutable.Set("hi","szm")
    s+=".cn"
    println(s)
  }
}

Set(szm, hi, .cn)

在那一行，将s初始化成一个新的包含字符串"hi"和"szm"的新的可变集。只要你想，也完全可以不用s+= “.cn"这样的写法，而是写成s.+=(”.cn")。

package com.hiszm.scala
object SetApp {

  def  main(args:Array[String]):Unit={
    println("hello world")
    val arrs="hiszm.cn"
    var i =0
    import scala.collection.mutable
    val map=mutable.Map[Int,String]()
    map +=(1->"hi")
    map +=(2->"szm")
    map +=(3->".cn")
    println(map(2))
  }
}

通过->和+=方法向映射添加键值对。即(1).->("szm");1的整数调用->方法。
如果你更倾向于使用不可变的映射，则不需要任何引入，因为默认的映射就是不可变的。由于没有显式引入，

Map

map是K-V键值对集合。

package org.example

object MapApp {

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

    val map = Map(
      "1" -> "hello" ,
      2 -> "world",
      3 -> "!!!!!"
    )
    println(map.mkString(","))

    println("-----------------------")
    for(x<-map){
      println(x._1+":"+x._2)
    }

    println("-----------------------")

    var keys = map.keys
    var keyIterator = keys.iterator
    while(keyIterator.hasNext) {
      val key = keyIterator.next()
      println(key + "\t" + map.get(key).get)
    }
  }
}

 1 -> hello,2 -> world,3 -> !!!!!
-----------------------
1:hello
2:world
3:!!!!!
-----------------------
1	hello
2	world
3	!!!!!

Tuple

与列表一样，与列表不同的是元组可以包含不同类型的元素。元组的值是通过将单个的值包含在圆括号中构成的。创建过程可加new关键词，也可不加。

package org.example

object TupleApp {

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

    var t=new Tuple3[Int,Int,String](1,99,"hello")
    println(t.toString())

    println("----------------")

    var t2=(9999,"hello")

    println(t2.toString())

    println(t2.swap.toString())


  }

}

(1,99,hello)
----------------
(9999,hello)
(hello,9999)

其他

    val map = Map(
      "1" -> "hello" ,
      2 -> "world",
      3 -> "!!!!!"
    )

    println(map.get(2))
    println(map.get(999))

Some(world)
None

option.scala

@SerialVersionUID(5066590221178148012L) // value computed by serialver for 2.11.2, annotation added in 2.11.4
case object None extends Option[Nothing] {
  def isEmpty = true
  def get = throw new NoSuchElementException("None.get")
}


@SerialVersionUID(1234815782226070388L) // value computed by serialver for 2.11.2, annotation added in 2.11.4
final case class Some[+A](x: A) extends Option[A] {
  def isEmpty = false
  def get = x
}