Scala100道练习题答案

package Test.E1
import scala.collection.mutable.Set
import scala.collection.mutable.Map
import scala.collection.immutable.List
import scala.io.StdIn
import scala.util.control.Breaks
import scala.collection.mutable.ArrayBuffer
import scala.util.Random
/**
  * @author ChinaManor
  *         #Description T2
  *         #Date: 4/8/2021 18:03
  */
object T2 {
  //  set集合(1-10)
  //  1、定义一个不可变set集合a，保存以下元素：10,20,30,10,50,40
  def t1()={
    val set =Set(10,20,30,10,50,40)
    println(set)
  }
  //  2、获取a集合的大小
  def t2(): Unit = {
    val set =Set(10,20,30,40,50)
    println(set.size)
  }
  //  3、遍历a集合
  def t3(): Unit = {
    val set =Set(10,20,30,40,50)
  for (i <- set) println(i)
  }
  //  4、a集合删除元素50
  def t4(): Unit = {
    val set =Set(10,20,30,40,50)
    set -= 50
    for (i <- set) println(i)
  }
  //  5、a集合拼接set集合Set(60,80,90)
  def t5(): Unit = {
    val set =Set(10,20,30,40,50)
    val a =Set(60,80,90)
    set ++a
    for (i<- set) println(i)
  }
  //  6、a集合拼接列表List(100,300,200)
  def t6(): Unit = {
    var set =Set(10,20,30,40,50)
    var a =List(100,300,200)
     set ++a
    for (i<- set) println(i)
  }
  //  7、定义一个可变set集合b,初始元素为：5,6,7,8
  def t7(): Unit = {
    var set =Set(5,6,7,8)
    println(set.mkString)
  }
  //  8、b集合中使用+=添加元素9
  def t8(): Unit = {
    var b =Set(5,6,7,8)
    b+=9
    println(b)
  }
  //  9、b集合中删除元素5
  def t9(): Unit = {
      var b =Set(5,6,7,8)
      b -=5
      println(b)
  }
  //  10、b集合使用add添加元素10
  def t10(): Unit = {
    var b =Set(5,6,7,8)
    b.add(9)
    println(b)
  }
  //  Map映射(11-20)
  //  11、构建一个映射map1，内容为"zhangsan" -> 20, "lisi" -> 18, "wangwu" -> "22"
  def t11(): Unit = {
        val map1 =Map("zhangsan"->20,"lisi"->18,"wangwu"->22)
    println(map1)
  }
  //  12、构建一个映射map2，内容为"zhangsan" -> 20, "lisi" -> 18, "wangwu" -> "22"
  def t12(): Unit = {
    val map2 =Map("zhangsan"->20,"lisi"->18,"wangwu"->22)
//    println(map2)
    //  14、获取map2中的lisi的年龄
//    println(map2("lisi"))
    //  15、获取所有的map2中的key值
//    println(map2.keys)
//    map2.keys.foreach(i =>
//         println("Key ="+ i)
//    )
    //  16、获取所有的map2中的value值
//    println(map2.values)
    //  17、map2中新增一组数据：zhaoliu,25
    map2 +=("zhaoliu" ->25)
    //  18、map2中获取zhaoliu的年龄，如果zhaoliu不存在，则返回-1
    println(    map2.getOrElse("zhaoliu","-1")
    )
    //  19、map2中遍历打印所有的key和value
    for(x <- map2)println(x)
    for((key,value) <- map2)println(key+"\t"+value)
    //  20、在map2中添加map1集合
  }
  //  13、构建一个空的映射map3，参数类型为Map[String, Int]
  def t13(): Unit = {
    val map3 =Map[String, Int]()
    println(map3)
  }
  //  方法（21-30）
  //  以下10道题目需要倒入两个包
  //  21. 编写一个方法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}")
      }
  }
  //  22. 编写一个方法method2，输入名字，判断该名字是否为laowang，如果是返回true，如果不是返回false（不使用return）
    def method2(string: String): Unit ={
      if (string.equals("laowang")){
          println("true")
      }else {
        println("false")
      }
    }
  //  23. 编写一个方法method3，要求能够输入一个大于0的数字参数，能够打印1到该数字范围内的所有数。（2种方式）
  def method3(int: Int): Unit ={
//        if (int>0){
//    val i = Random.nextInt(int)+1
//          for (i<-1 to i)println(i)
//        }
    val i = Random.nextInt(int)+1
    for (i<-1 to i if (int>0))println(i)
  }
  //  24. 编写一个方法method4，要求能够输入一个大于0的数字参数，能够打印1到该数字范围内的所有偶数。
  def method4(int: Int): Unit ={
    if (int>0){
      val i = Random.nextInt(int)+1
      for (i<-1 to i if i%2==0)println(i)
    }
  }
  //  25. 编写一个方法method5，要求能够输入一个大于0的数字参数，能够打印1到该数字范围内的所有奇数，并且该奇数不能被5整除。
  def method5(int: Int): Unit ={
    if (int>0){
      val i = Random.nextInt(int)+1
      for (i<-1 to i if i%2==1&& i%5 !=0)println(i)
    }
  }
  //  26. 编写一个方法method6，要求可以输入任意多个参数(数字类型)，将每个参数乘以100后放入数组并返回该数组。
  //  如：2, 4, 6 返回 Array(200, 400, 600)。
  def method6(num:Int*): Unit ={
//    num:Int*
      var arr = new ArrayBuffer[Int]()
          for(i<- num ){
            arr+=i*100
          }
    println(arr)
  }
  //27. 编写一个方法method7，要求输入一个数字，如果数字大于150则抛出异常，并捕获该异常，捕获异常后打印The number is greater than 150。
  //提示：throw new Exception("The number is greater than 150")
  def method7(num:Int): Unit = {
    if (num>150)throw new Exception("The number is greater than 150")
    //      try {
    //        num
    //      } catch {
    //        case num>150 =>println("The number is greater than 150")
    //      }
  }
  //   println(method7(151))
  //28. 编写一个方法method8，要求传入两个参数，默认值分别为10,15，返回两个参数的乘积。
  def method8(a:Int=10,b:Int=15): Int=a*b
  //    println(method8())
  //29. 定义一个名为method9的方法，有三个参数，前两个为数字类型，最后一个参数为f1函数（该函数类型参数接受两个数字类型参数，返回值也是数字类型），该method9方法返回值为数字类型。定义一个函数f1两个参数分别为x,y都为数字类型，执行返回结果是两个参数的和
  var function = (a:Int,b: Int) => a+b
  def method9(x:Int,y:Int,f1:(Int,Int)=>Int): Int={
    f1(x,y)
  }
  //    println(method9(10,20,function))
  //30. 编写一个方法method10，要求有两个参数，两个参数都为大于0的数字，要求能够打印1到第一个参数数字范围内的所有数，在打印过程中遇到与第二个参数相乘大于200就停止。
  def method10(a:Int,b:Int): Unit = {
    for (i<- 1 to a if a>0 if b>0 if i*b<=200){
      println(i)
    }
  }
  //    method10(10,40)
  //  28. 编写一个方法method8，要求传入两个参数，默认值分别为10,15，返回两个参数的乘积。
  //  29. 定义一个名为method9的方法，有三个参数，前两个为数字类型，最后一个参数为f1函数（该函数类型参数接受两个数字类型参数，返回值也是数字类型），该method9方法返回值为数字类型。定义一个函数f1两个参数分别为x,y都为数字类型，执行返回结果是两个参数的和
  //  30. 编写一个方法method10，要求有两个参数，两个参数都为大于0的数字，要求能够打印1到第一个参数数字范围内的所有数，在打印过程中遇到与第二个参数相乘大于200就停止。
  //  数组（31-40）
  //  31、定义一个数组arr1内容为1-10
      def a1(): Unit ={
      val arr =Array(1,2,3,4,5,6,7,8,9,10)
      arr.foreach(println)
  }
  //  32、使用filter过滤器,过滤出来偶数
  def a2(): Unit ={
    val arr =ArrayBuffer(1,2,3,4,5,6,7,8,9,10)
//      println(arr.filter(_%2 ==0).mkString)
  //  33、使用map把arr1数组中每一个元素都取出arr(i)-=arr(i)来放到一个全新数组
        val ints = arr.map(x=>x)
//    println(ints.mkString)
  //  34、使用foreach打印出arr1数组中的元素
//      arr.foreach(println)
  //  35、翻转数组arr1
//        println(arr.sorted.reverse.mkString)
  //  36、修改数组arr1中下标为0的数据为100
//      arr(0)=100
//    println(arr)
  //  37、删除arr1数组下标为0的数据
//      arr -= arr(0)
//    println(arr)
    //  38、arr1数组从下标2开始,删除3个元素
        for(i<-0 to arr.length-1 ){
            if (i>=2&&i<5){
              arr.remove(i)
            }
            println(arr(i))
        }
    //  39、插入数据到arr1数组, 第一个参数是开始的位置,插入50,66,77
//    茴香豆有四种写法
//          arr.insert(0,50)
//          arr.insert(0,66)
//          arr.insert(0,77)
        var arrY = ArrayBuffer[Int]()
        arrY += 50
        arrY ++= arr
        arrY+=66
        arrY+=77
        arr ++= arrY
//        var arr1 =ArrayBuffer(50,66,77)
//          val value = arr1++arr
//          arr1++=arr
//    println(arr)
    //  40、对arr1数组进行降序排列
        arr.sorted.reverse
  }
  //  List列表（41-70）
  //  41、定义一个列表list1，内容为("a", "b" ,"c","d","e")
    def l1(): Unit ={
    var list1 = List("a", "b", "c", "d", "e")
    //  42、在list1列表开头添加元素t
//          val value = "t":: list1
    val value = List("m","n")
  //  43、在列表开头添加指定列表List("m","n")的元素
//    val v2 = value.mkString::list1
//    println(v2)
    //    44、在列表list1后添加元素1
//          list1 +="1"
    //  45、将列表的所有元素添加到 StringBuilder
//        val builder = new StringBuilder
//          list1.addString(builder)
    //    46、将列表的所有元素添加到 StringBuilder并指定分隔符为","
//          list1.addString(builder,",")
    builder.append(list1)
//    //  47、获取列表索引为0的元素
//          list1.addString(builder,",")
//    //  48、检测列表中是否包含指定的元素a
//          list1.contains("a")
//    //  49、向list1列表中追加数据"a"
//          list1+="a"
//    //  50、去除list1列表的重复元素,并返回新列表
//          list1.distinct
//    //  51、list1丢弃前3个元素，并返回新列表
//          list1.drop(3)
//    //  52、list1丢弃最后2个元素，并返回新列表
//          list1.dropRight(2)
    //  53、检测列表list1是否以指定a结尾
//          val bool = list1.last.equals("a")
//          println(bool)
    //  54、判断是否是以指定a开始的列表list1
//    val bool = list1.head.equals("a")
    val bool = list1.startsWith("a")
    println(bool)
    //  55、获取list1列表的第一个元素
        println(list1.head)
    //  56、在list1中从指定位置 0 开始查找元素d第一次出现的位置
      println(list1.indexOf("d",0))
    //  57、list1返回所有元素，除了最后一个
    //  58、检测列表list1是否为空
    println(list1.isEmpty)
    //  59、返回list1列表最后一个元素
    println(list1.last)
    //  60、返回list1所有元素，除了第一个
    println(list1.tail)
    //  61、提取列表list1的前2个元素
    println(list1.take(2))
    //  62、提取列表list1的后2个元素
    println(list1.takeRight(2))
    //  63、列表list1转换为数组
          val array = list1.toArray
    //  64、list1转换为 Seq
        val seq = list1.toSeq
    //    65、list1转换为 Set
          val set = list1.toSet
    //    66、list1列表转换为字符串
        val str = list1.toString()
    //  67、list1列表反转
          list1.sorted.reverse
    //  68、list1列表排序
          list1.sorted
    //  69、检测list1列表在指定位置1处是否包含指定元素a
        list1.head.equals("a")
        list1.take(0).equals("a")
    //  70、列表list1转换为数组
        list1.toArray
  }
  //  元组（71-76）
  //  71 创建一个元组Y1，内部含有zhangsan   biejing   20  true  四个数据
  def t71(): Unit ={
    val tuple =("zhangsan","beijing",20,true)
    println(tuple.toString())
  //  72 获取元组Y1内的第二个元素（biejing）
    println(tuple._2)
  }
  //  现有数据如下图
  //  姓名  zhangsan  lisi  wangwu  zhaoliu
  //  年龄  20  30  40  50
  //  性别  1 0 1 0
  //  73 创建一个元组Y2，内部含有(zhangsan ,lisi,wangwu,zhaoliu),(20,30,40,50),(1,0,1,0)  3个数据(每个内部依然是元组)。
  def t72()={
    val tuple =(("zhangsan" ,"lisi","wangwu","zhaoliu"),(20,30,40,50),(1,0,1,0))
//    println(tuple.toString())
    //  74 获取zhangsan,并输出
  println(tuple._1._1)
    //  75 获取lisi 的年龄,并输出
  println(tuple._2._2)
    //  76 获取wangwu的性别,并输出
  println(if (tuple._3._3.equals(1)){"男"})
  }
  //  Iterator迭代器(77-86)
  //  77、 定义一个迭代器iter1，数据为"Hadoop","Spark","Java"
    def t77() ={
    val iter1 =Iterator("Hadoop","Spark","Java");
   while (iter1.hasNext)println(iter1.next())
  }
  //  78、遍历iter1，使用while循环并打印输出
  def t78() ={
    val iter1 =Iterator("Hadoop","Spark","Java");
    while (iter1.hasNext)println(iter1.next())
  }
  //  79、定义一个迭代器iter2，数据为10,20,20,30,34,50,60
  def t79() ={
    val iter2 =Iterator(10,20,20,30,34,50,60);
    //  80、打印出iter2中的最大值
    //  81、打印出iter2中的最小值
    //  82、打印出iter2的长度
//    println( iter2.max)
//    println( iter2.min)
//    println( iter2.length)
    //  83、合并iter2和iter1两个迭代器
//    val value = iter2++iter2
//    val value = iter2.drop(2)
    //  84、iter2丢弃前2个元素
    //  85、检查iter2是否为空
    val value = iter2.isEmpty
    println(if(value.equals(false)){"空值"}else if(value.equals(true)){"不空"})
    //  86、iter2返回前 2个元素的新迭代器
    val iter1 = iter2.take(2)
    while (iter1.hasNext)println(iter1.next())
  }
  //  87.变长数组的特点是什么？
//  变长数组指的是数组的长度是可变的，可以往数组中添加、删除元素
  //  88.创建没有初始元素的ArrayBuffer变长数组，语法结构是什么？
//    var/val a  =ArrayBuffer[元素类型]()
  //  89.创建带有初始元素的ArrayBuffer的语法结构是什么？
//  var/val a  =ArrayBuffer(元素1,元素2,元素3......)
  //  90.在定义变长数组的时候需要导入哪个包？
//  import scala.collection.mutable.ArrayBuffer
  //  91.定义变长数组的时候需要注意的点？
//      要导包
  //  92.定义一个变长数组 a,数组类型为string，长度为0
def  t92(): Unit ={
  val a  =ArrayBuffer[String]()
  //  93.向变长数组中添加元素spark
  a+="spark"
  //  94.定义一个包含以下元素的变长数据，10,20,30,40,50
  val b  =ArrayBuffer(10,20,30,40,50)
  //  95.b数组删除元素50
  b-=50
  //  96.在b数组后面追加一个数组Array(70)
  val c  =Array(70)
  b++c
  //  97.使用for循环遍历b数组的内容并输出
  for(i<-b){println(i)}
  //  98.使用for循环遍历b数组的索引下标，并打印元素
  for(i<-0 to b.length -1){println(b(i))}
  for(i<-0 until  b.length -1){println(b(i))}
}
  //  99.在scala中数组常用方法有哪些？
//  - 求和——sum方法
//  - 求最大值——max方法
//  - 求最小值——min方法
//  - 排序——sorted方法
  //  100.定义一个数组，包含以下几个元素（10,20,30,40)，请计算该数组的和
    def t100(): Unit ={
      val t100 =Array(10,20,30,40)
      println(t100.sum)
      //  101.定义一个数组，包含以下几个元素（130,120,310,140)，请计算该数组的最大值
      val t101 =Array(130,120,310,140)
      println(t101.max)
      //  102.定义一个数组，包含以下几个元素（130,120,310,140)，请计算该数组的最小值
      println(t101.min)
      //  103.定义一个数组，包含以下几个元素（130,120,310,140)，请计算该数组的和
      println(t101.sum)
      //  104.定义一个数组，包含以下几个元素（130,120,310,140)，请实现降序排序
      println(t101.sorted.reverse.mkString)
    }
  def main(args: Array[String]): Unit = {
//    t1()
//      t2()
//    t3()
//    t4()
//    t5()
//    t6()
//    t7()
//    t8()
//    t9()
//    t10()
//    t11()
//    t12()
//    t13()
//    t14()
//    method1(90)
//    method2("laowang")
//    method3(9)
//    method4(9)
//    method5(999)
//    method5(999)
//    method5(999)
//    method6(2,4,6)
//    method7(151)
//    a1();
    a2()
//    a3()
//    l1()
//    t71()
//    t72()
//    t77()
//    t77()
//    t79()
//    t92()
//    t100()
  }
//
}