Scala DateTimeFormatter类代码示例

//设置package包名称以及导入依赖的类
package de.zalando.play.controllers

import java.time.format.{ DateTimeFormatter, DateTimeParseException }
import java.time.{ LocalDate, ZoneId, ZonedDateTime }


object Rfc3339Util {

  private val fullDate = DateTimeFormatter.ofPattern("yyyy-MM-dd")
  private val shortDateTime = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ssZ")
  private val shortDTWithTicks = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss'Z'")
  private val fullDTWithTicks = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSSS'Z'")
  private val dateTime = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSSSZ")

  def parseDateTime(datestring: String): ZonedDateTime =
    if (datestring.endsWith("Z") || datestring.endsWith("z")) parseFull(datestring)
    else parseParts(datestring)

  def parseDate(datestring: String): LocalDate =
    LocalDate.parse(datestring, fullDate)

  def writeDate(date: LocalDate): String = fullDate.format(date)

  def writeDateTime(date: ZonedDateTime): String = dateTime.format(date)

  private def parseParts(datestring: String): ZonedDateTime = {
    //step one, split off the timezone.
    val sepChar = if (datestring.indexOf('+') > 0) '+' else '-'
    val firstpart = datestring.substring(0, datestring.lastIndexOf(sepChar.toInt))
    val secondpart = datestring.substring(datestring.lastIndexOf(sepChar.toInt))
    //step two, remove the colon from the timezone offset
    val thirdpart = secondpart.substring(0, secondpart.indexOf(':')) + secondpart.substring(secondpart.indexOf(':') + 1)
    val dstring = firstpart + thirdpart
    try {
      ZonedDateTime.parse(dstring, shortDateTime)
    } catch {
      case pe: DateTimeParseException =>
        ZonedDateTime.parse(dstring, dateTime)
    }
  }

  private def parseFull(datestring: String): ZonedDateTime = {
    val z = ZoneId.systemDefault()
    try {
      ZonedDateTime.parse(datestring, shortDTWithTicks.withZone(z))
    } catch {
      case p: DateTimeParseException => ZonedDateTime.parse(datestring, fullDTWithTicks.withZone(z))
    }
  }

} 

//设置package包名称以及导入依赖的类
package io.soheila.cms.api

import java.time.LocalDateTime
import java.time.format.DateTimeFormatter
import java.util.Locale

import sangria.ast.StringValue
import sangria.schema.ScalarType
import sangria.validation.ValueCoercionViolation

import scala.util.{ Failure, Success, Try }

package object graphql {
  case object LocalDateTimeCoercionViolation extends ValueCoercionViolation("Date value expected")
  case object LocaleCoercionViolation extends ValueCoercionViolation("Locale value expected")

  private[graphql] def parseLocalDateTime(s: String) = Try(LocalDateTime.parse(s)) match {
    case Success(date) => Right(date)
    case Failure(_) => Left(LocalDateTimeCoercionViolation)
  }

  private[graphql] def parseLocale(s: String) = Try(Locale.forLanguageTag(s)) match {
    case Success(locale) => Right(locale)
    case Failure(_) => Left(LocaleCoercionViolation)
  }

  val LocalDateTimeType = ScalarType[LocalDateTime](
    "LocalDateTime",
    coerceOutput = (value, caps) => value.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME),
    coerceUserInput = {
      case s: String => parseLocalDateTime(s)
      case _ => Left(LocalDateTimeCoercionViolation)
    },
    coerceInput = {
      case StringValue(s, _, _) => parseLocalDateTime(s)
      case _ => Left(LocalDateTimeCoercionViolation)
    }
  )

  val LocaleType = ScalarType[Locale](
    "Locale",
    coerceOutput = (value, caps) => value.toLanguageTag,
    coerceUserInput = {
      case s: String => parseLocale(s)
      case _ => Left(LocaleCoercionViolation)
    },
    coerceInput = {
      case StringValue(s, _, _) => parseLocale(s)
      case _ => Left(LocaleCoercionViolation)
    }
  )
} 

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

import java.time.format.DateTimeFormatter
import java.time.temporal.ChronoUnit
import java.time.{Clock, LocalDateTime}
import java.util.{Base64, UUID}
import javax.crypto.spec.SecretKeySpec
import javax.crypto.{KeyGenerator, Mac}

@SerialVersionUID(1L)
class Player(val id: UUID, val name: String, val secret: String) extends Serializable {
  override def hashCode = id.hashCode()

  override def equals(other: Any) = other match {
    case that: Player => this.id == that.id
    case _ => false
  }

  override def toString = s"$name ($id)"

  def identity = PlayerIdentity(id, name)

  def isAuthorized(time: LocalDateTime, signature: String): Boolean = {
    val seconds = ChronoUnit.SECONDS.between(time, LocalDateTime.now(Clock.systemUTC()))

    if (seconds < -300 || seconds > 300) {
      false
    } else {
      val secretKeySpec = new SecretKeySpec(secret.getBytes, "HmacSHA256")
      val mac = Mac.getInstance("HmacSHA256")
      mac.init(secretKeySpec)

      val message = id.toString.toLowerCase + "|" + time.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME)
      val hmac = mac.doFinal(message.getBytes("UTF-8"))

      val encoded = Base64.getEncoder.encodeToString(hmac)

      encoded.equalsIgnoreCase(signature)
    }
  }
}

object Player {
  def apply(name: String) = new Player(UUID.randomUUID(), name, generateKey)

  def apply(id: UUID, name: String) = new Player(id, name, generateKey)

  private def generateKey: String = {
    val keyGenerator: KeyGenerator = KeyGenerator.getInstance("HmacSHA256")
    Base64.getEncoder.encodeToString(keyGenerator.generateKey().getEncoded)
  }

  def apply(id: UUID, name: String, secret: String) = new Player(id, name, secret)

  def apply(identity: PlayerIdentity) = new Player(identity.id, identity.name, generateKey)

  def apply(identity: PlayerIdentity, secret: String) = new Player(identity.id, identity.name, secret)
}

case class PlayerIdentity(id: UUID, name: String) 

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

import java.io.{PrintWriter, StringWriter}
import java.time.LocalDateTime
import java.time.format.DateTimeFormatter
import java.util.UUID

import spray.json.{JsValue, JsonFormat, _}

trait UsersProtocol {
  private def getStackTrace(t: Throwable) = {
    val sw: StringWriter = new StringWriter()
    val pw: PrintWriter = new PrintWriter(sw)
    t.printStackTrace(pw)
    sw.toString
  }

  implicit object ThrowableWriter extends RootJsonWriter[Throwable] {
    def write(t: Throwable) = JsObject(
      "message" -> JsString(t.getMessage),
      "cause" -> t.getCause.toJson,
      "stackTrace" -> JsString(getStackTrace(t))
    )
  }

  implicit object MessageFormat extends RootJsonWriter[Message] {
    def write(m: Message) = JsObject(
      "summary" -> JsString(m.summary),
      "errorCode" -> JsNumber(m.errorCode)
    )
  }

  implicit object ValidationFormat extends RootJsonWriter[Validation] {
    def write(v: Validation) = {
      val fields = Seq[Option[JsField]](
        Some("message"   -> JsString(v.message)),
        Some("errorCode" -> JsNumber(v.errorCode)),
        v.exception.map(exception => "exception" -> exception.toJson)
      )
      JsObject(fields.flatten: _*)
    }
  }

  implicit object UUIDFormat extends JsonFormat[UUID] {
    def write(uuid: UUID) = JsString(uuid.toString)
    def read(value: JsValue) = value match {
      case JsString(uuid) => UUID.fromString(uuid)
      case _ => deserializationError("UUID expected.")
    }
  }

  implicit object LocalDateTimeFormat extends JsonFormat[LocalDateTime] {
    def write(dateTime: LocalDateTime) = JsString(dateTime.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME))
    def read(value: JsValue) = value match {
      case JsString(dateTime) => LocalDateTime.parse(dateTime, DateTimeFormatter.ISO_LOCAL_DATE_TIME)
      case _ => deserializationError("LocalDateTime expected.")
    }
  }
} 

//设置package包名称以及导入依赖的类
package org.wex.cmsfs.common.monitor

import java.time.format.DateTimeFormatter
import java.time.{ZoneOffset, ZonedDateTime}

import com.redis.RedisClient
import play.api.libs.json._

trait MonitorStatus {
  val r = new RedisClient("redis.cmsfs.org", 6379)

  def putStatus(id: Int, stage: String)(state: Boolean, result: String) = {
    val stageStatus = CoreMonitorStageStatus(state, result)
    val key = s"${id}_${stage}"

    r.set(key, Json.toJson(stageStatus).toString())
  }
}

case class CoreMonitorStatus(id: Int, category: String, name: String, metric: String,
                             collect: CoreMonitorCollectStatus,
                             analyze: Option[CoreMonitorAnalyzeStatus],
                             Alarm: Option[CoreMonitorAlarmStatus])

object CoreMonitorStatus {
  implicit val format: Format[CoreMonitorStatus] = Json.format
}

case class CoreMonitorStageStatus(state: Boolean, result: String,
                                  timestamp: String = ZonedDateTime.now(ZoneOffset.ofHours(8)).format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:m:s")))

object CoreMonitorStageStatus {
  implicit val format: Format[CoreMonitorStageStatus] = Json.format
}

case class CoreMonitorCollectStatus(state: Boolean, timestamp: String, result: String)

object CoreMonitorCollectStatus {
  implicit val format: Format[CoreMonitorCollectStatus] = Json.format
}

case class CoreMonitorAnalyzeStatus(state: Boolean, timestamp: String, result: String)

object CoreMonitorAnalyzeStatus {
  implicit val format: Format[CoreMonitorAnalyzeStatus] = Json.format
}

case class CoreMonitorAlarmStatus(state: Boolean, timestamp: String, result: String)

object CoreMonitorAlarmStatus {
  implicit val format: Format[CoreMonitorAlarmStatus] = Json.format
} 

//设置package包名称以及导入依赖的类
package knot.core.logging

import java.time.LocalDateTime
import java.time.format.DateTimeFormatter

import scala.util.control.NoStackTrace

object StdOutLogger {
  final val errorLevel = 1
  final val warningLevel = 2
  final val infoLevel = 3
  final val debugLevel = 4
}

case class StdOutLogger(name: String, logLevel: Int = 1) extends Logger {

  override def isErrorEnabled: Boolean = logLevel >= StdOutLogger.errorLevel

  override def isWarningEnabled: Boolean = logLevel >= StdOutLogger.warningLevel

  override def isInfoEnabled: Boolean = logLevel >= StdOutLogger.infoLevel

  override def isDebugEnabled: Boolean = logLevel >= StdOutLogger.debugLevel

  override protected def logError(cause: Throwable, message: String): Unit = {
    println(s"$time [ERROR] - $thread - $name - $message ${stackTrace(cause)}")
  }

  override protected def logWarning(message: String): Unit = {
    println(s"$time [WARN ] - $thread - $name - $message")
  }

  override protected def logInfo(message: String): Unit = {
    println(s"$time [INFO ] - $thread - $name - $message")
  }

  override protected def logDebug(message: String): Unit = {
    println(s"$time [DEBUG] - $thread - $name - $message")
  }

  private def time = LocalDateTime.now().format(DateTimeFormatter.ISO_DATE_TIME)

  private def thread = Thread.currentThread.getName

  private def stackTrace(e: Throwable): String = e match {
    case null => ""
    case _: NoStackTrace => " (" + e.getClass.getName + ")"
    case other =>
      val sw = new java.io.StringWriter
      val pw = new java.io.PrintWriter(sw)
      pw.append('\n')
      other.printStackTrace(pw)
      sw.toString
  }
} 

//设置package包名称以及导入依赖的类
package io.gustavoamigo.quill.pgsql.encoding.datetime

import java.time.format.{DateTimeFormatter, DateTimeFormatterBuilder}
import java.time.temporal.ChronoField

private[datetime] object Formatters {
  val bpDateFormatter = DateTimeFormatter.ISO_LOCAL_DATE
  val bpTimeFormatter = DateTimeFormatter.ISO_LOCAL_TIME
  val bpTzTimeFormatter =
    new DateTimeFormatterBuilder()
      .append(DateTimeFormatter.ofPattern("HH:mm:ss"))
      .optionalStart()
      .appendFraction(ChronoField.NANO_OF_SECOND,0,6,true)
      .optionalEnd()
      .appendOffset("+HH:mm","+00")
      .toFormatter()
  val bpTzDateTimeFormatter =
    new DateTimeFormatterBuilder()
      .append(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"))
      .optionalStart()
      .appendFraction(ChronoField.NANO_OF_SECOND,0,6,true)
      .optionalEnd()
      .appendOffset("+HH:mm","+00")
      .toFormatter()
} 

//设置package包名称以及导入依赖的类
package wvlet.core.scales

import java.time.format.DateTimeFormatter
import java.time._
import java.time.temporal.{TemporalAccessor, TemporalQueries, TemporalQuery}

import wvlet.log.LogSupport

import scala.util.{Failure, Success, Try}


object TimeParser extends LogSupport{

  val localDatePattern = DateTimeFormatter.ofPattern("yyyy-MM-dd")
  val localDateTimePattern = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss[.SSS]")

  val zonedDateTimePatterns: List[DateTimeFormatter] = List(
    "yyyy-MM-dd HH:mm:ss[.SSS][ z][XXXXX][XXXX]['['VV']']",
    "yyyy-MM-dd'T'HH:mm:ss[.SSS][ z][XXXXX][XXXX]['['VV']']"
  ).map(DateTimeFormatter.ofPattern(_))


  def parseLocalDateTime(s: String, zone: ZoneOffset): Option[ZonedDateTime] = {
    Try(LocalDateTime.parse(s, localDateTimePattern))
    .map{ d => ZonedDateTime.of(d, zone) }
    .orElse {
      Try(LocalDate.parse(s, localDatePattern))
      .map{ d => d.atStartOfDay(zone) }
    }
    .toOption
  }

  def parseZonedDateTime(s:String): Option[ZonedDateTime] = {
    def loop(lst:List[DateTimeFormatter]): Option[ZonedDateTime] = {
      if(lst.isEmpty)
        None
      else {
        val formatter = lst.head
        Try(ZonedDateTime.parse(s, formatter)) match {
          case Success(dt) =>
            Some(dt)
          case Failure(e) =>
            loop(lst.tail)
        }
      }
    }
    loop(zonedDateTimePatterns.toList)
  }

  def parseAtLocalTimeZone(s:String) = parse(s, TimeWindow.systemZone)

  def parse(s: String, zone: ZoneOffset): Option[ZonedDateTime] = {
    parseLocalDateTime(s, zone)
    .orElse {
      parseZonedDateTime(s)
    }
  }
} 

//设置package包名称以及导入依赖的类
package uk.vitalcode.dateparser.token

import java.time.LocalTime
import java.time.format.DateTimeFormatter

import scala.util.Try

final case class Time(value: LocalTime, index: Int) extends DateToken

object Time extends TokenCompanion[Time] {

  def apply(hours: Int, minutes: Int, seconds: Int = 0, index: Int = 0): Time = Time(LocalTime.of(hours, minutes, seconds), index)

  private val timeFormatter: DateTimeFormatter = DateTimeFormatter.ofPattern(""
    + "[h.m[.s]a]"
    + "[h[:m][:s]a]"
    + "[H.m[.s]]"
    + "[H:m[:s]]"
  )

  // matches with either : or .  separators,
  // will match a 24 hour time, or a 12 hour time with AM or PM specified,
  // allows 0-59 minutes, and 0-59 seconds. Seconds are not required.
  // http://regexlib.com/REDetails.aspx?regexp_id=144
  private val timeRegEx =
  """((([0]?[1-9]|1[0-2])((:|\.)[0-5]?[0-9])?((:|\.)[0-5]?[0-9])?( )?(AM|am|aM|Am|PM|pm|pM|Pm))|(([0]?[0-9]|1[0-9]|2[0-3])(:|\.)[0-5]?[0-9]((:|\.)[0-5]?[0-9])?))""".r

  override def of(text: String, index: Int): Try[Time] = Try {
    timeRegEx.findFirstIn(text)
      .map(_.replaceAll("""\s*""", "").toUpperCase)
      .map(timeString => LocalTime.parse(timeString, timeFormatter))
      .map(localTime => Time(localTime, index))
      .get
  }
} 

//设置package包名称以及导入依赖的类
package uk.vitalcode.dateparser

import java.time.format.DateTimeFormatter
import java.time.{LocalDate, LocalDateTime, LocalTime}

import uk.vitalcode.dateparser.token.DateToken

case class DateTimeInterval(from: LocalDateTime, to: Option[LocalDateTime]) {
  def to(date: LocalDate, time: LocalTime): DateTimeInterval = copy(
    to = Some(LocalDateTime.of(date, time))
  )

  def to(year: Int, month: Int, day: Int, hours: Int = 0, minutes: Int = 0): DateTimeInterval = copy(
    to = Some(LocalDateTime.of(year, month, day, hours, minutes))
  )

  private def formatDate(date: LocalDateTime) = date.format(DateTimeFormatter.ISO_DATE_TIME)

  override def toString: String = s"interval[from: ${formatDate(from)}" + to.map(d => s" to: ${formatDate(d)}").getOrElse("") + "]"
}

object DateTimeInterval {

  val defaultTime = LocalTime.of(0, 0)

  def from(date: LocalDate, time: LocalTime): DateTimeInterval = new DateTimeInterval(
    from = LocalDateTime.of(date, time),
    to = None
  )

  def from(year: Int, month: Int, day: Int, hours: Int = 0, minutes: Int = 0): DateTimeInterval = new DateTimeInterval(
    from = LocalDateTime.of(year, month, day, hours, minutes),
    to = None
  )

  def of(dateTokens: List[DateToken], tp: DateTimeProvider): List[DateTimeInterval] = {
    val aggregatedTokens = aggregateTokens(dateTokens, tp)
    Analyser.analyse(aggregatedTokens)
  }

  def of(text: String, tp: DateTimeProvider = new DefaultDateTimeProvider): List[DateTimeInterval] = {
    val tokens = DateToken.parse(text)
    of(tokens, tp)
  }

  private def aggregateTokens(dateTokens: List[DateToken], timeProvider: DateTimeProvider): List[DateToken] = {
    val aggregatedTokens = DateTokenAggregator.aggregate(dateTokens, timeProvider)
    if (aggregatedTokens == dateTokens) aggregatedTokens
    else aggregateTokens(aggregatedTokens, timeProvider)
  }
} 

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

import java.time.format.DateTimeFormatter

import delorean.FileOps._
import delorean._

/**
  * Class for 'describe' command.
  */
case class Describe(pitstops: List[String]) {
    pitstops.foreach(pitstop ? {
        docExplain(pitstop)
        if (pitstops.length > 1) println
    })

    // Let the doc explain the pitstop
    def docExplain(simplifiedPitstop: String): Unit = {
        val correctPitstop = resolveTheCorrectPitstop(simplifiedPitstop)
        if (correctPitstop.isEmpty) return
        val metadata: Metadata = Metadata(correctPitstop)

        // fileName -> fileHash
        val changedFilesMap = getFileAsMap(PITSTOPS_FOLDER + correctPitstop)
        println(
            s"""Pitstop $correctPitstop
               |Rider: ${metadata.rider}
               |Time: ${metadata.time.format(DateTimeFormatter.ofPattern("MMM dd yyyy hh:mm a zz"))}
               |Parent(s): ${metadata.parents.mkString(", ")}
               |Rider Log: ${metadata.riderLog}
               |Changes: ${changedFilesMap.keys.mkString("\n\t", "\n\t", "")}
             """.stripMargin)
    }
} 

//设置package包名称以及导入依赖的类
package eu.kraml.io

import java.io.File
import java.nio.file.Path
import java.time.Instant
import java.time.format.DateTimeFormatter

import eu.kraml.model.{GpsCoordinate, Record}

import scala.collection.mutable.ListBuffer
import scala.xml.XML


object GpxFileReader {
    val formatter = DateTimeFormatter.ISO_INSTANT

    def read(gpxFile: Path): Option[List[Record]] = {
        read(gpxFile.toFile)
    }

    def read(gpxFile: File): Option[List[Record]] = {
        try {
            Some(readInternal(gpxFile))
        } catch {
            case e:Exception =>
                None
        }
    }

    private def readInternal(gpxFile: File): List[Record] = {
        val gpx = XML.loadFile(gpxFile)
        val segment = gpx \ "trk" \ "trkseg"
        val points = segment \ "trkpt"
        val records = ListBuffer[Record]()
        points.foreach(n => {
            val lat = n.attribute("lat").get.head.text
            val lon = n.attribute("lon").get.head.text
            val timestampText = (n \ "time").text
            val timestamp = Instant.parse(timestampText)
            records += Record(new GpsCoordinate(lat.toDouble, lon.toDouble), timestamp)
        })
        records.toList
    }
} 

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

import java.time.format.DateTimeFormatter
import java.time.temporal.TemporalAccessor


abstract class Request[A <: Response] {
  def endpoint: String
  def queryString: Seq[(String, String)]

  private val dateFormatter = DateTimeFormatter.ofPattern("YYYY-MM-dd 00:00:00")
  protected def formatDateTime(date: TemporalAccessor): String = dateFormatter.format(date)
}

abstract class PagedRequest[E](__limit: Int = 100, __offset: Int = 0) extends Request[PagedResponse[E]] with Cloneable {

  private var _limit: Int = __limit
  private var _offset: Int = __offset

  def limit(): Int = _limit
  def offset(): Int = _offset

  override def queryString: Seq[(String, String)] = {
    Seq(
      ("limit", _limit.toString),
      ("offset", _offset.toString)
    )
  }

  def next : this.type = {
    val cl: this.type = this.clone().asInstanceOf[this.type]
    cl._offset = this.offset + this.limit
    cl
  }
} 

//设置package包名称以及导入依赖的类
package openquant.yahoofinance.impl

import java.time.format.DateTimeFormatter
import java.time.{LocalDate, ZoneId, ZonedDateTime}

import com.github.tototoshi.csv._
import openquant.yahoofinance.Quote

import scala.io.Source


class QuoteParser {
  private[this] val df = DateTimeFormatter.ofPattern("yyyy-MM-dd")
  private[this] val zoneId = ZoneId.of("America/New_York")

  def parse(content: String): Vector[Quote] = {
    val csvReader = CSVReader.open(Source.fromString(content))
    val quotes: Vector[Quote] = csvReader.toStream.drop(1).map { fields ?
      parseCSVLine(fields.toVector)
    }.toVector
    quotes
  }

  private def parseCSVLine(field: Vector[String]): Quote = {
    require(field.length >= 7)
    Quote(
      parseDate(field(0)),
      BigDecimal(field(1)),
      BigDecimal(field(4)),
      BigDecimal(field(2)),
      BigDecimal(field(3)),
      BigDecimal(field(5)),
      BigDecimal(field(6))
    )
  }

  private def parseDate(date: String): ZonedDateTime = {
    LocalDate.parse(date, df).atStartOfDay().atZone(zoneId)
  }
}

object QuoteParser {
  def apply() = new QuoteParser
} 

//设置package包名称以及导入依赖的类
package br.com.caelum.argentum.model

import java.time.LocalDateTime
import java.time.format.DateTimeFormatter


final case class Candlestick(val opening: BigDecimal, val closing: BigDecimal, val minimum: BigDecimal,
                             val maximum: BigDecimal, val volume: BigDecimal, val date: LocalDateTime) {
  require(opening >= BigDecimal(0.0))
  require(closing >= BigDecimal(0.0))
  require(minimum >= BigDecimal(0.0))
  require(maximum >= BigDecimal(0.0))
  require(volume >= BigDecimal(0.0))
  require(maximum >= minimum)

  final var defaultDateFormat = DateTimeFormatter.ofPattern("dd/MM/yyyy hh:mm:ss")

  def isAlta(): Boolean = opening <= closing

  def isBaixa(): Boolean = opening > closing

  override def toString: String = {
    s"{ (Abertura: ${opening}) (Fechamento: ${closing}) (Minimo: ${minimum}) (Maximo: ${maximum}) (volume: ${volume}) (Data: ${date.format(defaultDateFormat)}) }"
  }
}