scala的基本语法

scala中函数的定义

基本格式：
def 函数名(形参)[:返回类型]={
//方法体
}

//如果不是递归函数可以不指定返回类型，但递归函数必须指定返回类型
def show()={
    var a = 15
    a
}

//递归函数必须指定返回类型
//求1~n的和
def fun(n:Int): Int ={
    if( n == 1){
      1
    }else{
      n + fun(n-1)
    }
}

//指定默认参数
def fun2(name: String,left: String="<<",right:String=">>")={
    left+name+right
}

//调用方法时使用带名参数
var c = fun2(name = "aaa")

//可变参数
def fun3(a:Int*)={
    for(i <- a){
      print(i+"\t")
    }
}

scala中过程的定义

基本格式：
def 函数名(形参)={
//方法体
}
过程没有返回值，=可以省略

def fun1(){
    print("====")
}

scala中异常的抓捕

基本格式：
try{
//需要捕捉异常的代码
}catch{
case 对象：异常类型=>代码
case 对象：异常类型=>代码
case 对象：异常类型=>代码
}

def fun2()={
    var a = 10
    var b = 0
    var d = "10"
    var e = "a"
    try {
      var f = d.toInt / e.toInt
    }catch {
      case e1:NumberFormatException=>println("算术转换异常")
    }

    try{
      var c = a/b//没有对异常处理的话，就会导致程序终止
    }catch {
      case  e1:ArithmeticException=>println("算术异常")
    }
}

scala中声明数组

声明定长数组

//声明一个长度为10，存放Int的数组
val arr = new Array[Int](10)

//声明具有初始值的数组,具有值的数组不需要声明类型，scala会自动推断数据类型
val arr1 = Array("Hello","Jerry","smith")

scala中数组的声明建议使用val，节省空间

声明可变数组

val arr2 = new ArrayBuffer[Int]()

定长数组与可变数组的区别

定长数组添加数据

val arr = new Array[Int](10)  
arr(0) = 2
arr(1) = 3

可变数组添加数据

val arr2 = new ArrayBuffer[Int]()
//crud
arr2+=2
arr2+=3
arr2+=4
arr2+=(5,6,7)
//在下标为2的位置依次往后添加1,2,3
arr2.insert(2,1,2,3)

定长数组与可变数组的打印

val arr = new Array[Int](10) 
arr(0) = 2
arr(1) = 3
println(arr)//[I@ea4a92b，打印的是arr的地址

val arr2 = new ArrayBuffer[Int]()
arr2+=2
arr2+=3
arr2+=4
arr2+=(5,6,7)
arr2.insert(2,1,2,3)
println(arr2)//ArrayBuffer(2, 3, 1, 2, 3, 4, 5, 6, 7)

CRUD

增加
增加在上一节已经说过了
删除

	//删除,表示从0开始删除两个
    arr.remove(0,2)
    //删除指定下标的元素
    arr.remove(1)
    //删除指定的元素，找不到就不删
    arr-="Good"
    //从后往前删除两个元素
    arr.trimEnd(2)

修改

//修改下标为0的元素
arr.update(0,"Hehe")

查

//查找String类型数组中长度为5的内容,找到符合要求的就会停止查找
arr.find(_.length==5) 
//表示查找数组中第一次出现该元素的位置
var a = arr.indexOf("world")
println(a)

遍历数组

//遍历数组，1.根据下标遍历 2.增强循环遍历
for (i <- 0 until arr.length){
  print(arr(i)+"\t")
}
println()
for (i <- arr){
  print(i+"\t")
}
println()

定长数组和可变数组的转换

1. 定长数组转换为可变数组

   val arr =Array(1,7,2,9)
   arr.toBuffer
   

2. 可变数组转换为定长数组

   val arr = ArrayBuffer("Mary","had","a","little","lamb")
   arr.toArray
   

数组中常见的算法

1. 求数组中的和

   val arr = Array(1,7,2,9)
   println(arr.sum)//19
   

2. 求数组中的最大值，字符串首先比较第一个字符，第一个字符最大，它就是最大，如果第一个字符有许多相同的，那就比较第二个，以此类推

   val arr2 = ArrayBuffer("Mary","had","a","little","lamb")
   println(arr2.max)//little
   

3. 数组排序

   //数组从大到小排序
   val newArr = arr.sortWith(_>_)//不改变原有数组，而是产生一个新的数组
   println(newArr.toBuffer)
   //数组从小到大排序
   val newArr = arr.sortWith(_<_)//不改变原有数组，而是产生一个新的数组
   println(newArr.toBuffer)
   //只能从小到大
   val newArr1 = arr.sorted
   println(newArr1.toBuffer)
   

4. 把数组转化为字符串

   	//把数组转化为字符串
       var str = arr.mkString
       println(str)//1729
       //每个元素之间加-
       var str1 = arr.mkString("-")
       println(str1)//1-7-2-9
       //前面和后面分别添加<和>每个元素之间加-
   	var str2 = arr.mkString("<","-",">")
   	println(str2)//<1-7-2-9>
   

java和scala的相互调用

java类：

public class People {
    public void show(List list){
        System.out.println(list);
    }
}

scala类：

import scala.collection.JavaConversions
import scala.collection.mutable.ArrayBuffer
object Test8 {
  def main(args: Array[String]): Unit = {
    val arr = ArrayBuffer(1,2,3,4,5,6)
    val p:People = new People()
    p.show(JavaConversions.bufferAsJavaList(arr))//将scala的数组转为java集合
  }
}

练习

1. 编写一段代码，将a设置为一个n个随机数的数组，要求随机数介于0（包含）和n（不包含）之间

   def test1(n:Int){
       var a = new Array[Int](n)
   
       for (i <- 0 until a.length){
         a(i) = Random.nextInt(n)
       }
       for(i <- a){
         print(i+"\t")
       }
   }
   

2. 编写一个循环，将整数数组中相邻的元素置换。例如，Array(1,2,3,4,5)经过置换后变为Array(2,1,4,3,5)

   def test2(){
       val arr = Array(1,2,3,4,5)
       for (i <- 0.until(arr.length,2)){
         var a = 0;
         a = arr(i)
         if(i + 1 < arr.length ){
         arr(i) = arr( i + 1 )
         arr( i + 1 ) = a
         }
       }
       for (i <- arr){
         print(i+"\t")
       }
   }
   

3. 重复前一个练习，不过这一次生成一个新的值交换过的数组。用for/yied

   def test3(){
       var arr = Array(1,2,3,4,5)
       var arr1 = for(i <- 0.until(arr.length))yield {
         if(i % 2 == 0 && (i+1) < arr.length){
           arr(i+1)
         }else if (i == arr.length - 1){
           arr(i)
         }else{
           arr(i-1)
         }
       }
       println(arr1.toBuffer)
   }
   

4. 给定一个整数数组，产出一个新的数组，包含原数组中的所有正值，以原有顺序排列。之后的元素是所有零或负值，以原有顺序排列

   def  test4(){
       val arr = Array(-3,-8,1,0,8,-3,7,-6)
       val arr1 = for (i <- 0 until 2;a <- arr if (a > 0&& i == 0)||(a<=0 && i == 1))yield{
         a
       }
       println(arr1.toBuffer)
   }
   

5. 如何计算Array[Double]的平均值

   def test5(){
       val arr = Array(1.33,2.46,3.67,4.22,5)
       var avg = arr.sum / arr.length
       println("Array(1.33,2.46,3.67,4.22,5)的平均值为："+avg)
   }
   

6. 如何重新组织Array[Int]的元素将它们以反序排列？对于ArrayBuffer[Int]你又该怎么做呢？

   def test6(){
       val arr = Array(1,3,7,4,2,8)
       val arr1 = arr.sortWith(_>_)
       println(arr1.toBuffer)
       val arr2 = ArrayBuffer(1,3,7,4,2,8)
       val arr4 = arr2.sortWith(_>_)
       println(arr4)
   
   }
   

7. 编写一段代码，产出数组中的所有值，去掉重复项

   def test7(){
       var arr = Array(1,3,7,7,3,4,2,8)
       val arr1 = arr.distinct
       println(arr1.toBuffer)
   }