Scala MutableList类代码示例

//设置package包名称以及导入依赖的类
package pl.writeonly.babel.beans

import pl.writeonly.babel.entities.User
import pl.writeonly.babel.entities.Record
import pl.writeonly.babel.entities.Word

import scala.collection.mutable.MutableList
import scala.collection.mutable.HashMap

//@org.springframework.stereotype.Component
class Game(val drawn: Array[Record]) {
  val priv = drawn(0)
  val key = priv.relation.key
  val map= new HashMap[Word, Record] //tra zgadn?? co tam da?
  val lambda = (ml: MutableList[Word], r: Record) => {
    val word = r.relation.value
    this.map + (word -> r)
    ml += word
  }
  val values = drawn.foldLeft(new MutableList[Word])(lambda).toArray
  val tuple = key -> values

} 

//设置package包名称以及导入依赖的类
package pl.writeonly.babel.beans
import javax.annotation.Resource
import java.io.BufferedReader
import org.springframework.stereotype.Service
import pl.writeonly.babel.daos.DaoCrud
import pl.writeonly.babel.entities.Record
import pl.writeonly.babel.entities.User
import pl.writeonly.scala.util.ToBoolean
import scala.collection.mutable.MutableList
import pl.writeonly.babel.entities.Relation

@org.springframework.stereotype.Service
class RecordBean(@Resource(name = "daoImpl") val dao: DaoCrud) extends ToBoolean {
  val clazz = classOf[Record]
  def persist(record: Record) = dao.persist(record)
  def persistAll(records: List[Record]) = dao.persistAll(records)
  def find(user: User) = dao.find(clazz);
  def find() = dao.find(clazz)
  def merge(record: Record) = dao.merge(record);

  def parse(reader: BufferedReader): MutableList[Record] = {
    val list = new MutableList[Record]
    do {
      val line: String = reader.readLine
      if (!line) return list
      list += new Record(line)
      var i: Int = new Integer(line).toInt
    } while (true)
    return null
  }
  
  def toRecordAll(relations : List[Relation]) = {
    
  }
} 

//设置package包名称以及导入依赖的类
import org.apache.spark.SparkConf
import org.apache.spark.SparkContext
import scala.collection.mutable.MutableList

object Assignment2RDD {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("Assignment 2").setMaster("local[*]")
    val sc = new SparkContext(conf)
    val filePath = "Path\\to\\textfiles\\*.txt"
    val file = sc.textFile(filePath)
    val ftm = file.map(x => x.split(","))
    val ftm1 = ftm.map(x => (x(0).toInt,x(1).toInt,x(2).trim))
    var y0 = MutableList(0)
    var y1 = MutableList(0)
    var y2 = MutableList(0)
    var y3 = MutableList(0)
    var y4 = MutableList(0)
    val grouped_data = ftm1.groupBy(_._1).collect()
    val grouped_data0 = List(grouped_data).foreach(x => x(0)._2.foreach(x => y0+=x._2))
    val grouped_data1 = List(grouped_data).foreach(x => x(1)._2.foreach(x => y1+=x._2))
    val grouped_data2 = List(grouped_data).foreach(x => x(2)._2.foreach(x => y2+=x._2))
    val grouped_data3 = List(grouped_data).foreach(x => x(3)._2.foreach(x => y3+=x._2))
    val grouped_data4 = List(grouped_data).foreach(x => x(4)._2.foreach(x => y4+=x._2))
    println("1001 ", y0.max)
    println("1002 ", y1.max)
    println("1003 ", y2.max)
    println("1004 ", y3.max)
    println("1005 ", y4.max)
  }
} 

//设置package包名称以及导入依赖的类
import org.jfree.chart._
import org.jfree.data.xy._
import scala.math._
import scala.collection.mutable.{MutableList, Map}
import java.io.{FileReader, BufferedReader}

object ParallelCoordinates {
  def readCSVFile(filename: String): Map[String, MutableList[String]] = {
    val file = new FileReader(filename)
    val reader = new BufferedReader(file)
    val csvdata: Map[String, MutableList[String]] = Map()
    try {
      val alldata = new MutableList[Array[String]]
      var line:String = null
      while ({line = reader.readLine(); line} != null) {
        if (line.length != 0) {
          val delimiter: String = ","
          var splitline: Array[String] = line.split(delimiter).map(_.trim)
          alldata += splitline
        }
      }
      val labels = MutableList("sepal length", "sepal width",
        "petal length", "petal width", "class")
      val labelled = labels.zipWithIndex.map {
        case (label, index) => label -> alldata.map(x => x(index))
      }
      for (pair <- labelled) {
        csvdata += pair
      }
    } finally {
      reader.close()
    }
    csvdata
  }

  def main(args: Array[String]) {
    val data = readCSVFile("iris.csv")
    val dataset = new DefaultXYDataset
    for (i <- 0 until data("sepal length").size) {
      val x = Array(0.0, 1.0, 2.0, 3.0)
      val y1 = data("sepal length")(i).toDouble
      val y2 = data("sepal width")(i).toDouble
      val y3 = data("petal length")(i).toDouble
      val y4 = data("petal width")(i).toDouble
      val y = Array(y1, y2, y3, y4)
      val cls = data("class")(i)
      dataset.addSeries(cls + i, Array(x, y))
    }
    val frame = new ChartFrame("Parallel Coordinates",
      ChartFactory.createXYLineChart("Parallel Coordinates", "x", "y",
      dataset, org.jfree.chart.plot.PlotOrientation.VERTICAL,
      false, false, false))
    frame.pack()
    frame.setVisible(true)
  }
} 

//设置package包名称以及导入依赖的类
import scala.collection.mutable.{MutableList, Map}
import java.io.{FileReader, BufferedReader}

object CSVReader {
 def main(args: Array[String]) {
   val file = new FileReader("iris.csv")
   val reader = new BufferedReader(file)
   try {
     val alldata = new MutableList[Array[String]]
     var line:String = null
     while ({line = reader.readLine(); line} != null) {
       if (line.length != 0) {
         val delimiter: String = ","
         var splitline: Array[String] = line.split(delimiter).map(_.trim)
         alldata += splitline
       }
     }
     val labels = MutableList("sepal length", "sepal width",
       "petal length", "petal width", "class")
     val labelled = labels.zipWithIndex.map {
       case (label, index) => label -> alldata.map(x => x(index))
     }
     val csvdata: Map[String, MutableList[String]] = Map()
     for (pair <- labelled) {
       csvdata += pair                                           
     }
   }
   finally {
     reader.close()
   }
 }
}