scala基础练习，学习scala必备知识点

有一句话叫做：先看懂，然后再手懂。就是先脑子会代码，然后再手练熟了代码，这确实是程序员的必备精神之一，多学多敲多看。
作为一个scala初学者，有必要先学习scala的基础
scala基础学习，点进去你就会有收获了
特别注意scala严格遵循大小写，关键字名不能写错

下面就让我们来练习一下下，我们可爱的scala的基础吧，
基础学习一：
定义数组，追加数组，以及删除添加数组

import scala.collection.mutable.ArrayBuffer

object shimmer2 {
  def main(args: Array[String]): Unit ={
    //添加元素
      //定义定长数组：定义长度为8的定长数组，数组中的每个元素都是初始化为0
       val  arr1 =new Array[Int](8)
      //打印定长数组：内容就是数组的hashcode值
      println(arr1)

      //定义变长数组（数组需要导入包：import scala.collection.mutable.ArrayBuffer）
      val ab:ArrayBuffer[Int]  = ArrayBuffer[Int]()
      //向变长数组中追加数组
      ab+=1
      println(ab)
      //向变长数组中追加多个元素
      ab+=(2,3,4,5)
      println(ab)

      //把定长数组追加到变长数组中
      //追加一个定长数组
      ab++=Array(6,7)
      println(ab)
      //追加一个变长数组（数组缓冲）
      ab ++=ArrayBuffer(8,9)
      println(ab)
    //在变长数组的某个位置插入元素
      ab.insert(0,-1)
      ab.insert(0,0)
      println(ab )
    //在变长数组中删除某个元素
      ab.remove(0)
      println(ab)

  }
}

结果：

基础练习二：
数组的遍历：

object ArreyDemo {
  def main(args: Array[String]): Unit = {
    //定义数组
    val array= new Array[Int](8)//方式一
    val myarr=Array(1,9,2.5,6.3,72)//方式二

    //打印输出数组中的所有元素
    for (x<-myarr){
      println(x+" ")
    }
    //打印换行
    println()

    //计算数组中所有元素的和
    var total =0.0;
    for  (i<- 0 to (myarr.length-1)){
      total+=myarr(i)
    }
    println("总和为："+total)

    //查找数组中的最大值
    //注意：<-中间不要出现空格，像这样会报错：< -
    var max= myarr(0)
    for (i<- 1 to (myarr.length - 1)){
      //如果if语句只有一条可以去掉{}
      if(myarr(i)>max)
        max =myarr(i)
    }
    println("最大值："+max)
  }

}

基础练习三：
数组的转换

object Arrey {
  def main(args: Array[String]): Unit = {
    //数组转换就是通过yield关键字符原始的数组进行转换，会产生一个新的数组，然而原始的数组保持不变。
    //scala使用var定义变量，val定义常量
    // 定义一个数组实现将偶数取出乘以10后生成一个新的数组

    val arr =Array(1,2,3,4,5,6,7,8,9)
    var newArr=for (e<-arr if e%2==0) yield e*10//20 40 60 80
    //如果直接打印会打印出hash值，必须通过toBuffer转换
    println(newArr.toBuffer)//toBuffer将定长数组变成变长数组,并输出

  }
}

代码结果：

基础练习四：
元组：

object shimmer1 {
  def main(args: Array[String]): Unit = {
    //scala元组是对多个不同类型对象的一种简单封装，它将不同的值用小括号括起来，并用逗号做分隔，即表示元组
    val tuple=("shimmer",1,13)//创建元组，使用逗号进行分隔
    //获取元组中的元素，(tuple._1,2....)元组索引从1开始
    var newtuple = tuple._1
    println(newtuple)

//zip方法，拉链方法,此拉链方法跟Python类似，
// 如果两个数组的长度不一致吗，短的那个数组的长度为组合后数组的长度，长的数组多出的数将被舍弃
    val scores = Array(80,90,70)
    val names= Array("shimmer","admiral","zhuzhu")
    println(names.zip(scores).toBuffer)
    println(scores.zip(names).toBuffer)
  }

}

代码结果:

基础练习五：
集合

一：List:

import scala.collection.mutable.ListBuffer

object set1 {
  def main(args: Array[String]): Unit = {
    //scala中集合三大类：list，set，以及map
    //集合分为可变类型（mutable）和不可变类型(immytable)
    //list不可变类型，定义列表需要导入包import scala.collection.mutable.ListBuffer
    //字符串
    val fruit:List[String] = List("apples","oranges","pears")
    println(fruit.toBuffer)
    //整型
    val nums:List[Int] = List(1,2,3)
    println(nums.toBuffer)
    //空
    val empty:List[Nothing]=List()
    println(empty.toBuffer)
    //二维列表
    val dim:List[List[Int]]=
      List(
        List(1,0,0),
        List(0,1,0),
        List(0,0,1),
        List(1,1,0)
      )
    println(dim.toBuffer)

    //在scala中可以使用Nil和“::”操作列表,定义不同类型的集合,"：："定义多行时需要空一行
    val fruit1="aplles"::("oranges"::("pears"::Nil))
    println(fruit1 )
    //整型
    val nums1=1::(2::(3::(4::Nil)))
    println(nums1)
    //空列表
    val empty1=Nil
    println(empty1.toBuffer)
    //二维列表
    val dim1 = (1::(0::(0::Nil)))::(1::(0::(0::Nil))):: (1::(0::(1::Nil)))::Nil
    println(dim1)

  }

}

代码结果：

object set_apply {
  def main(args: Array[String]): Unit = {
    val fruit="apple"::("oranges"::("pears"::Nil))
    val nums =Nil

    println("Head of fruit:"+fruit.head)
    println("tail of fruit:"+fruit.tail)


    println("Check if fruit is empty:"+fruit.isEmpty)
    println("Check if fruit is empty:"+nums.isEmpty)
    println("Take of fruit:"+fruit.take(2))
    println("Contains of fruit:"+fruit.contains("apples"))
  }
}

代码结果：

二：set
在Scala中，set是没有重复对象的集合，所有元素都是唯一的，默认情况下，Scala使用不可变Set集合，若想使用可变的Set集合，则需要引入 import scala.collection.mutable.Set

import scala.collection.mutable.Set
object True_set {
  def main(args: Array[String]): Unit = {
    //定义set
    val site1 =Set("shimmer","Alex","peiqi")
    val nums:Set[Int]=Set()
    println("Head of names:"+site1.head)
    println("tail of names:"+site1.tail)


    println("查看集合site1是否为空:"+site1.isEmpty)
    println("查看集合nums是否为空:"+nums.isEmpty)
    println("查看两个元素："+site1.take(2))
    println("Contains of fruit:"+site1.contains("apples"))
  }

}

代码结果：

三：map
在Scala中，Map是一种可迭代的键值对（Key/Value）结构，并且键是唯一的。若需要使用可变的Map集合，则需要引入
import scala.collection.mutable.Map

import scala.collection.mutable.Map
object map_practies1 {
  def main(args: Array[String]): Unit = {
    val colors =Map("red"->"#FF0000","azure"->"#F0FFFF")
    val  peruColor=if (colors.contains("red")) colors("red") else 0
    val epr=colors.getOrElse("azure",1)

    println("获取colors中所有的键"+colors.keys)
    println("获取colors中键为red的值"+colors("red"))
    println("获取colors中键为red的值"+colors.values)
    println("检测colors是否为空"+colors.isEmpty)
    println("判断colors是否包含red，包含放回对应值，不存在则返回0"+peruColor)
    println("判断colors是否包含azure，包含放回对应值，不存在则返回1"+epr)



  }

}

代码结果：