Scala的基本数据结构

数组的定义与使用

一般定义：

val  array = new Array[Int](10)  
println(array(1))    //输出array下标为1的值
println(array)         // 输出arrary(0)的内存地址
array(1) = 10        //赋值
array(2) = 20

通过伴生对象来创建数组

val  array2 = Array(1,2,3,4,5)
println(array2(2))


val array3 = new ArrayBuffer[Int]()
array3.append(1,2,3,4,5)
println(array3.mkString(","))

将定长数组，转换成变长数组:

val toBuffer: mutable.Buffer[Int] = array.toBuffer
toBuffer.append(20,30,40)

变长数组转换成为定长的数组

val toArray: Array[Int] = array3.toArray


val dim = Array.ofDim[Double](3,4)
dim(1)(1) = 11.11
println(dim.mkString(","))

val array5  = ArrayBuffer(1,2,3,4,5,6)
//单层for循环   1 to 5
for(x <- array5){
  println(x )
}

val array6 = Array(1,2,4,3,5,6)
array6.max

array6.min

array6.sum

array6.sorted

元组的创建与遍历

创建元组

val tuple1 = ("helloworld","zhangsan",28,5.0f)

//数据的访问,通过   _下标来进行访问，下标是从1开始的
println(tuple1._1)

for(y <- tuple1.productIterator){
  println(y)
}

tuple1.productIterator.foreach(x => println(x))

Map集合

map集合的操作
定义一个不可变的Map

val  map1 = Map("hello" -> "zhagnsan","age" ->  28 ,"address" -> "地球村")

可变的map

val map2 = scala.collection.mutable.Map("hello" -> "world","age" -> 28)

添加元素

map2.+= ("name" -> 50)
println(map2)

删除元素

map2   .- ("name")

更新元素

//map2("hello") ="abc"
//通过key的覆盖来更细值
map2 +=("hello" -> "小猫")

println(map2)
//如果没有phonNo 这个key，那么就不会更新数据了，但是这个key也会添加进去
map2 +("hello" ->"上海","phonNo" -> "13688886666")

map2 +=("abc" ->"阿猫","hello" ->  "xingqisan")

+   与  +=  区别
第一点，如果没有这个key，都会进行添加
如果有这个key，都会进行覆盖

map2.get("name")
map2.get("nameabc")
//scala当中的option  some  none
//使用key来进行获取值，如果获取到了，那么就直接取出来，
//如果获取不到，那么就用后面的默认值
map2.getOrElse("name","120")

遍历key和value

for((x,y) <- map2){
  println(x )
  println(y)
}

遍历所有的key

for(x <- map2.keys){
  println(x )
}

遍历所有的value

for(x <- map2.values){
  println(x)

}

打印key，value对

for(p <- map2){
  println(p)
}
//tuple  val  tuple2 = ("xxx","")
//将对偶的数组转换成map
val arrayMap = Array(("name","zhangsan"),("age",28))
val toMap: Map[String, Any] = arrayMap.toMap
println(toMap)

list集合

创建一个列表

val list1 = List("abc",128,5.0f)
访问列表当中的元素
println(list1(0))

添加元素 java add

val list2 = list1 :+ 50   50会插入到集合的末尾
val list3 = 100 +: list1     100会插入到集合的开头

//Nil是一个空的集合 （1,2,3,list1）
val list4 = 1 ::2 ::3 :: list1 ::Nil
//（1,2,3，abc,128,5.0f）
val list5 = 1::2 ::3 :: list1

可变的列表list

val list6 = new ListBuffer[String]
list6.append("hello")
list6.append("abc")

set集合常用操作

不可变集合

val set1 = Set("1","1",2,2)
println(set1.mkString(","))

import scala.collection.mutable.Set
可变set

val set2 = Set(1,2,3)
set2.add(20)
val value: mutable.Set[Int] = set2. +=(30)

//相等于将原来集合的数据全部考别出来，+ 40 变成一个新的集合，原来的集合数据没动
val ints: mutable.Set[Int] = set2.+(40)
println(set2.mkString(","))

删除元素

set2 -= (30)
set2.remove(20)

set集合当中遍历元素

for(x <-  set2){
  println(x)
}

集合元素与函数的映射

集合当中的元素与函数的映射

val listFunc = List("name","age","zhangsan","lisi")

//将我们列表当中的每一个元素取出来，传入到这个函数里面去
//MapReduce
//Mapper类  ==》  map()
println(listFunc.map(x  => x +"world"))
//scala当中的下划线 val  tuple2  = Tuple(1,2,3,)
//tuple2._2
//在scala当中规定，如果变量x   在  =>右边只使用了一次，那么可以使用下划线代替
println(listFunc.map(x => x.toUpperCase()))
println(listFunc.map(_.toUpperCase()))

val listFunc2 = List("address","phonNo")
//压平的操作
val flatten: List[Char] = listFunc2.flatten

//listFunc2.flatMap(_ + "world") = listFunc2.flatMap(x => x + "world")
//flatmap是先进行map操作再去flat压平
//压平 ==》  a,d,d,r,e,s,s,w,o,r,l,d
listFunc2.flatMap(x => x + "world")
listFunc2.flatMap(_ +"world")

队列与折叠化简和扫描

//队列的操作
val queue1 = new  mutable.Queue[Int]()
println(queue1)
//队列当中添加元素
queue1 += 1
//队列当中添加集合
//添加集合，会将集合当中的元素全部取出来，放到队列里面去
//添加元素用+，添加集合用++
queue1 ++= List(1,2,3)
println(queue1)


//出队列操作
val dequeue: Int = queue1.dequeue()
println(dequeue)

queue1.enqueue(4,5,6,7,8)
println(queue1)


//获取队列第一个与最后一个元素
println(queue1.head)
println(queue1.last)

//折叠化简与扫描操作
val reduceList = List(1,2,3,4,5)
//MapReduce当中  reduceer  reduce方法
reduceList.reduceLeft((x,y) => x-y)

reduceList.reduceLeft(_ + _ )




val  foldList = List(1,9,2,8)
val foldResult = foldList.fold(10)((x,y) => x+y)
println(foldResult)


//50-1-9-2-8 = 30
val foldLeftResult = foldList.foldLeft(50)((x,y) => x-y)
println(foldLeftResult)

拉链操作

//拉链操作
val  zipList1 = List("name","age","sex")
val zipList2 = List("zhangsan",28,"哈哈")
//zipList1.zip(zipList2)


val zipResult = zipList1 zip zipList2
println(zipResult)
val zipMap: Map[String, Any] = zipResult.toMap
println(zipMap)



val listIterator = List(1,2,"zhangsan")
val iterator: Iterator[Any] = listIterator.iterator
while(iterator.hasNext){
  println( iterator.next())
}