scala学习---2

一.遍历

object Scala05 {
  def main(args: Array[String]): Unit = {
    //1.遍历
  /*  var n=10
    while (n>0){
      println(n)
      n-=1
    }*/

    //2.
/*    var n=10
    for(i<-1 to n)
      println(i)*/

    //3.
/*    var n=10
    for (i<-1 until n)
     println(i)*/

    //4.字符串遍历
    /*for(c<-"Hello World")
      print(c)*/

    //1.跳出循环
    //·scala没有提供类似于java的break语句。
    //·但是可以使用boolean类型变量、return或者Breaks的break函数来替代使用。
  /*  import scala.util.control.Breaks._
    breakable {
      var n = 10
      for(c <- "Hello World") {
        if(n == 5) break;
        print(c)
        n -= 1
      }
    }*/

    //2.多重for循环：九九乘法表
    /*  for(i <- 1 to 9; j <- 1 to 9) {
        if(j == 9) {
          println(i * j)
        } else {
          print(i * j + " ")
        }
      }*/

    //3.if守卫：取偶数
   // for(i <- 1 to 100 if i % 2 == 0) println(i)

    //4.for推导式：构造集合
    println( for(i <- 1 to 10) yield i)
    //打印结果 Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

  }
}

1.Any是String和Int的公共父类型 

2.在Scala中，定义函数时，如果函数体直接包裹在了花括号里面，而没有使用=连接，则函数的返回值类型就是Unit。这样的函数就被称之为过程。过程通常用于不需要返回值的函数。

二.方法函数

object Scala01 {
  //1.函数
  def sayHello(name: String, age: Int) = {
    if (age > 18) {
      printf("hi %s, you are a big boy
", name); age
    }
    else {
      printf("hi %s, you are a little boy
", name);
      age
    }
  }

  def main(args: Array[String]): Unit = {
    //sayHello("leo", 30)
    //println(sum(10))
   //sayHello1("")
    // println(sum3(1,2,4))
     println(sum2(1,2,4))
  }
  //2.函数
  def sum(n: Int) = {
    var sum = 0;
    for(i <- 1 to n) sum += i
    sum   //默认是返回值
  }

  //3.默认参数  如果给出的参数不够，则会从作往右依次应用参数
  def sayHello1(name: String, age: Int = 20) {
    print("Hello, " + name + ", your age is " + age)
  }

  //4还可以混合使用未命名参数和带名参数，但是未命名参数必须排在带名参数前面
  //sayHello("Mick", lastName = "Nina", middleName = "Jack")

  //5.变长参数
  def sum3(nums:Int*)={
    var res=0
    for (num<-nums) res+=num
    res
  }

  //6.使用递归函数实现累加
  def sum2(nums:Int*):Int={
    if(nums.length==0)0
    else nums.head+sum2(nums.tail:_*)
  }
}

三.集合

 ArrayBuffer和Array

// 使用insert()函数可以在指定位置插入元素
// 但是这种操作效率很低，因为需要移动指定位置后的所有元素
b.insert(5, 6)
b.insert(6, 7, 8, 9, 10)
// 使用remove()函数可以移除指定位置的元素
b.remove(1)
b.remove(1, 3)
// Array与ArrayBuffer可以互相进行转换
b.toArray
a.toBuffer

// 使用for循环和until遍历Array / ArrayBuffer
// 使until是RichInt提供的函数
  for (i <- 0 until b.length)
  println(b(i))
// 跳跃遍历Array / ArrayBuffer
  for(i <- 0 until (b.length, 2))
  println(b(i))
// 从尾部遍历Array / ArrayBuffer
  for(i <- (0 until b.length).reverse)
  println(b(i))
// 使用“增强for循环”遍历Array / ArrayBuffer
  for (e <- b)
  println(e)

// 数组元素求和
 val a = Array(1, 2, 3, 4, 5)
 val sum = a.sum
// 获取数组最大值
 val max = a.max
// 对数组进行排序
 scala.util.Sorting.quickSort(a)
// 获取数组中所有元素内容
 a.mkString
 a.mkString(", ")
 a.mkString("<", ",", ">")
// toString函数
 a.toString
 b.toString

使用yield和函数式编程转换数组

// 对Array进行转换，获取的还是Array
val a = Array(1, 2, 3, 4, 5)
val a2 = for (ele <- a) yield ele * ele
// 对ArrayBuffer进行转换，获取的还是ArrayBuffer
val b = ArrayBuffer[Int]()
b += (1, 2, 3, 4, 5)
val b2 = for (ele <- b) yield ele * ele
// 结合if守卫，仅转换需要的元素
val a3 = for (ele <- a if ele % 2 == 0) yield ele * ele

// 使用函数式编程转换数组（通常使用第一种方式）
a.filter(_ % 2 == 0).map(2 * _)
a.filter { _ % 2 == 0 } map { 2 * _ }

算法案例：移除第一个负数之后的所有负数

// 构建数组
val a = ArrayBuffer[Int]()
a += (1, 2, 3, 4, 5, -1, -3, -5, -9)

// 每发现一个第一个负数之后的负数，就进行移除，性能较差，多次移动数组
var foundFirstNegative = false
var arrayLength = a.length
var index = 0
while (index < arrayLength) {
  if (a(index) >= 0) {
    index += 1
  } else {
    if (!foundFirstNegative) { foundFirstNegative = true; index += 1 }
    else { a.remove(index); arrayLength -= 1 }
  }
} 

 算法案例：移除第一个负数之后的所有负数（简约版）
// 重新构建数组
val a = ArrayBuffer[Int]()
a += (1, 2, 3, 4, 5, -1, -3, -5, -9)

// 每记录所有不需要移除的元素的索引，稍后一次性移除所有需要移除的元素
// 性能较高，数组内的元素迁移只要执行一次即可
var foundFirstNegative = false
val keepIndexes = for (i <- 0 until a.length if !foundFirstNegative || a(i) >= 0) yield {
  if (a(i) < 0) foundFirstNegative = true
  i
}
for (i <- 0 until keepIndexes.length) { a(i) = a(keepIndexes(i)) }
a.trimEnd(a.length - keepIndexes.length)