学习scala ：流程控制+数组练习题

前言：题目参考于《快学scala》

流程控制语法和练习

package com.feng.scala

import scala.io.StdIn

/**
  * Created by Feng on 2020/1/2 19:52
  * CurrentProject's name is scala
  * 练习：Scala 的流程控制语句
  * 注意1： Scala 中的 try catch finally 和java中差不多一样
  * 注意2： Scala 中没有 continue 和 break
  * 注意3： 想要退出循环，可以用 scala.util.control.Breaks.break方法或直接return
  */
object ScalaProcess {

  def main(args: Array[String]): Unit = {
    // 运行 if 表达式的方法
    try {
       /*打印结果：
        * age 小于 20
        * 10
        */
      ifExpression()
    } catch {
      // 捕获运行时异常
      case e1:RuntimeException => e1.printStackTrace()
    } finally {
      // do something
    }

    // 块表达式
    println("块表达式")
    val result = blockExpression()
    println(result)
    // while 循环
    println("while 循环")
    whileExpression()
    // for 循环
    println("for 循环")
    forExpression()
    // 模式匹配
    println("match")
    matchExpression()
    // 键盘输入
    println("StdIn")
    standardInput()

  }


  /**
    * 定义一个返回值为 Unit 的方法
    * if 表达式的练习
    */
  def ifExpression():Unit = {
    // 定义一个 Int 类型常量
    val age:Int = 10
    // 带有返回值
    val result = if(age.equals(20)) "age 大于 20" else "age 小于 20"
    // 控制台打印结果
    println(result)

    if(age > 5)if(age > 6) println(age)
  }

  /**
    * 定义一个返回值为 Int 的方法
    * 块表达式的练习
    * @return
    */
  def blockExpression():Int = {
    // 定义一个块表达式
    val result = {
      // 定义常量
      val num = 1 + 1
      // 返回该常量到 result 中
      num
    }
    // 返回 result 的结果
    // 当 result 中无返回时，此处的 result 返回是 Unit
    result
  }


  /**
    * 定义一个返回值为 Unit 的方法
    * while 循环语句和 do while 语句
    */
  def whileExpression(): Unit ={
    // 定义一个变量
    var num = 0
    // 当num < 10时，给其自增；注意scala 中无“++”操作符
    // 打印结果
    while (num < 10) num += 1;println(num)

    // 重新赋值为0
    num = 0
    // do - while 语句
    do {println(num);num += 1} while (num < 10)
  }

  /**
    * 定义一个返回值为 Unit 的方法
    * for 循环
    */
  def forExpression(): Unit ={
    // 打印 [1,9)
    for (n <- 1 until 10) println(n)

    // 双重循环
    for(m <- 1 to 3; n <- 1 to 3) println(m + "," + n)

    // 双重循环+判断语句
    for(n <- 1 to 3; m <- 1 to 3 if n != m) println(m + "," + n)

    // 使用 IndexedSeq 指定泛型为 Int ，接收 for 的内容
    // 结果：IndexedSeq(2,3,4,5,6,7,8,9,10,11)
    val list:IndexedSeq[Int] = for(n <- 1 to 10) yield n + 1
    // 遍历打印结果
    list.foreach(println)
  }


  /**
    * 匹配
    */
  def matchExpression(): Unit ={
    // 定义数组
    val array = Array("a", "b", "c", "d", "e")

    // 匹配字符串，并打印对应结果
    array.foreach {
      case "a" => println(10)
      case "b" => println(20)
      case "c" => println(30)
      // 其他
      case _ => println(0)
    }

    // 接收 match 的结果
    for (elem <- array) {
      val num:Int = elem match {
        case "a" => 10
        case "b" => 20
        case "c" => 30
        case _ => 0
      }
      println(elem + ", " + num)
    }
  }

  /**
    * 键盘输入
    */
  def standardInput(): Unit ={
    val name = StdIn.readLine("输入你的名字：")
    println("输入你的年龄：")
    val age = StdIn.readInt()
    println(s"你好，$name! 明年你会变成 ${age + 1} 岁！")
  }
}

数组和数组的遍历

package com.feng.scala

import scala.collection.mutable.ArrayBuffer

/**
  * Created by Feng on 2020/1/3 9:34
  * CurrentProject's name is scala
  */
object ScalaArray {

  def main(args: Array[String]): Unit = {
    // 定长数组
    // 定义长度为5的数组
    // 整数默认为0，字符串默认是null
    val nums1:Array[Int] = Array[Int](5)
    val nums2 = Array[Int](5)
    val nums3 = new Array[Int](5)
    val nums4 = Array(1,2,3,4,5)

    // 求和
    val sum4 = nums4.sum
    println(sum4)
    // 最大值
    val max4 = nums4.max
    println(max4)
    // 最小值
    val min4 = nums4.min
    println(min4)

    // 取值，打印1
    println(nums4(0))

    // 变长数组
    val dynamicArray1 = new ArrayBuffer[String]
    val dynamicArray2 = new ArrayBuffer[String]()

    // 在数组结尾增加元素
    dynamicArray2 += "111"
    // 增加多个元素
    dynamicArray1 += ("333", "222")

    // 追加集合
    dynamicArray1 ++= Array("444", "555")
    // 打印
    println(dynamicArray1)

    // 移除最后3个元素
    dynamicArray1.trimEnd(2)

    // 在第一个元素后边插入多个新的元素
    dynamicArray1.insert(1, "666", "777")

    // 从第1个元素开始，移除2个元素，第二个参数不指定时表示移除1个
    dynamicArray1.remove(1, 2)

    // 转成数组
    val myArray = dynamicArray1.toArray

    // 打印数组的 哈希值
    println(myArray)

    // 定长数组转缓冲数组
    val dyArray = myArray.toBuffer
    println(dyArray)

    println("sort2()------->")
    sort2()
  }

  /**
    * 遍历数组：方式1
    */
  def for1(array:Array[Int]): Unit ={
    for (elem <- array)println(elem)
  }

  /**
    * 遍历数组：方式2
    */
  def for2(array:Array[Int]): Unit ={
    for(index <- array.indices)println(array(index))
  }

  /**
    * 遍历数组：方式3
    */
  def for3(array:Array[Int]): Unit ={
    for(index <- array.indices)println(array(index))
  }

  /**
    * 遍历数组：方式4
    * 反向遍历
    */
  def for4(array:Array[Int]): Unit ={
    for (index <- array.indices.reverse)println(array(index))
  }

  /**
    * 遍历数组：方式5
    * 简写：array.foreach(println)
    */
  def for5(array:Array[Int]): Unit ={
    array.foreach(element => println(element))
  }


  /**
    * 数组转换：由现有的数组产生新的数组
    * 方式1：
    */
  def transformArray1(): Unit ={
    val nums = Array(1,2,3,4,5,6,7,8,9,10)

    val nums1 = for (elem <- nums if elem % 2 == 0) yield 10 * elem
    nums1.foreach(println)
  }

  /**
    * 数组转换方式2：
    */
  def transformArray2(): Unit ={
    val nums = Array(1,2,3,4,5,6,7,8,9,10)
    val nums1 = nums.filter(_ % 2 == 0).map(_ * 10)
    nums1.foreach(println)
  }


  /**
    * 多维数组
    */
  def matrixArray(): Unit ={
    val matrix = Array(
      Array(1,2,3),
      Array(4,5,6),
      Array(7,8,9)
    )

    for (elem <- matrix) {
      elem.foreach(elem => print(elem + ","))
      println()
    }
  }

  /**
    * 排序：降序
    */
  def sort1(): Unit ={
    val arr = Array(4,2,7,8,1,6)
    val sorted = arr.sortWith(_ > _)

    sorted.foreach(println)
  }

  /**
    * 升序
    */
  def sort2(): Unit ={
    val arr = Array(4,2,7,8,1,6)
    val sorted = arr.sorted
    // 使用指定格式输出
    // [1-2-4-6-7-8]
    println(sorted.mkString("[", "-", "]"))
    // 1-2-4-6-7-8
    println(sorted.mkString("-"))
  }

  /**
    * 排序：升序
    */
  def sort3(): Unit ={
    val arr = Array(4,2,7,8,1,6)
    val sorted = arr.sortWith(_ < _)
    sorted.foreach(println)
  }
}

数组练习题

package com.feng.scala

import scala.collection.mutable.ArrayBuffer

/**
  * Created by Feng on 2020/1/3 10:59
  * CurrentProject's name is scala
  */
object ScalaArrayProblem {
  def main(args: Array[String]): Unit = {
    println("method1 ---->")
    method1(5).foreach(println)
    println("method2 ---->")
    method2().foreach(println)
    println("method3 ---->")
    method3()
    println("method4 ---->")
    method4()
    println("method5 ---->")
    method5()
    println("method6 ---->")
    method6()
  }


  /**
    * 编写一段代码，将 array 设置为一个 n 个随机整数的数组
    * 要求随机数属于 [0,n) 区间
    * @return
    */
  def method1(n:Int): Array[Int] ={
    // 定义长度为 n 的数组
    val array = new Array[Int](n)
    // 导入类
    import scala.util.Random
    // 循环给数组赋随机值
    for (index <- 0 until n){
      array(index) = Random.nextInt(n)
    }
    // 返回结果数组
    array
  }

  /**
    * 编写一个循环，将整数数组中相邻的元素置换。
    * 例如，Array(1,2,3,4,5) 经过置换变为 Array(2,1,4,3,5)
    */
  def method2(): Array[Int] ={
    val array = Array(1,2,3,4,5)

    for(index:Int <- 0 until array.length - 1 if index %2 == 0){
      val temp:Int = array(index)
      array(index) = array(index + 1)
      array(index + 1) = temp
    }
    array
  }

  /**
    * 给定一个整数数组，产生一个新的数组，包含原数组中的所有正值。
    * 以原有顺序排列。之后的元素是所有零或负值。以原有顺序排列。
    */
  def method3(): Unit ={
    var array = Array[Int](1,0,-2,3,6,9,2,-1)

    val result = array.filter(_ > 0)
    array = array.filter(_ <= 0)

    // 原数组
    println(array.mkString("array: ",",",""))
    // 新的数组
    println(result.mkString("result: ", ",",""))
  }

  /**
    * 计算Array[Double] 的平均值
    */
  def method4(): Unit ={
    // 方式1、直接调用api
    val nums:Array[Double] = Array[Double](1.2,2.4,3.6,4.8,0.1)
    val result = nums.sum / nums.length
    println(result)

    // 方式2、循环计算
    var sum:Double = 0.0
    for (elem <- nums) {
      sum += elem
    }
    println(sum / nums.length)
  }

  /**
    * 如何重新组织Array[Int]的元素将他们反序排列。
    * 对于ArrayBuffer[Int]又该怎么做？
    */
  def method5(): Array[Int] ={
    // 当数组是变量
    val array:ArrayBuffer[Int] = ArrayBuffer(1,0,-2,3,6,9,2,-1)
    println(array.reverse.mkString(","))

    // 当数组不可变
    val arr:Array[Int] = Array(1,0,-2,3,6,9,2,-1)
    // 先转换为动态数组
    arr.toBuffer.reverse.toArray
  }


  /**
    * 编写一段代码，产出数组中的所有值。去掉重复项
    */
  def method6(): Unit ={
    import scala.util.Random
    // 定义10个长度的数组
    val array:Array[Int] = new Array[Int](10)
    // 使用随机数存储进入array中
    for (index <- array.indices) {
      array(index) = Random.nextInt(10)
    }

    println(array.mkString("原数组：",",",""))
    println(array.distinct.mkString("去重后：",",",""))
  }
}