[scala]学习笔记三——集合

一、Array

1.定长数组的定义：
①一种方式：给出长度

scala> val a=new Array[String](5)
a: Array[String] = Array(null, null, null, null, null)				//null是String类型的默认值

②另一种方式，直接利用object Array中的apply方法定义与声明

scala> val b=Array("Nina","Daming")
b: Array[String] = Array(Nina, Daming)				//类名()=>调用object中的apply()方法

2.定长数组的一些操作

//访问数组长度
scala> b.length
res0: Int = 2

//更改数组中的某一元素
scala> b(1)="sam"
scala> b
res9: Array[String] = Array(Nina, sam)

scala> val c=Array(1,2,3,4)
c: Array[Int] = Array(1, 2, 3, 4)

//数组求和
scala> c.sum
res2: Int = 10

//数组求最大值
scala> c.max
res3: Int = 4

//数组求最小值
scala> c.min
res4: Int = 1

//将数组变成字符串
scala> c.mkString
res5: String = 1234

//将数组变成字符串，并且声明分隔符
scala> c.mkString(",")
res6: String = 1,2,3,4

3.变长数组的定义

val c=scala.collection.mutable.ArrayBuffer[Int]()             //定义可变数组

4.变长数组的操作

//往可变数组中添加单个元素：
c+=1    
c+=2
结果：ArrayBuffer(1, 2)

//往可变数组中添加多个元素
c+=(3,4,5)   
结果：ArrayBuffer(1, 2，3，4，5)

//往可变数组中添加一个数组
c++=Array(6,7,8,9)
结果：ArrayBuffer(1, 2, 3, 4, 5, 6, 7, 8, 9)

//在第n的位置添加某一元素
c.insert(0,0)     //(第几位，添加的元素)
结果：ArrayBuffer(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

//删除某一位的元素
c.remove(1)
结果：ArrayBuffer(0, 2, 3, 4, 5, 6, 7, 8, 9)

//删除某几位元素
c.remove(0,2)		//(第几位开始删除，删除几个)
结果：ArrayBuffer(3, 4, 5, 6, 7, 8, 9)

//删除末尾的几个：
c.trimEnd(3)
结果：ArrayBuffer(3, 4, 5, 6)

//把可变数组变成定长数组：
c.toArray

5.数组的遍历

//一种方式
for(i<-0 until c.length){
    println(c(i))
  }

//另一种方式，更实用
for(ele<-c){
    println(ele)
  }

//倒序遍历
for(i<-(0 until c.length).reverse){
    println(c(i))
  }

二、List (有顺序，且可重复)

1.List[T]：T是泛型，指的是list中的类型，scala会自行推导，因此可以不指明T
2.List的声明与定义：

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

3.连接操作符
1）::

scala> val b=0::a				//把0插在了a前面形成了b
b: List[Int] = List(0, 1, 2, 3, 4)

scala> val d="x"::"y"::"z"::Nil	//字符串相互连接形成了新的字符串list，倒着连接的
d: List[String] = List(x, y, z)

2）::: 用于连接两个list

scala> val e=a:::d
e: List[Any] = List(1, 2, 3, 4, x, y, z)			//Any是Int和String的父类

4.访问list中的元素
1）e.head：返回的是e的第一个元素
2）e.tail：返回的是e除第一个元素之后其他元素组成的列表（伪列表）
3）e.isEmpty：用于判断e是否为空

scala> e.head
res5: Any = 1
scala> e.tail
res6: List[Any] = List(2, 3, 4, x, y, z)
scala> e.isEmpty
res7: Boolean = false

5.长度可变 List
长度可变的List的操作同长度可变的Array操作相同

//定义变长的List
val a=scala.collection.mutable.ListBuffer[Int]()

//往变长List中添加元素
 a+=1
 a+=2
 a++=List(3,4,5)

//删除变长List中的一些元素
 a-=1

//将变长List转变为定长List
 a.toList

6.list的高级函数
1）filter： 起过滤作用

scala> b.filter(x=>x%2==1)		//把b中的奇数给过滤出来了
res8: List[Int] = List(1, 3)

scala> "99 Red Rose".toList.filter(x=>Character.isDigit(x))			//把字符串中的数字给过滤出来了
res12: List[Char] = List(9, 9)

2）takeWhile： 起到的也是过滤作用

//过滤到第一个字母o时，就停止过滤，输出结果，与filter不同
scala> "99 Red Rose".toList.takeWhile(x=>x!='o')			
res13: List[Char] = List(9, 9,  , R, e, d,  , R)

3）map： 把列表中的每个元素进行映射

scala> d.map(x=>x.toUpperCase)		//把d中字母都改成了大写
res16: List[String] = List(X, Y, Z)

//匿名函数的简写，用通配符_来简写匿名函数
scala> d.map(_.toUpperCase)
res17: List[String] = List(X, Y, Z)

4）flatMap： 把多个list打平，放到一个list中

scala> val q=List(List(1,2,3,4),List(5,6,7,8))
q: List[List[Int]] = List(List(1, 2, 3, 4), List(5, 6, 7, 8))

//使用map时，得出的结果是两层的list
scala> q.map(_.filter(_%2==0))
res20: List[List[Int]] = List(List(2, 4), List(6, 8))

//使用flatMap，把最终结果放在一层中
scala> q.flatMap(_.filter(_%2==0))
res21: List[Int] = List(2, 4, 6, 8)

7.list的归约
1）reduceLeft： reduceLeft(op:(T,T)=>T)

scala> a
res22: List[Int] = List(1, 2, 3, 4)

scala> a.reduceLeft(_+_)		//_为通配符
res23: Int = 10

2）fold Left： foldLeft(z:U)(op:(U,T)=>U)

scala> a.foldLeft(0)(_+_)			//(z:U) 是需要给定一个初始值
res24: Int = 10

三、Set (无序、不可重复)

Set的用法，同List一样，但Set是无序，并且不可重复的，剩下的操作都与List相同

scala> var e=Set(1,2,1,3,4,2,3,4,5,6)
e: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3, 4)

四、Range

1.to： 形成的整数数列为 左闭右闭

scala> 1 to 10
res25: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> 1.to(10)
res26: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

2.until： 形成的数列是 左闭右开

scala> 1 until 10
res27: scala.collection.immutable.Range = Range(1, 2, 3, 4, 5, 6, 7, 8, 9)

五、Stream

1.stream is a lazy range！符号为 #::
2.stream只确定序列的第一个值，其余的先不求，之后按需求值

scala> val stream=(1 to 100).toStream
stream: scala.collection.immutable.Stream[Int] = Stream(1, ?)

3.访问Range中的元素：同访问List一样
1）stream.head
2）stream.tail

scala> stream.head
res28: Int = 1

scala> stream.tail
res29: scala.collection.immutable.Stream[Int] = Stream(2, ?)

六、Tuple（元组）

1.元组要是只有两个元素，称为pair
2.元组定义：

//方法一：
scala> val t=(1,2)
t: (Int, Int) = (1,2)

//方法二：
scala> 1->2
res30: (Int, Int) = (1,2)

3.访问元组中的元素：A._x

scala> t._1
res31: Int = 1

4.遍历元组

//元组的遍历，需要注意一下，与其他集合的遍历方法不同
for(i<-0 until t.productArity){
    println(t.productElement(i))
  }

5.使用元组的一个例子

scala> a
res32: List[Int] = List(1, 2, 3, 4)

//定义了一个函数，最终输出一个元组
//元组的第一个值用于list计数
//第二个值记录所有list元素的加和
//第三个值记录每个值与自身乘积的加和
scala> def sumQ(l:List[Int]):(Int,Int,Int)={
      l.foldLeft(0,0,0)((t,v)=>(t._1+1,t._2+v,t._3+v*v))
}

scala> sumQ(a)
res33: (Int, Int, Int) = (4,10,30)

七、Map

1.Map的定义：Map[K,V]

scala> val map=Map(1->"Nina",2->"Linda")
map: scala.collection.immutable.Map[Int,String] = Map(1 -> Nina, 2 -> Linda)

2.有关Map的一些操作
1）通过某个key值取value值

scala> map(1)
res34: String = Nina

//还可以通过get来取值
scala> map.get(1)
res0: Option[String] = Some(Nina)

scala> map.get(1).get
res1: String = Nina

//getOrElse 当查找的关键字不存在时，也不会报错，并可以给出一个默认的值
scala> map.getOrElse(3,"Lily")
res2: String = Lily

2）判断是否包含某个key值

scala> map.contains(2)
res35: Boolean = true

3）查看Map中的key集合

scala> map.keys
res36: Iterable[Int] = Set(1, 2)

4）查看Map中的values集合

scala> map.values
res37: Iterable[String] = MapLike(Nina, Linda)

5）Map中新添加一个键值对

scala> map
res39: scala.collection.immutable.Map[Int,String] = Map(1 -> Nina, 2 -> Linda)
scala> map+(3->"Nancy")
res38: scala.collection.immutable.Map[Int,String] = Map(1 -> Nina, 2 -> Linda, 3 -> Nancy)

6）Map中减掉一个键值对

scala> map
res39: scala.collection.immutable.Map[Int,String] = Map(1 -> Nina, 2 -> Linda)
scala> map-(2)
res40: scala.collection.immutable.Map[Int,String] = Map(1 -> Nina)

7）Map中添加多个元素 ++

scala> map
res41: scala.collection.immutable.Map[Int,String] = Map(1 -> Nina, 2 -> Linda)
scala> map++List(3->"Amy",4->"Daming")
res42: scala.collection.immutable.Map[Int,String] = Map(1 -> Nina, 2 -> Linda, 3 -> Amy, 4 -> Daming)

8）Map中减掉多个元素 –

scala> map++List(3->"Amy",4->"Daming")--List(1,2)			//List中只给出关键字即可
res43: scala.collection.immutable.Map[Int,String] = Map(3 -> Amy, 4 -> Daming)

9）Map遍历

//一种方式：			比较直接且方便
for((key,value)<-map){
    println(key+" : "+value)
  }
  
  //另一种方式：
  for(key<-map.keys){
    println(key+" : "+map.getOrElse(key,"N"))
  }