scala语言学习笔记3之容器操作

数组

和Java一样，常量引用指向是一个地址，数组引用被标记为常量，只是数组引用的地址不能被更改，数组中的值是可以被更改的。

object TestScala4 {

def main(args: Array[String]): Unit = {
val arr = Array[Int] (1,2,3,4)
println(arr(0))
arr(0)=10;
println(arr(0))
arr.foreach(println)
}
}

可变与不可变

scala中集合分为两个包，一个是immutable不可变的，一个是mutable可变的

链表

根据可变不可变，链表也就有可变链表与不可变链表。添加方式也换了种写法。

object TestScala5 {

def main(args: Array[String]): Unit = {
val list1 = List(1,2,3,4,5,6,7,8)
list1.foreach(println)

val list2 = new ListBuffer[Int]()
list2.+=(33)
list2.+=(34)
list2.+=(35)

list2.foreach(println)
}
}

Set

可以在方法内部导入包，下一行代码将选择就近的包来使用。

Tuple

这个写着确实很爽啊，哈哈，里面啥都能装，装个函数，再传参到一个能传入函数参数函数中。还有Tuple20，果断还是放弃写那么多。

迭代器

object TestScala7 {

def main(args: Array[String]): Unit = {
val t2 = Tuple2(1,"dsfs")
val t3 = Tuple3(1,"sdfs",2)
val t6 = Tuple6(
1,
Array[Int](1,2,3),
List(22,33),
Set("sss","aaa"),
"sdfsd",
(x:Int,y:Int)=>{x+y}
)
def compute(x:Int,y:Int,f:(Int,Int)=>Int): Int ={
return f(x,y)
}
var result = compute(t6._3(0),t6._2(2),t6._6)
println(result)

val iterator = t6.productIterator
while(iterator.hasNext){
println(iterator.next())
}
}
}

Map

学习新语言，肯定不能少了我们的键值对集合。

可变的Map

object TestScala8 {

def main(args: Array[String]): Unit = {
val map01:Map[String,Int] = Map(("a",11),"b"->22,("a",111))
val keys:Iterable[String] = map01.keys
println(map01.get("a"))
println(map01.get("a").get)
println(map01.get("b"))
println(map01.get("b").get)
println(map01.get("c").getOrElse("hello"))

for (elem <- keys) {
println(s"key:$elem value:${map01.get(elem).get}")
}

val map02 = scala.collection.mutable.Map(("a",11),("b",22))
map02.put("hello",33);
println(map02.get("hello").get)
}

}

类MapReduce操作

我们可以使用scala语言对集合进行一次类MapReduce的操作，单词计算需求。全程使用迭代器模式。

object TestScala9 {

def main(args: Array[String]): Unit = {
//将一个文件导入内存
    val lines = List("hello word","hello scala","hello python","life short","I use python")
// Map 过程 采用迭代器模式
    val iteratorLines:Iterator[String] = lines.iterator
val words = iteratorLines.flatMap((element:String)=>element.split(" "))
val mapList = words.map((_,1))
// Reduce 采用迭代器模式
    val reduceMap = scala.collection.mutable.Map[String,Int]()
mapList.foreach(
element=>{
if(reduceMap.contains(element._1)){
reduceMap.put(element._1,reduceMap.get(element._1).get+1)
}else{
reduceMap.put(element._1,1)
}
}
)
reduceMap.foreach(println)
}
}