scala学习笔记


本文主要介绍关于scala,学习,java的知识点,对【Scala学习笔记】和【scala学习笔记】有兴趣的朋友可以看下由【Log1119】投稿的技术文章,希望该技术和经验能帮到你解决你所遇的笔记相关技术问题。

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.一般使用不可变的集合,做更改要赋给新的一个集合

二.最简化原则:
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用:::或者++,但是要用 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用++、++=
val list2 = ListBuffer(12, 53, 75)
val arr2 = ArrayBuffer(23, 57, 92)

十二.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不变,追加合并用++=并且做覆盖
12.++这种操作是针对不变的,所以要把得到结果赋给新的一个

十三.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) ) )

本文《Scala学习笔记》版权归Log1119所有,引用Scala学习笔记需遵循CC 4.0 BY-SA版权协议。


注意!

本站转载的文章为个人学习借鉴使用,本站对版权不负任何法律责任。如果侵犯了您的隐私权益,请联系我们删除。



 
  © 2014-2022 ITdaan.com 联系我们: