Scala40道例题与答案

set集合(1-10)

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

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

2、获取a集合的大小

(1)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"
}

}

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()
}
}