Scala 40道基础练习题及答案

Scala 40道基础练习题及答案

set集合(1-10)

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

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

2、获取a集合的大小

Println(a.size)

3、遍历a集合

a.foreach(i => println(i))

4、a集合删除元素50

println(a - 50)

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

println(a ++ Set(60,80,90))

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

println(a ++ List(100,300,200))

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

var b = Set(5,6,7,8)

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

println(b += 9)

9、b集合中删除元素5

println(b -= 5)

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

println(b.add(10))

---

Map映射(11-20)

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

var map1 = Map(“zhangsan” -> 20,“lisi” -> 18,“wangwu” -> “22”)

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

var map2 = Map(“zhangsan” -> 20,“lisi” -> 18,“wangwu” -> “22”)

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

var map3 = MapString, Int

14、获取map2中的lisi的年龄

println(map2.get(“lisi”))

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

println(map2.keys)

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

println(map2.values)

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

println(map2 += “zhaoliu”->25)

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

println(map2.getOrElse(“zhaoliu”,-1))

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

//方式一
map2.foreach(i =>println(i))
//方式二
for((a,b)<-map2)println(a+"-"+b)

20、在map2中添加map1集合

map2 ++= map1

---

Iterator迭代器(21-30)

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

var iter1 = Iterator(“Hadoop”,“Spark”,“Java”)

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

while (iter1.hasNext){
	println(iter1.next())
}

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

var iter2 = Iterator(10,20,20,30,34,50,60)

24、打印出iter2中的最大值

println(iter2.max)

25、打印出iter2中的最小值

println(iter2.min)

26、打印出iter2的长度

println(iter2.length)

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

Iter2 ++ iter1

28、iter2丢弃前2个元素

iter2.drop(2)

29、检查iter2是否为空

println(iter2.isEmpty)

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

iter2.take(2)

---

类对象(31-40)

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

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

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

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

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

object Test02 {
    class student2{
        var name:String=_
        var age:Int=_
        var addrsss:String=_
        def hello(s:String): Unit ={
        	println(s)
        }
    }
}

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

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

object Test03 {
    class student3{
        var name:String=_
        var age:Int=_
        var addrsss:String=_
    }
    class hello(var name:String=“张无忌”,var age:Int=25){
    	println(“student3主构造器初始化”)
    }
}

34、创建一个名字为Test04的Object，在Test04中

• 定义一个student4类
• 声明三个成员变量，String类型的name,Int 类型的age,String类型的address
• 通过主构造器参数列表定义姓名和年龄字段为默认值，并在主构造器方法中打印出“student4主构造器初始化”
• 通过辅助构造器把姓名和年龄更新成赵敏和20，主方法调用辅助构造输出姓名和年龄

object Test04 {
    class student4{
        var name:String=_
        var age:Int=_
        var addrsss:String=_
	}
	
    class hello(var name:String="",var age:String=""){
    println(“student4主构造器初始化”)

        def this(arr:Array[String]) = {
          this(arr(0),arr(1))
          arr(0)="赵敏"
          arr(1)="20"
        }
    1
    2
    3
    4
    5
    }

	def main(args: Array[String]): Unit = {
        var hello=new hello(Array("",""))
        println(hello.name)
        println(hello.age)
    }
}

35、创建一个名字为Test05的Object，在Test05中

• 定义一个student5类
• 声明三个成员变量，String类型的name,Int 类型的age,String类型的address
• 通过主构造器参数列表定义姓名和年龄字段为默认值，并在主构造器方法中打印出“student5主构造器初始化”
  构建两个辅助构造方法，
• 第一个辅助构造方法的参数为name和age为默认值，输出打印“student5调用第一个辅助构造方法”
• 第二个辅助构造方法的参数为address赋值为北京，输出打印“student5调用第二个辅助构造方法”+address

object Test05 {
    class student5{
        var name:String=_
        var age:Int=_
        var addrsss:String=_
    }
    class hello(var name:String,var age:Int,var address:String){
        def this(name:String,age:Int)={
            this(name,age,address="")
            println(“student5调用第一个辅助构造方法”)
    	}
        def this(adderss: String="")={
            this(name="",age=0,address="")
            this.address=“北京”
            println(“student5调用第二个辅助构造方法”+adderss)
        }
    }

    def main(args: Array[String]): Unit = {
        var hello = new hello("")
        println(hello.address)
    }

}

36、创建一个名字为Test06的Object，在Test06中

• 声明一个 String 类型的name赋值为“大数据”
• 定义一个hello方法无参数，输出为“你好”+name
• 在此文件中创建一个student6单例,调用Test06的hello方法

object Test06 {
    var name:String=“大数据”
    def hello(name:String=""): Unit ={
        println(“你好”+name)
    }
    object student6{
        Test06.hello()
    }
}

37、创建一个名字为Test07的类，在Test07中

• 声明一个string类型的name私有变量,赋值为小明
• 定义一个私无参方法，名字为eat，输出为:name+“是吃货！”
• 在此文件中创建一个半生对象Test07，在半生对象中调用Test07类中的eat方法

class Test07 {
    private val name =“小明”
    def eat(): Unit ={
        println(name+“是吃货!”)
    }
    object Test07{
        eat()
    }
}

38、创建一个名字为Test08的类，在Test08中

• 声明一个string类型的name变量,赋值为"继承Test08"
• 再此文件中创建一个cat类，继承Test08类，定义一个无参方法hello，输出name

class Test08 {
val name =“继承Test08”

    class cat extends Test08{
        def hello(): Unit ={
        println(name)
        }
    }
}

39、创建一个名字为Test09的类，在Test09中

• 声明一个可变string类型的name变量，赋值为“单例继承Test08”
• 在此文件中创建一个dog单例继承Test08
• 在此文件中创建Main08单例，使用dog调用name

class Test09 {
    val name =“单例继承Test08”
    object dog extends Test08 {
    }
    object Main08{
        dog.name
    }
}

40、创建一个名字为Test10的Object

• 在此文件中创建一个animal类
• 在animal类中声明一个可变字符串类型的name变量，赋值为动物
• 在animal类中定义一个无参成员方法eat,输出为this.name+“吃水果”
• 在此文件中创建一个cat类
• 在cat类中重写name变量，赋值为猫
• 在cat类中重写方法eat,输出为this.name+“吃鱼”
• 在此文件中创建主方法，创建cat对象，调用eat方法

object Test10 {
    class animal{
    	val name:String =“动物”
        def eat(): Unit ={
            println(this.name+“吃水果”)
        }
    }
    class cat extends animal {
        override val name:String = “猫”
        override def eat() = {
        	println(this.name+“吃鱼”)
        }
    }

    def main(args: Array[String]): Unit = {
        val cat =new cat()
        cat.eat()
    }
}