数组

scala中集合主要分为两类，可变（mutable）和不可变（immutable）

package chapter03

//java 中的集合List,Set,Map
//List:有序，可重复 ArrayList，LinkedList
//Set:无序，不可重复 Mapset，TreeSet
//Map:无序，（key，value）中key不能重复,value可重复，HashMap,HashTable,TreeMap

//数组：不可改变

//scala中集合主要分为两类，可变（mutable）和不可变（immutable）

object test01 {

    //public static void main(String[] args)
    def main(args:Array[String]):Unit={

      //java数组：int[] ints=new int[3]
      //赋值:ints[0]=1
      //取值：int i=ints[0]


      //Array;不可变数组
      val ints:Array[Int] = Array(1,2,3,4)

      //查询值
      println(ints(0))

      //修改值
      ints.update(1,9)
      println(ints.mkString(","))

      //增加值,产生新的数组
      val ints1:Array[Int]=ints:+(5)
      val ints2:Array[Int]=5+:(ints)
      println(ints1.mkString(","))
      println(ints2.mkString(","))
      println(ints==ints1)  //false

      //长度length
      println(ints.length)

      //将数组转化为字符串打印出来
      println(ints.mkString(","))

      //遍历值
      for (elem <- ints) {
        println(elem)
      }

      //ints.foreach((i:Int)=>{println(i)})
      //ints.foreach((i)=>{println(i)})
      //ints.foreach({println(_)})
      //ints.foreach(println(_))
      //ints.foreach(println)






      //可变数组：ArrayBuffer
      import scala.collection.mutable.ArrayBuffer
      val ab:ArrayBuffer[Int] = ArrayBuffer(5,6,7,8)

      //查询值
      println(ab(0))

      //修改值
      ab(0)=11
      println(ab(0))

      //增加数据，按索引
      ab.insert(1,9)
      println(ab.mkString(","))

      //删除元素:按索引
      ab.remove(1)
      ab.remove(1,2)


      //遍历值
      ab.foreach(println)


      //可变数组-->不可变数组
      val buffer = ints.toBuffer

      //不可变数数组-->可变数组
      val array = ab.toArray









    }
}

 

package chapter03

import java.util

import scala.collection.mutable.ArrayBuffer

object test12 {
  def main(args:Array[String]):Unit={

    //scala数组==》java数组
    val arrayScala = ArrayBuffer("1","2","3","4")
    import scala.collection.JavaConversions.bufferAsJavaList
    val arrayJava = new ProcessBuilder(arrayScala)
    val strings: util.List[String] = arrayJava.command()
    println(strings)

    //java数组==》scala数组
    import scala.collection.JavaConversions.asScalaBuffer
    import scala.collection.mutable

    val scalaArr:mutable.Buffer[String]=strings
    println(scalaArr)




  }

}

 

package chapter02

import scala.collection.mutable.ArrayBuffer

object test01 {

   def main(args:Array[String]):Unit={
     //定义二维数组
     val rows = 3
     val cols = 5

     val chessMap1: Array[Array[Int]] = Array.ofDim[Int](rows,cols)
     chessMap1(1)(1) = 1
     chessMap1(2)(0) = 2


     //遍历二维数组
     for ( i <- 0 until chessMap1.length){
       for ( j <- 0 until chessMap1(i).length){
         printf("%d ",chessMap1(i)(j))
       }
       println()
     }



     //对二维数组压缩
     //创建ArrayBuffer,动态的压缩数据
     //用node对象表示一个数据
     val sparseArray = ArrayBuffer[Node]()
     sparseArray.append(new Node(rows,cols,0))
     //遍历chessMap1，如果发现一个非零的对象，则加入sparseArray
     for ( i <- 0 until chessMap1.length){
       for ( j <- 0 until chessMap1(i).length){
         val result  = chessMap1(i)(j)
         if (result != 0){
           sparseArray.append(new Node(i,j,result))
         }
       }
     }

     println("稀疏数组是： ")
     for(i<- 0 until sparseArray.length){
       val node = sparseArray(i)
       printf("%d %d %d \n",node.row,node.col,node.value)

       }

     //将稀疏数组恢复成二维数据
     val col_2 = sparseArray(0).col
     val row_2 = sparseArray(0).row

     val chessMap2 = Array.ofDim[Int](row_2,col_2)

     for (i <- 1 until sparseArray.length){
       val col_res = sparseArray(i).col
       val row_res = sparseArray(i).row
       val value_res = sparseArray(i).value
       chessMap2(row_res)(col_res)=value_res
     }

     println("恢复后的二维数组：")
     for (i <- 0 until chessMap2.length){
       for (j <- 0 until chessMap2(i).length){
         printf("%d ",chessMap2(i)(j))
       }
       println()
     }

     
     }
}

class Node(val row:Int,val col:Int,val value:Int){

}