【Kotlin】 Kotlin ～ 基本編 / 日付・時間 ～

■ はじめに

基本的に Java の 日付・時間 を使えるので
なんってことはないが、あまりにも使うので
まとめておく

実行環境

https://try.kotlinlang.org/#/Examples/Hello,%20world!/Simplest%20version/Simplest%20version.kt

■ サンプル

package com.dk.jpalarm.utils

import java.text.SimpleDateFormat
import java.util.*

class DateTimeUtil {
    companion object {
        private const val MILLIS_OF_DAY = 1000 * 60 * 60 * 24
        private const val TIME_FORMAT_FOR_INT = "%02d:%02d"
        private const val DATE_FORMAT_FOR_INT = "%04d/%02d/%02d"
        private const val DATE_FORMAT = "yyyy/MM/dd"
        private const val TIME_FORMAT = "HH:mm"
        private const val TIME_DELIMITER = ":"

        @JvmStatic
        fun getTime(hourOfDay: Int, minute: Int): String {
            return TIME_FORMAT_FOR_INT.format(hourOfDay, minute)
        }

        @JvmStatic
        fun getDate(year: Int, month: Int, dayOfMonth: Int): String {
            return DATE_FORMAT_FOR_INT.format(year, month, dayOfMonth)
        }

        @JvmStatic
        fun getDate(targetDate: Calendar): String {
            return getDate(targetDate.time)
        }

        @JvmStatic
        fun getDate(targetDate: Date?): String {
            return if (targetDate == null) {
                ""
            } else {
                val dateFormat = SimpleDateFormat(DATE_FORMAT)
                dateFormat.format(targetDate)
            }
        }

        @JvmStatic
        fun getTime(targetTime: Calendar): String {
            return getTime(targetTime.time)
        }

        @JvmStatic
        fun getTime(targetTime: Date): String {
            val timeFormat = SimpleDateFormat(TIME_FORMAT)
            return timeFormat.format(targetTime)
        }

        @JvmStatic
        fun parseDate(date: String): Calendar? {
            return when (date) {
                "" -> {
                    null
                }
                else -> {
                    val dateFormat = SimpleDateFormat(DATE_FORMAT)
                    val parsedDate = dateFormat.parse(date)
                    if (parsedDate == null) {
                        null
                    } else {
                        toCalendar(parsedDate)
                    }
                }
            }
        }

        @JvmStatic
        fun parseTime(time: String): Calendar? {
            return when (time) {
                "" -> null
                else -> {
                    var times = time.split(TIME_DELIMITER)
                    var currentDate = Calendar.getInstance()
                    currentDate.set(Calendar.HOUR_OF_DAY, times[0].toInt())
                    currentDate.set(Calendar.MINUTE, times[1].toInt())
                    currentDate.set(Calendar.SECOND, 0)
                    currentDate
                }
            }
        }

        @JvmStatic
        fun getDateTime(date: Calendar, time: Calendar): Calendar {
            var returnValue = date

            returnValue.set(Calendar.HOUR_OF_DAY, time.get(Calendar.HOUR_OF_DAY))
            returnValue.set(Calendar.MINUTE, time.get(Calendar.MINUTE))
            returnValue.set(Calendar.SECOND, 0)

            return returnValue
        }

        @JvmStatic
        fun getPeriod(fromDate: Calendar, toDate: Calendar): Int {
            val diffTime = toDate.timeInMillis - fromDate.timeInMillis
            return (diffTime / MILLIS_OF_DAY).toInt()
        }

        @JvmStatic
        fun getWeekIndex(targetDateTime: Calendar): Int {
            return targetDateTime.get(Calendar.DAY_OF_WEEK) - 1
        }

        @JvmStatic
        fun toDate(targetDateTime: Calendar?): Date? {
            return targetDateTime?.time
        }

        @JvmStatic
        fun toCalendar(targetDateTime: Date): Calendar {
            var returnValue = Calendar.getInstance()
            returnValue.time = targetDateTime
            return returnValue
        }

        @JvmStatic
        fun isSameMonth(targetDate: Calendar, sourceMonth: Int): Boolean {
            return isSame(Calendar.MONTH, targetDate, sourceMonth - 1)
        }

        @JvmStatic
        fun isSameDay(targetDate: Calendar, sourceDay: Int): Boolean {
            return isSame(Calendar.DAY_OF_MONTH, targetDate, sourceDay)
        }

        fun isSameDayOfWeekInMonth(targetDate: Calendar, sourceDayOfWeek: Int): Boolean {
            return isSame(Calendar.DAY_OF_WEEK_IN_MONTH, targetDate, sourceDayOfWeek)
        }

        fun isSameWeek(targetDate: Calendar, sourceWeek: Int): Boolean {
            return isSame(Calendar.DAY_OF_WEEK, targetDate, sourceWeek)
        }

        @JvmStatic
        fun isSame(targetUnit: Int, target: Calendar, source: Int): Boolean {
            val targetYear = target.get(targetUnit)
            return targetYear == source
        }
    }
}

関連記事

Kotlin ～ 入門編 ～
https://dk521123.hatenablog.com/entry/2018/09/13/001546
日付・時間 について ～ 入門編 ～
https://dk521123.hatenablog.com/entry/2014/11/18/235600
日付・時間 について ～ 基本編 ～
https://dk521123.hatenablog.com/entry/2016/10/12/235711
日付・時間 について ～ System.currentTimeMillis / System.nanoTime ～
https://dk521123.hatenablog.com/entry/2017/04/25/223122
日付・時間 について ～ Java8編 ～
https://dk521123.hatenablog.com/entry/2018/02/24/014650