最新Scala学习笔记

Scala学习笔记

一.scala相关

1._.charAt(0)表示首字母

2.符号使用：

循环<-
=>拉姆达表达式
->map

3.：后面跟数据类型

4.list.insert（指定位置，多个数据）指定添加

5.不可变命名语法

val set = mutable.set(,,,)
val list2 = ListBuffer(12, 53, 75)
val arr2 = ArrayBuffer(23, 57, 92)

6.rdd数组中有数组，遍历方式为

glomRDD.collect().foreach(data=>println(data.mkString(",")))

7.rdd不会回行，使用collect().mkString(",")

8.一般使用不可变的RDD，做更改转换为新的一个RDD

二.最简化原则：

val mapRDD: RDD[Int] = rdd.map((num:Int)=>{num*2})
val mapRDD: RDD[Int] = rdd.map((num:Int)=>num*2)
val mapRDD: RDD[Int] = rdd.map(num=>num*2)
val mapRDD: RDD[Int] = rdd.map(num=>num*2)
val mapRDD: RDD[Int] = rdd.map(_*2)

三.创建用伴生对象：

val listname = List(数据)
val listname = ListBuffer(数据)
val listname = Array(数据)   
val listname = ArrayBuffer(数据)   

四.通用语法

1.按照集合类型生成字符串

println(set)、println(list)

2.输出元素自定义分隔符：

println(list.mkString("-"))

3.判断包含

1.list.contains(23)
2.set.contains(23)

五.修改、增加元素

1.list(3)=2

2.array和list通用增加+：，：+

3.list可用+=添加数据，如果在前面加就是666 +=：list

4.list1++=list2可以在list1后面追加list2

5.++=:是反过来追加

6.list加list用：：：或者++，但是要赋值给list3 val list3 = list1 ++ list2

六.添加数组

1.array和list增加array和list都用++就可以

2.array.insertAll(插入位置, newArr)插入数组

3.array.prependAll(newArr)在前面加数组

4.array.prepend前面加数据

5.array.append后面加数据

七.删除方式

1.list.remove(删除位置)

2.list -= 删除元素

八.打印方式

1.打印用array.foreach(println)

2.或者println(array.mkString(“，”))

3.或者for(i <- list.indices) println(list(i))

4.也可以for(elem <- list) println(elem)

5.迭代器 for (elem <- list.iterator) println(elem)

九.双重循环

1.双重循环用一个for加if
2.for循环用 i <- 1 to 10用；隔开，如果写成 j = 10 - i 表明j是一个引入变量
3.也可以写成

	for{
	i <- 1 to 10
	j= 10 - i 
	}

十一.Set

(1)不可变Set：

1.val set01=Set(数据,数据),可以用来数据去重
2.添加元素:set02=set01.+(20),set01是不可变类型的，需要用set02来接受,也可以写成set1 + 20
3.set是无序的
4.合并set用:set2 ++set3
5.删除某个元素用:set02 - 元素

(2)可变Set：

1.定义方式：

val set = mutable.set(,,,)

2.不能直接用＋来添加数据，要用新的set2来获取，可以调用+=添加元素或者用set.add（）
3.删除元素用:-=或者set.remove,set.remove底层调用的-=
4.合并set用++、++=

十二.Map

1.Map类型

(val map1:Map(String,Int,自定类型)) = Map()

2.可以直接打印查看:

val map1=Map("a"->13, "b"->25,"Hello"->3)
println(map1)

3.如果使用遍历：

map1.foreach(println)

会得到一下形式

(a,13)
(b,25)
(hello,3)

4.取所有key，value

for(key <- map1.keys){
println(s"$key--->${map.get(key)}")
}

5.访问某一个key的value

printlv(map1.get("a").get)
//最好用map1.getOrElse("c",0),如果c没有值就返回0不会报异常
//简化：println(map1("a"))

6.可变map，map都是无序的

val map1 =mutable.Map("a" ->13)

7.添加1:

map1.put("c",5)
map1.put("d",9)

8.添加2:

map +=（"e"，7）

9.删除:

map.remove("c"指定key就可以),或者map1 -=“d”

10.修改:

map1.updete（“c”，5）如果不存在就是插入，如果存在就是修改

11.合并用:++赋值给第三个map，原来的map不变，追加合并用++=并且做覆盖

十三.Queue

1.可变队列

val queue = new mutable.Queue[String] ()

1.1入队

queue.enqueue("a","b")
println(queue)

1.2出队

queue.dequeue

2.不可变队列

val queue2=Queue("a","b")

需要用一个新队列去接受

val queue3 =queue2.enqueue("d")

十四.元组

1.元组是将多个无关的数据封装为一个整体，最大22个元素，可以理解为一个容器， 里面存着各种相同或不同类型的数据

2.声名元组(相同或不同的数据类型，，，，)，
3.创建元组:

 val tuple =（"hello",100,'a',true）,println(tuple)

4.访问数据：

println（tuple._1）
println（tuple._2）
println（tuple._3）
println（tuple._4）
println（tuple.productElement(0)）

5.遍历元组：

for(elem <- tuple.productIterator)
println(elem)

6.可嵌套：

val mulTuple = ("hello",(23,"scala"))

访问"scala"

println(mulTuple._2._2)

十五.特定衍生集合操作

（1）获取集合的头(头、尾的称法是针对list)

println(list1.head)

（2）获取集合的尾（不是头的就是尾）

println(list1.tail)

（3）集合最后一个数据

println(list1.last)

4）集合初始数据`（不包含最后一个）

println(list1.init)

（5）反转

println(list1.reverse)

（6）取前（后）n 个元素

println(list1.take(3))
println(list1.takeRight(3))

（7）去掉前（后）n 个元素

println(list1.drop(3))
println(list1.dropRight(3))

（8）并集

 println(list1.union(list2))

（9）交集

println(list1.intersect(list2))

（10）差集

 println(list1.diff(list2))

（11）拉链
注:如果两个集合的元素个数不相等，那么会将同等数量的数据进行拉链，多余的数据省略不用。

println(list1.zip(list2))

（12）滑窗

list1.sliding(2, 5).foreach(println)

十六.常用计算函数

1.求和 list.sum

var sum = 0
for (elem <- list){
  sum += elem
}
println(sum)

println(list.sum)

2.求乘积 list.product

println(list.product)

3.最大值 list.max list.maxBy

println(list.max)
println(list2.maxBy( (tuple: (String, Int)) => tuple._2 ))
println(list2.maxBy( _._2 ))

4.最小值 list.min list.minBy

println(list.min)
println(list2.minBy(_._2))

5.排序
5.1 sorted

val sortedList = list.sorted
println(sortedList)
//从大到小逆序排序
println(list.sorted.reverse)
// 传入隐式参数
println(list.sorted(Ordering[Int].reverse))
println(list2.sorted)

5.2 sortBy

println(list2.sortBy(_._2))
println(list2.sortBy(_._2)(Ordering[Int].reverse))

5.3 sortWith

println(list.sortWith( (a: Int, b: Int) => {a < b} ))
println(list.sortWith( _ < _ ))
println(list.sortWith( _ > _))

十七.常用方法

1.过滤 filter

// 选取偶数
val evenList = list.filter( (elem: Int) => {elem % 2 == 0} )
println(evenList)

// 选取奇数
println(list.filter( _ % 2 == 1 ))

2.映射 map

// 把集合中每个数乘2
println(list.map(_ * 2))
println(list.map( x => x * x))

3.扁平化 flat

val nestedList: List[List[Int]] = List(List(1,2,3),List(4,5),List(6,7,8,9))

val flatList = nestedList(0) ::: nestedList(1) ::: nestedList(2)
println(flatList)

val flatList2 = nestedList.flatten
println(flatList2)

4.扁平映射 flatmap(一般直接用flatmap就可以)

// 将一组字符串进行分词，并保存成单词的列表
val strings: List[String] = List("hello world", "hello scala", "hello java", "we study")
val splitList: List[Array[String]] = strings.map( _.split(" ") )    // 分词
val flattenList = splitList.flatten    // 打散扁平化

println(flattenList)

val flatmapList = strings.flatMap(_.split(" "))
println(flatmapList)

5.分组 groupBy

// 分成奇偶两组
val groupMap: Map[Int, List[Int]] = list.groupBy( _ % 2)
val groupMap2: Map[String, List[Int]] = list.groupBy( data => if (data % 2 == 0) "偶数" else "奇数")

println(groupMap)
println(groupMap2)

// 给定一组词汇，按照单词的首字母进行分组
val wordList = List("china", "america", "alice", "canada", "cary", "bob", "japan")
println( wordList.groupBy( _.charAt(0) ) )