Scala HashMap类代码示例

//设置package包名称以及导入依赖的类
package com.protegra_ati.agentservices.store.util

import java.util.HashMap

class MultiMap[K, V] extends java.io.Serializable{
  private var _map = new HashMap[K, List[V]]()

  def add(key:K, value:V) = {
    val list:List[V] = if (_map.get(key) == null) List[V]() else _map.get(key)
    _map.put(key, list ++ List(value))
  }

  def remove(key:K, value:V) {
    if (_map.get(key) != null) {
      val sublist = _map.get(key).filterNot(x => x == value)
      _map.put(key, sublist)
    }
  }

  def get(key:K):List[V] = {
    _map.get(key)
  }
  
  def hasValue(key:K, value:V):Boolean = {
    val values = get(key)
    (values != null && values.contains(value))
  }
} 

//设置package包名称以及导入依赖的类
package offheap

import java.util.HashMap

class InMemoryHeap[T <: Node[T]] extends Heap[T] {
  val data = new HashMap[Long, T]
  var next_id = 0
  
  def append(node : T, reserve : Int) : Long = {
    data.put(next_id, node)
    val result = next_id
    next_id += 1
    next_id
  }
  
  def write(pointer : Long, node : T) : Unit = {
    data.put(pointer, node)
  }
  
  def read(pointer : Long) : T =
    data.get(pointer)
    
  def commit() = {}
} 

//设置package包名称以及导入依赖的类
package info.matsumana.flink

import java.util.regex.Pattern
import java.util.{HashMap, Properties}

import com.fasterxml.jackson.databind.ObjectMapper
import org.apache.flink.api.java.utils.ParameterTool
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaProducer010
import org.apache.flink.streaming.connectors.twitter.TwitterSource
import org.apache.flink.streaming.util.serialization.SimpleStringSchema

object TweetCollect {

  val DELETED_TWEET_PATTERN = Pattern.compile("""^\{"delete":\{""")

  // ????
  val TARGET_TWEET_PATTERN = Pattern.compile("^.*[\u3040-\u3096]+.*$")

  val mapper = new ObjectMapper()

  def main(args: Array[String]): Unit = {
    val params = ParameterTool.fromPropertiesFile(args(0))

    val env = StreamExecutionEnvironment.getExecutionEnvironment
    env.enableCheckpointing(60000)

    // source (twitter)
    val twitterProps = new Properties()
    twitterProps.setProperty(TwitterSource.CONSUMER_KEY, params.get("consumer_key", ""))
    twitterProps.setProperty(TwitterSource.CONSUMER_SECRET, params.get("consumer_secret", ""))
    twitterProps.setProperty(TwitterSource.TOKEN, params.get("token", ""))
    twitterProps.setProperty(TwitterSource.TOKEN_SECRET, params.get("token_secret", ""))
    val sourceStream = env.addSource(new TwitterSource(twitterProps))

    // sink (kafka)
    val kafkaProps = new Properties()
    kafkaProps.setProperty("bootstrap.servers", params.get("bootstrap.servers", "localhost:9092"))
    val topic = params.get("topic", "twitter")
    val sink = new FlinkKafkaProducer010[String](
      topic,
      new SimpleStringSchema,
      kafkaProps)

    // stream processing
    sourceStream
      .filter(!DELETED_TWEET_PATTERN.matcher(_).matches())
      .map(mapper.readValue(_, classOf[HashMap[String, Object]]))
      .filter(m => {
        val text = m.get("text")
        text != null && TARGET_TWEET_PATTERN.matcher(String.valueOf(text)).matches()
      })
      .map(mapper.writeValueAsString(_))
      .addSink(sink)

    env.execute("TweetCollect")
  }
} 

//设置package包名称以及导入依赖的类
import java.util.HashMap

class Marker private (val color: String) {
  println(s"Creating ${toString}")
  
  override def toString : String = "marker color " + color
}

object Marker {
  private var markers : HashMap[String, Marker] = new HashMap[String, Marker]
  
  def getMarker(color: String) : Marker = {
    if (!markers.containsKey(color)) {
      markers.put(color, new Marker(color))
    }
    
    markers.get(color)
  }
} 

//设置package包名称以及导入依赖的类
package org.apache.spark.sql

import java.nio.ByteBuffer
import java.util.{ArrayList, HashMap}

import scala.util.Random

object TestUtils {

  def generateRandomByteBuffer(rand: Random, size: Int): ByteBuffer = {
    val bb = ByteBuffer.allocate(size)
    val arrayOfBytes = new Array[Byte](size)
    rand.nextBytes(arrayOfBytes)
    bb.put(arrayOfBytes)
  }

  def generateRandomMap(rand: Random, size: Int): java.util.Map[String, Int] = {
    val jMap = new HashMap[String, Int]()
    for (i <- 0 until size) {
      jMap.put(rand.nextString(5), i)
    }
    jMap
  }

  def generateRandomArray(rand: Random, size: Int): ArrayList[Boolean] = {
    val vec = new ArrayList[Boolean]()
    for (i <- 0 until size) {
      vec.add(rand.nextBoolean())
    }
    vec
  }
} 

//设置package包名称以及导入依赖的类
package com.jcode.spark.streaming

import java.util.HashMap

import org.apache.kafka.clients.producer.{KafkaProducer, ProducerConfig, ProducerRecord}

import org.apache.spark.SparkConf
import org.apache.spark.streaming._
import org.apache.spark.streaming.kafka._


object KafkaWordCountProducer {

  def main(args: Array[String]) {
    if (args.length < 4) {
      System.err.println("Usage: KafkaWordCountProducer <metadataBrokerList> <topic> " +
        "<messagesPerSec> <wordsPerMessage>")
//      System.exit(1)
    }

//    val Array(brokers, topic, messagesPerSec, wordsPerMessage) = args
    val Array(brokers, topic, messagesPerSec, wordsPerMessage) = Array("192.168.1.234:9092","sparkStreamingTest","1","5")

    // Zookeeper connection properties
    val props = new HashMap[String, Object]()
    props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, brokers)
    props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,
      "org.apache.kafka.common.serialization.StringSerializer")
    props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,
      "org.apache.kafka.common.serialization.StringSerializer")

    val producer = new KafkaProducer[String, String](props)

    // Send some messages
    while(true) {
      (1 to messagesPerSec.toInt).foreach { messageNum =>
        val str = (1 to wordsPerMessage.toInt).map(x => scala.util.Random.nextInt(10).toString)
          .mkString(" ")

        val message = new ProducerRecord[String, String](topic, null, str)
        producer.send(message)
      }

      Thread.sleep(1000)
    }
  }

}
// scalastyle:on println 

//设置package包名称以及导入依赖的类
package alexsmirnov.pbconsole

import java.util.HashMap
import org.apache.commons.lang3.text.StrSubstitutor
import scala.io.Source
import scalafx.beans.property.StringProperty
import javafx.util.Callback
import javafx.beans.Observable

class Macro {
  val nameProperty = StringProperty("")
  def name = nameProperty.get
  def name_=(v: String) = nameProperty.update(v)
  val descriptionProperty = StringProperty("")
  def description = descriptionProperty.get
  def description_=(v: String) = descriptionProperty.update(v)
  val contentProperty = StringProperty("")
  def content = contentProperty.get
  def content_=(v: String) = contentProperty.update(v)
}

object Macro {
  import Settings._
  object extractor extends Callback[Macro,Array[Observable]]{
    def call(m: Macro) = Array(m.nameProperty,m.descriptionProperty,m.contentProperty)
  }
  def apply(name: String,description: String,content: String) = {
    val m = new Macro
    m.name = name
    m.description = description
    m.content = content
    m
  }
  def prepare(content: String,conf: Settings): Iterator[String] = {
    val values = new HashMap[String,Any]
    values.put(BED_W, conf.bedWidth())
    values.put(BED_D, conf.bedDepth())
    values.put(H, conf.height())
    values.put(Z_OFFSET, conf.zOffset())
    val sub = new StrSubstitutor(values)
    val src = Source.fromString(sub.replace(content))
    src.getLines()
  }
}