【大数据学习之路之Scala语法练习】

熟悉Scala语法练习题

都是从网上找的练习题

一、set相关（1-10）

1、定义一个不可变set集合a，保存以下元素：10,20,30,10,50,40

var  a = Set(10,20,30,40)

2、获取a集合的大小

println(a.size)
5

3、遍历a集合

for(i<- a)println(i)
10
20
50
40
30

4、a集合删除元素50

a -50
res57: scala.collection.immutable.Set[Int] = Set(10, 20, 40, 30)

5、a集合拼接set集合Set(60,80,90)

a++Set(60,80,90)
res59: scala.collection.immutable.Set[Int] = Set(10, 20, 60, 80, 50, 40, 30, 90)

6、a集合拼接列表List(100,300,200)

a++List(100,300,200)
res60: scala.collection.immutable.Set[Int] = Set(10, 20, 50, 40, 300, 30, 200, 100)

7、定义一个可变set集合b,初始元素为：5,6,7,8

import scala.collection.mutable.Set
var b = Set(5,6,7,8)

8、b集合中使用+=添加元素9

b+=9

9、b集合中删除元素5

b-=5

10、b集合使用add添加元素10

b.add(10)

二、Map映射(11-20)

11、构建一个映射map1，内容为"zhangsan" -> 20, “lisi” -> 18, “wangwu” -> “22”

var map1 = Map("zhangsan"->20,"lisi"->18,"wangwu"->"22")
map1: scala.collection.immutable.Map[String,Any] = Map(zhangsan -> 20, lisi -> 18, wangwu -> 22

12、构建一个映射map2，内容为"zhangsan" -> 20, “lisi” -> 18, “wangwu” -> “22”

var map2 = Map("zhangsan"->20,"lisi"->18,"wangwu"->"22")
map2: scala.collection.immutable.Map[String,Any] = Map(zhangsan -> 20, lisi -> 18, wangwu -> 22)

13、构建一个空的映射map3，参数类型为Map[String, Int]

var map3 = Map[String,Int]()
map3: scala.collection.immutable.Map[String,Int] = Map()

14、获取map2中的lisi的年龄

print(map2("lisi"))
18

15、获取所有的map2中的key值

print(map2.keys)
Set(zhangsan, lisi, wangwu)

16、获取所有的map2中的value值

print(map2.values)
MapLike(20, 18, 22)

17、map2中新增一组数据：zhaoliu,25

map2+="zhaoliu"->25

scala> print(map2.values)
MapLike(20, 18, 22, 25)

18、map2中获取zhaoliu的年龄，如果zhaoliu不存在，则返回-1

 map2.getOrElse("zhaoliu",-1)
res49: Any = 25

map2.getOrElse("zhaoliu2",-1)
res50: Any = -1

19、map2中遍历打印所有的key和value

//遍历方式1
map2.foreach(i=>print(i))
(zhangsan,20)(lisi,18)(wangwu,22)(zhaoliu,25)

//遍历方式2
for((x,y)<-map2) println(s"$x $y")
zhangsan 20
lisi 18
wangwu 22
zhaoliu 25

//遍历方式3
for((a,b)<-map2) println(a+" "+b)
zhangsan 20
lisi 18
wangwu 22
zhaoliu 25

20、在map2中添加map1集合

map2 ++= map1

三、Iterator迭代器(21-30)

21、定义一个迭代器iter1，数据为"Hadoop",“Spark”,“Java”

var iter1 = List("Hadoop","Spark","Java").iterator
iter1: Iterator[String] = non-empty iterator

22、遍历iter1，使用while循环并打印输出

while(iter1.hasNext){println(iter1.next)}
Hadoop
Spark
Java

23、定义一个迭代器iter2，数据为10,20,20,30,34,50,60

var iter2 = List(10,20,30,40,50,60).iterator
iter2: Iterator[Int] = non-empty iterator

24、打印出iter2中的最大值

print(iter2.max)
60

25、打印出iter2中的最小值

print(iter2.min)
10

26、打印出iter2的长度

print(iter2.length)
6

27、合并iter2和iter1两个迭代器

scala> var iter3 = iter1++iter2
iter3: Iterator[Any] = non-empty iterator
scala> while(iter3.hasNext){println(iter3.next)}
Hadoop
Spark
Java
10
20
30
40
50
60

28、iter2丢弃前2个元素

scala> iter2.drop(2)
res20: Iterator[Int] = non-empty iterator

scala> while(iter2.hasNext){println(iter2.next)}
30
40
50
60

29、检查iter2是否为空

scala> print(iter2.isEmpty)
true

30、iter2返回前 2个元素的新迭代器

scala> var iter3 = iter2.take(2)
iter3: Iterator[Int] = non-empty iterator

scala> while(iter3.hasNext){println(iter3.next)}
10
20

四、类对象(31-33)

31、创建一个名字为Test01的Object，在Test01中

定义一个student1类,声明三个成员变量，String类型的name,Int 类型的age,String类型的address

scala> :paste
// Entering paste mode (ctrl-D to finish)

object Test01 {
  class student1{
    var name :String = ""
    var age :Int = _
    var address :String = ""
  }
}


// Exiting paste mode, now interpreting.

defined object Test01

32、创建一个名字为Test02的Object，在Test02中

定义一个student2类,声明三个成员变量，String类型的name,Int 类型的age,String类型的address定义成员方法hello(s:String)，方法中打印出s

scala> :paste
// Entering paste mode (ctrl-D to finish)

object Test02 {
  class student2{
    var name :String = ""
    var age :Int = _
    var address :String = ""
    def hello(s: String){
        print(s)
    }
  }
}

// Exiting paste mode, now interpreting.

defined object Test02

33、创建一个名字为Test03的Object，在Test03中

定义一个student3类,声明三个成员变量，String类型的name,Int 类型的age,String类型的address,通过主构造器参数列表定义姓名和年龄字段为张无忌和25，并在主构造器方法中打印出“student3主构造器初始化”

scala> :paste
// Entering paste mode (ctrl-D to finish)

object Test03 {
  class student2{
    var name :String = ""
    var age :Int = _
    var address :String = ""
  }

  class hello(var name:String="张无忌",var age:Int=25){
      println("student3主构造器初始化")
  }
}

// Exiting paste mode, now interpreting.

defined object Test03

五、方法（34-42）

34、编写一个方法method1，输入分数之后能够打印出不及格（小于60分）、及格（60-80）、良好（80-90）、优秀（大于90）

def method1(int: Int): Unit ={
   if (int<60){
     println (s" = 不及格：${int}")
   }else if (60 >=int&&int <80 ){
     println (s" = 及格：${int}")
   }else if (80 <=int&& int<90 ){
     println (s" = 良好：${int}")
   }else if (int >=90){
     println (s" = 优秀：${int}")
   }
 }

//测试结果
scala> method1(10)
 = 不及格：10

scala> method1(100)
 = 优秀：100

35、编写一个方法method2，输入名字，判断该名字是否为laowang，如果是返回true，如果不是返回false（不使用return）

def method2(string: String): Unit ={
      if("laowang".equals(string)){
        print(true)
      }else{
        print(false)
      }
  }
  
//测试结果
scala> method2("w")
false
scala> method2("laowang")
true
scala> 

36、编写一个方法method3，要求能够输入一个大于0的数字参数，能够打印1到该数字范围内的所有数。

def method3(int: Int): Unit ={
    for (i<-1 to int if int>0)println(i)
}

scala> method3(5)
1
2
3
4
5

37、编写一个方法method4，要求能够输入一个大于0的数字参数，能够打印1到该数字范围内的所有偶数。

scala> def method4(int: Int): Unit ={
     |     if (int>0) {
     |       for (i <- 1 to int if i % 2 == 0) println(i)
     |     }
     |   }
method4: (int: Int)Unit

scala> method4(5)
2
4

scala> method4(8)
2
4
6
8

38、编写一个方法method6，要求可以输入任意多个参数(数字类型)，将每个参数乘以100后放入数组并返回该数组。

如：2, 4, 6 返回 Array(200, 400, 600)。

总结：scala中可以直接使用Int*,用来表示多个参数

def method6(num:Int*): Unit ={
    var arr = Array[Int]()
    for(i<- num ){
      arr+=i*100
    }
    println(arr)
}

scala> method6(5)
ArrayBuffer(500)

scala> method6(5,1,2)
ArrayBuffer(500, 100, 200)

39、编写一个方法method7，要求输入一个数字，如果数字大于150则抛出异常，并捕获该异常，捕获异常后打印The number is greater than 150。

提示：throw new Exception(“The number is greater than 150”)

scala> method7(2)
2
scala> method7(222)
java.lang.Exception: The number is greater than 150
  at method7(<console>:27)
  ... 48 elided

40、编写一个方法method8，要求传入两个参数，默认值分别为10,15，返回两个参数的乘积。

def method8(i: Int,j: Int): Unit ={
    println(i*j)
}
scala> method8(1,2)
2

scala> method8(8,2)
16

41、定义一个名为method9的方法，有三个参数，前两个为数字类型，最后一个参数为f1函数（该函数类型参数接受两个数字类型参数，返回值也是数字类型），该method9方法返回值为数字类型。定义一个函数f1两个参数分别为x,y都为数字类型，执行返回结果是两个参数的和

scala> def method9(i: Int,j: Int,f1: (Int,Int)=>Int): Int ={
     |       f1(i,j)-i-j
     |   }
method9: (i: Int, j: Int, f1: (Int, Int) => Int)Int

scala>   def f1(x: Int,y: Int): Int ={
     |       x+y
     |   }
f1: (x: Int, y: Int)Int

scala> method9(1,2,f1)
res59: Int = 0

scala> method9(1,5,f1)
res60: Int = 0

42、编写一个方法method10，要求有两个参数，两个参数都为大于0的数字，要求能够打印1到第一个参数数字范围内的所有数，在打印过程中遇到与第二个参数相乘大于200就停止。

def method10(a:Int,b:Int): Unit ={
    if(a>1 && b>0){
      for (i <- 1 to a if a*b<=200){
        println(i)
      }
    }else{
      println("请重新输入！")
    }
  }
scala> method10(4,30)
1
2
3
4

scala> method10(12,10)
1
2
3
4
5
6
7
8
9
10
11
12

六、数组（43-49）

43、使用filter过滤器,过滤出来偶数

小总结：写到这里，有点理解_的意思了

scala> var arr = ArrayBuffer(1,2,3,4,5,6)
arr: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4, 5, 6)

//遍历一下数组【也可以写成arr.foreach(x=>println(x))】
arr.foreach(println(_))
1
2
3
4
5
6

//用到arr.filter，先输出一下试试
scala> println(arr.filter(x=>x%2==0))
ArrayBuffer(2, 4, 6)

//将过滤后的数组遍历取出，这里使用_
scala>   arr.filter(_%2==0).foreach(println(_))
2
4
6

44、使用map把arr1数组中每一个元素都取出来放到一个全新数组

arr.map(x=>x).foreach(println(_))
1
2
3
4
5
6

45、删除arr1数组下标为0的数据

scala>  arr -= arr(0)
res19: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(2, 3, 4, 5, 6)

scala>  arr.foreach(println(_))
2
3
4
5
6

46、arr1数组从下标2开始,删除3个元素

scala> arr.remove(2,3)

scala> arr.foreach(println(_))
2
3

47、插入数据到arr1数组, 第一个参数是开始的位置,插入50,66,77

scala> arr.insert(0,50)

scala>   arr.insert(0,66)

scala>   arr.insert(0,77)

scala>   arr.foreach(println(_))
77
66
50
2
3

48、对arr1数组进行降序排列

scala>   arr.sorted
res27: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(2, 3, 50, 66, 77)

scala> arr.sorted.reverse
res28: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(77, 66, 50, 3, 2)

七、元组（49-54）

49、创建一个元组Y1，内部含有zhangsan beijing 20 true 四个数据

scala> var  y1 = ("zhangsan","beijing",1,20)
y1: (String, String, Int, Int) = (zhangsan,beijing,1,20)

scala> print(y1.toString())
(zhangsan,beijing,1,20)

50、 获取元组Y1内的第二个元素（beijing）

scala> y1._2
res32: String = beijing

51、创建一个元组Y2，内部含有(zhangsan ,lisi,wangwu,zhaoliu),(20,30,40,50),(1,0,1,0) 3个数据(每个内部依然是元组)。

现有数据如下图:

姓名	年龄	性别
zhangsan	20	1
lisi	30	0
wangwu	40	1
zhaoliu	50	0

scala> var y2 = (("zhangsan","lisi","wangwu","zhaoliu"),(10,20,30,40),(1,0,1,0)) 

y2: ((String, String, String, String), (Int, Int, Int, Int), (Int, Int, Int, Int)) = ((zhangsan,lisi,wangwu,zhaoliu),(10,20,30,40),(1,0,1,0))

52、获取zhangsan,并输出

scala>   print(y2._1._1)
zhangsan

53、 获取lisi 的年龄,并输出

print(y2._2._2)
20

54、 获取wangwu的性别,并输出

print(y2._3._3)
1