Scala数组

1、数组的定义和取值

object helloworld {

  def main(args: Array[String]) {

    //java:    int[] arr = new int[10];
    //          int[] arr = new int[]{1,2,3,4}
    //          int[] arr = {1,2,3,4}

    //scala:
//    var arr = new Array[Int](10)  //隐含的调用了apply(10)的方法
//    for(x<-arr) println(x);//初始化为0

    //如果数组有初始值就不用定义数组的类型
    var arr1 = Array(1,2,3);
    var arr2 = Array("hello","woijid");
    //遍历数组
    for(x<-arr1) println(x);
    for(y<-arr2) println(y);

    //访问指定的数组元素
    println(arr1(0));//注意这里访问指定的元素用的是小括号
    println(arr2(1));

  }
}

2、变长数组

import scala.collection.mutable.ArrayBuffer

object helloworld {

  def main(args: Array[String]) {
    //创建数组缓冲区
    var buffer = new ArrayBuffer[Int]();//创建一个数组缓冲对象，中括号里面表示泛型
    buffer += 44;
    buffer += 2;
    buffer += (5);//因为这里+=是一个函数所以可以用.来调用方法
    //+=表示在末尾添加元素
    //++=  表示在末尾添加集合
    buffer ++= Array(1,2,31);
    //因为现在的buffer是一个对象所以可以调用很多的函数
    println(buffer);

  }
}

3、数据缓冲区对象的方法以及和数组之间的转换

import scala.collection.mutable.ArrayBuffer

object helloworld {

  def main(args: Array[String]) {
    //创建数组缓冲区
    var buffer = new ArrayBuffer[Int]();//创建一个数组缓冲对象，中括号里面表示泛型
    buffer += 44;
    buffer += 2;
    buffer += (5);//因为这里+=是一个函数所以可以用.来调用方法
    //+=表示在末尾添加元素
    //++=  表示在末尾添加集合
    buffer ++= Array(1,2,31);
    //因为现在的buffer是一个对象所以可以调用很多的函数
    println(buffer);

    //剔除末尾2个
    buffer.trimEnd(2);
    println(buffer);

    //剔除头部1个
    buffer.trimStart(1);
    println(buffer);

    //在下标为2的地方插入34
    buffer.insert(2,34);
    println(buffer);

    //在下标为0的地方插入11，22，33
    buffer.insert(0,11,22,33);
    println(buffer);

    //从下标为0的地方开始移除2个元素
    buffer.remove(0,2);
    println(buffer);

    //将数组缓冲区对象转换成数组
   var arr1 =   buffer.toArray;
    for (x<-arr1)println(x);
  }
}
    //将数组缓冲区对象转换成数组
   var arr1 =   buffer.toArray;
    //遍历数组的两种方法
    for (i<-0  until   arr1.length) println(arr1(i));
    for(x<-arr1) println(x);

4、yield产生新的数组集合，或者数据缓冲区

import scala.collection.mutable.ArrayBuffer

object helloworld {

  def main(args: Array[String]) {

    var arr = Array(1,2,3,4,5,6,7,8);
    /*var result = for (x<-arr) yield x*2;
    for(x<-result) println(x);
    //利用yield产生一个新的数组，但是原来的数组并不会收到影响
    for(y<-arr) println(y);*/
    //对特定的元素进行筛选
    //利用if添加守卫条件
    val result_1 = for(x<-arr if x%2==0) yield x*2;
    for(z<-result_1) println("如果是偶数，就*2====="+z);

  }
}

5、使用过滤器进行筛选，并通过map映射来改变筛选出来的值

 //通过过滤器来实现数组元素的筛选
    val arr = Array(1,2,3,4,5,6,7);
    //第一个下划线表示通配所有的元素，通过过滤器筛选出偶数，然后通过map映射改变取出的元素的值
    val arr1 =  arr.filter(_ % 2 == 0).map(_ * 2);
    for(x<-arr1) println(x);

6、数组的方法

 val arr = Array(1,2,3,4,5,6);
    val sum = arr.sum;
    val max = arr.max;
    val min = arr.min;
    println(sum+"=="+max+"==="+min);

数组的排序
import scala.util.Sorting._
object helloworld {

  def main(args: Array[String]) {
   val arr1 = ArrayBuffer(23,544,2,4,5);
    val newArr =  arr1.toArray;--->对于数据缓冲区对象需要转换为数组才能够进行排序
     quickSort(newArr);
    for(x<- 0 to newArr.length) println(newArr(x));

  }
}

7、数组的分隔

import scala.util.Sorting._
object helloworld {

  def main(args: Array[String]) {

    //数组的分隔
    val arr = Array(1,3,4,5);
    val newArr = arr.mkString("<<",",,",">>");
    for(i<- 0 to newArr.length) print(newArr(i));

    //打印结果：<<1,,3,,4,,5>>

  }
}

8、二维数组的遍历和定义

object helloworld {

  def main(args: Array[String]) {

    //多维数组
//    一维数组
//    val arr = new Array[Int](4);
//二维数组
   /* val arr  = new Array[Array[Int] ](4);
    arr(0)=Array(1,3,4);
    arr(2) = Array(2,3,5);
   for(x<-arr ;from = x;j<-from) println(j);*/

    //在定义的时候赋值
    val arr1 = Array(Array(1,2,3),Array(3,4,5) );
    for(i<-arr1;from = i;j<-from) print(j);
  }
}

9、使用ofDim来定义多维数组，以及访问多维数组的每一个元素，以及访问数组的长度

object helloworld {
  def main(args: Array[String]) {
    //定义一个多维数组
    val arr = Array.ofDim[Int](4,5);
    //遍历数组的每个元素
    //for(i<-arr;from = i;j<-from) println(j);

    arr(2)(2)=1;
    //访问具体的元素，使用行和列来指定
    println(arr(2)(2));
    //数组的长度
    //行数
    println("数组的长度"+arr.length);
    //列数
    println("第一行的长度："+arr(0).length);
  }
}