试图一篇搞定Scala基本知识点(尝试中)
0、Scala目录
特殊符号
| 符号 | 操作 | 描述 |
|---|---|---|
| <- | for (ch <- 1 to 3)print(i) | 用作循环 |
| -> | A += (‘I’ -> 1) | 用作map映射 |
| => | x=>x+1 | 符号左侧为函数的变量，右侧为函数的返回值 |
| _ | val array1= (1 to 10).map(_*1) | 集合中某一元素this之意 |
| _ | val m1=methoda(:Double,:Double) | 偏函数 |
| _ | import math._ | 引用的包下所有内容 |
| _ | ch match {case ‘+’ => sign = 1；case _ => sign = 0} | 相当于switch中的default |
| _ | val value=(1,2) print(value._2) 输出2 | 当不需要某个值的时候可以使用_替代 |
| :: | a::b List(List(1, 2, 3), 4, 5, 6) | 把a当成一个元素，前插到b集合 |
| ::: | a:::b List(1, 2, 3, 4, 5, 6) | ab集合合并 |
1、Scala基础
- 声明值和变量
Scala 声明变量有两种方式，一个用 val，一个用 var。
val 变量名 [: 变量类型] = 变量值
var 变量名 [: 变量类型] = 变量值
val定义的值是不可变的，类似于一个常量。
val 和 var 声明变量时都必须初始化。
如何检测一个变量是val还是var?
val是不可变的，而var是可变的,如果不能重新赋值则整个变量是val
常量声明：val name : String="Yang"
可以省略类型:val name="Yang"
变量声明var name : String = "Yang"
name = "Yang2"//变量的值可以修改
函数的声明
def divide(x: Int, y: Int): Int = {
if (y == 0) throw new Exception("Divide by zero")
else x / y
}
- 常用类型
Scala 有 8 种数据类型：Byte、Char、Short、Int、Long、Float、Double以及 Boolean。
Scala 并不区分基本类型和引用类型，所以这 些类型都是对象，可以调用相对应的方法
在 Scala 中通过方法进行类型转换，不像 Java 的强制类型转换。
- 算术和操作符重载
±*/%可以完成和 Java 中相同的工作，但是有一点区别，他们都是方 法。你几乎可以用任何符号来为方法命名。
Scala 中没有++、–操作符，需要通过+=、-=。
//相当于3+8
print(3.+(8))
//4的平方根*4的平方根
print(scala.math.sqrt(4)*scala.math.sqrt(4))
print(scala.math.sqrt(4))
- 调用函数和方法
Scala 中没有静态方法，一般通过单例对象或者伴生对象进行实现。
Scala允许你用数字去乘一个字符串
“crazy”*3 = crazycrazycrazy
//需要导包
print(sqrt(4))
//调用静态方法
print(Int.box(66))
//调用对象方法
print("specialwu".toUpperCase)
//取下标元素 等同于 "specialwu".apply(4)
print("specialwu"(4))
//*相当于一个方法
def * (n: Int): String = {
val buf = new StringBuilder
for (i <- 0 until n) buf append toString
buf.toString
}
print("crazy"*3)
//取最大数
print(10 max 2)
在Scala中如何获取字符串“Hello”的首字符和尾字符？
//获取首字符
"Hello"(0)
"Hello".take(1)
//获取尾字符
"Hello".reverse(0)
"Hello".takeRight(1)
2、控制结构和函数
scala 并没有提供 break 和 continue 语句来退出循环,可以 通过几种方法来做
1、使用 Boolean 型的控制变量
2、使用嵌套函数，从函数中return
3、使用 Breaks 对象的 break 方法。
行尾的位置不需要分号，只要能够从上下文判断出语句的终止即可。但是如果在单行中写多个语句，则需要分号分割。
foreah用法
val l=List(1,3,5,7,9)
l.foreach(println)
//输出13579
一个数字如果为正数，则它的signum为1;如果是负数,则signum为-1;如果为0,则signum为0.编写一个函数来计算这个值
var num = -1
var signnum=6
if(num>0)
signnum=7
else signnum=8
print(signnum)
针对下列Java循环编写一个Scala版本:
for(int i=10;i>=0;i–)System.out.println(i);
for(int i=10;i<=0;i++)System.out.println(i);
//输出10987654321
for(i <- 0 to 10 reverse)print(i)
//输出12345678910
var i=0
while (i < 10){
i=i+1;
print(i)
}
编写一个过程countdown(n:Int)，打印从n到0的数字
def countdown(n:Int){
(0 to n).reverse.foreach(print)
}
编写一个函数product(s:String)，计算字符串中所有字母的Unicode代码（toLong方法）的乘积递归
//取字符串下标0处的字符
println("specialwu".charAt(0))
//除去下标0意外的字符
println("specialwu".drop(1))
//该递归方法如下
def product(s:String):Long={
if(s.length == 1) return s.charAt(0).toLong
else s.take(1).charAt(0).toLong * product(s.drop(1))
}
3、数据结构
使用 yield 关键字便能在 for 表达式中生成新的集合。for-yield 表达式所生成的集合类型将根据被遍历的集
函数值使用for循环本身没返回值，如果加上yield则有返回值
不可变集合：scala.collection.immutable
可变集合：scala.collection.mutable
Scala 优先采用不可变集合。集合主要分为三大类：序列、集、映射。
映射就是 key-value 的集合，就类似于 Java 中的 Map。
不可变构造映射val scores = Map(“Alice” -> 10, “Bob” -> 3, “Cindy” -> 8)
可变映射val scores1 = scala.collection.mutable.Map(“Alice” -> 10, “Bob” -> 3, “Cindy” -> 8)
对偶 “Alice” -> 10
集是不重复元素的集合。集不保留顺序，默认是以哈希集实现。
1、编写一段代码，将a设置为一个n个随机整数的数组，要求随机数介于0和n之间。
def makeArr(n : Int) : Array[Int] = {
val a = new Array[Int](n)
val rand = new scala.util.Random()
for (i <- a) yield rand.nextInt(n)
}
2、用Scala写冒泡排序
val sortArray = Array(12,5,7,9,56,36,2)
for( j <- 0 until( sortArray.length -1)){
for(i<- 0 until sortArray.length - 1 -j ){
if(sortArray(i) > sortArray(i+1)){
val temp = sortArray(i)
sortArray(i) = sortArray(i+1)
sortArray(i+1) = temp
}
}
}
sortArray.foreach(x=> print(x + " "))
3、编写一段WordCount函数，统计传入的字符串中单词的个数
def wordCount(str:String)={
val count = new scala.collection.mutable.HashMap[String, Int]
for(word <- str.split("\\s+"))
count(word) = count.getOrElse(word,0) + 1
count
}
//输出打印print(wordCount("good good study day day up")) Map(study -> 1, up -> 1, day -> 2, good -> 2)
4、编写一个函数，接受一个字符串的集合，以及一个从字符串到整数值的映射。返回整形的集合，其值为能和集合中某个字符串相对应的映射的值。举例来说，
给定Array(“Tom”,”Fred”,”Harry”)和Map(“Tom”->3,”Dick”->4,”Harry”->5)，返回Array(3,5)。提示：用flatMap将get返回的Option值组合在一起。
def main(args: Array[String]): Unit = {
val a = Array("Tom","Fred","Harry")
val m = Map("Tom"->3,"Dick"->4,"Harry"->5)
strMap(a,m).mkString(",")
print(strMap(a,m).mkString(",")) //3,5
}
def strMap(strArr: Array[String], map:Map[String,Int]): Array[Int] = {
//这个过程就像是先 map, 然后再将 map 出来的这些列表首尾相接 (flatten).
strArr.flatMap(map.get(_))
}
5、实现一个函数，作用与mkStirng相同
def main(args: Array[String]): Unit = {
val setString = HashSet[String]("a","b","c")
print(myMakeString(setString)) //输出cab
}
def myMakeString(set : Iterable[String]):String={
if(set!=Nil) set.reduceLeft(_ + _) else ""
}
6、给定整型列表lst，(lst :\ ListInt)(_ :: )得到什么? (ListInt /: lst)( :+ _)又得到什么？如何修改他们中的一个，以对原列表进行反向排列?
val lst = List(1,2,3,4,5)
//a :: b 把a当成一个元素，前插到b集合 List(List(1, 2, 3), 4, 5, 6)
//a :+ b 把b当成一个元素，后插到a集合 List(1, 2, 3, List(4, 5, 6))
println((List[Int]() /: lst)(_ :+ _))
println((List[Int]() /: lst)((a,b)=> b :: a))
//分别输出List(1, 2, 3, 4, 5)
//List(5, 4, 3, 2, 1)
7、编写一个函数，将Int数组转换成二维数组。传入列数作为参数。
举例来说，传入Array(1,2,3,4,5,6)和2列，返回Array(Array(1,2,3), Array(4,5,6))。
val arr = Array(1,2,3,4,5,6,7,8)
divArr(arr,3)
//遍历输出
divArr(arr,3).foreach(a => println(a.mkString(",")))
//1,2,3
//4,5,6
//7,8
8、编写一个并行的wordcount程序，统计字符串中每个字符的出现频率。可以通过并行集合的aggregate函数试试
var str = "aaabbccdddaaa"
//aggregate用于合并来自不同分区的结果的一种关联运算符
val parWordCount = str.par.aggregate(Map[Char,Int]())(
{ (a,b) => a + (b -> (a.getOrElse(b,0)+1)) },
{ (map1,map2)=>
(map1.keySet ++ map2.keySet).foldLeft(Map[Char,Int]()){
(result,k) => result + (k -> (map1.getOrElse(k,0) + map2.getOrElse(k,0)))
}
}
)
print(parWordCount)
//输出结果 Map(b -> 2, d -> 3, a -> 6, c -> 2)
824
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
