Unix时间戳转日期时间格式，C#、Java、Python各语言实现！

之前有个Q上好友没事问我，怎么自己写Unix时间戳转日期时间？于是我就顺手写了个C#版本给他！最近想起来，就萌发多写几个语言的版本分享，权当练习思路外加熟悉另外两种语言。

先说转换步骤

1. 先处理年份，从1970年开始处理，根据平年闰年的总秒数，先得到年，剩余的秒数再求月份；
2. 根据剩余秒数求得月份，因为2月的缘故，同样需要处理平年闰年‘；
3. 得天数，直接除以每天的总秒数，然后取得天；
4. 取小时、分钟、秒；

Python版本：

# -*- coding: UTF-8 -*- 
from datetime import datetime, tzinfo, timedelta
import pytz

class DateHelper:
    def unixTimestmpToDate(self,timestamp):
        #计算年
        (remainSeconds,year) = self.__get_year(timestamp)
        (remainSeconds,month) = self.__get_month(remainSeconds,year)
        (remainSeconds,day) = self.__get_day(remainSeconds)
        (remainSeconds,hour) = self.__get_hour(remainSeconds)
        (remainSeconds,minute) = self.__get_minute(remainSeconds)

        result = datetime(year, month, day, hour, minute, remainSeconds, 0, UTC(8))

        print result.strftime('%Y-%m-%d %H:%M:%S',)
       

    def __get_minute(self,timestamp):
        """
        计算分钟
        """
        min = timestamp / 60

        return (timestamp - min * 60, min)

    def __get_hour(self,timestamp):
        """
        计算小时
        """
        hour = timestamp / (60 * 60)

        return (timestamp - hour * 60 * 60, hour)

    def __get_day(self,timestamp):
        """
        计算天
        """
        #每天的秒数
        daySeconds = 24 * 60 * 60

        day = timestamp / daySeconds

        return (timestamp - day * daySeconds, day + 1)

    def __get_month(self, timestamp, year):
        """
        计算月份
        """
        #每天的秒数
        daySeconds = 24 * 60 * 60
        #每月的总秒数
        monthDays = [31 * daySeconds, 28 * daySeconds, 31 * daySeconds, 30 * daySeconds, 31 * daySeconds, 30 * daySeconds, 31 * daySeconds, 31 * daySeconds, 30 * daySeconds, 31 * daySeconds, 30 * daySeconds, 31 * daySeconds]
        
        if self.__is_leap_year(year):
            monthDays[1] = 29 * daySeconds

        totalSeconds = 0
        month = 0
        for second in monthDays:
            month +=1
            if second + totalSeconds > timestamp:
                break

            totalSeconds += second

        return (timestamp - totalSeconds, month)

    def __get_year(self,timestamp):
        """
        计算年份
        """
        year = 1969
        totalSeconds = 0

        while True:
            year +=1
            second = self.__get_year_seconds(year)
            #年份总秒数大于时间戳
            if totalSeconds + second > timestamp:
                break

            totalSeconds += second
           

        return (timestamp - totalSeconds,year)

    def __get_year_seconds(self,year):
        '''
        得到每一年的总秒数
        '''
        isLeapYear = self.__is_leap_year(year)

        if isLeapYear:
            return 366 * 24 * 60 * 60
        else:
            return 365 * 24 * 60 * 60

    def __is_leap_year(self,year):
        '''
        判断是否闰年
        '''
        if year % 4 == 0 and year % 100 != 0:
            return True
        elif year % 400 == 0:
            return True
        else:
            return False

class UTC(tzinfo):    
    """UTC 时区创建"""
    def __init__(self,offset=0):
        self._offset = offset

    def utcoffset(self, dt):
        return timedelta(hours=self._offset)

    def tzname(self, dt):
        return "UTC +%s" % self._offset

    def dst(self, dt):
        return timedelta(hours=self._offset)
        
if __name__ == "__main__":
    datehelper = DateHelper()
    datehelper.unixTimestmpToDate(1483200000)

 C#版本：

class DateHelper
    {
        /// <summary>
        /// unix时间戳转时间
        /// </summary>
        /// <param name="timestamp">时间戳</param>
        /// <returns></returns>
        public static DateTime UixTimestmpToDate(int timestamp)
        {
            int remainSeconds;
            int year = GetYear(timestamp, out remainSeconds);

            int seconds = remainSeconds;
            int month = GetMonth(seconds, year, out remainSeconds);

            // seconds = remainSeconds;
            int day = GetDay(remainSeconds, out remainSeconds);
            int hour = GetHours(remainSeconds, out remainSeconds);
            int minute = GetMinute(remainSeconds, out remainSeconds);

            return new DateTime(year, month, day, hour, minute, remainSeconds);
        }

        /// <summary>
        /// 计算分钟
        /// </summary>
        /// <param name="timestamp"></param>
        /// <param name="remainSeconds">剩余秒数</param>
        /// <returns></returns>
        private static int GetMinute(int timestamp, out int remainSeconds)
        {
            var minute = timestamp / 60;

            remainSeconds = timestamp - minute * 60;

            return minute;
        }

        /// <summary>
        /// 计算小时
        /// </summary>
        /// <param name="timestamp"></param>
        /// <param name="remainSeconds"></param>
        /// <returns></returns>
        private static int GetHours(int timestamp, out int remainSeconds)
        {
            var hour = timestamp / (60 * 60);

            remainSeconds = timestamp - hour * 60 * 60;

            return hour;
        }

        /// <summary>
        /// 计算日
        /// </summary>
        /// <param name="timestamp"></param>
        /// <param name="remainSeconds"></param>
        /// <returns></returns>
        private static int GetDay(int timestamp, out int remainSeconds)
        {
            var daySeconds = 24 * 60 * 60;

            var day = timestamp / daySeconds;

            remainSeconds = timestamp - day * daySeconds;

            return day + 1;
        }

        /// <summary>
        /// 计算月
        /// </summary>
        /// <param name="timestamp"></param>
        /// <param name="year"></param>
        /// <param name="remainSeconds"></param>
        /// <returns></returns>
        private static int GetMonth(int timestamp, int year, out int remainSeconds)
        {
            // 每天的秒数
            var daySeconds = 24 * 60 * 60;
            //每月的总秒数
            var monthDays = new int[] { 31 * daySeconds, 28 * daySeconds, 31 * daySeconds, 30 * daySeconds, 31 * daySeconds, 30 * daySeconds, 31 * daySeconds, 31 * daySeconds, 30 * daySeconds, 31 * daySeconds, 30 * daySeconds, 31 * daySeconds };


            if (IsLeepYear(year))
                monthDays[1] = 29 * daySeconds;

            var totalSeconds = 0;
            var month = 0;
            foreach (var second in monthDays)
            {
                month += 1;
                if (second + totalSeconds > timestamp)
                    break;

                totalSeconds += second;
            }
            remainSeconds = timestamp - totalSeconds;
            return month;
        }

        /// <summary>
        /// 计算年
        /// </summary>
        /// <param name="timestamp"></param>
        /// <param name="remainSeconds"></param>
        /// <returns></returns>
        private static int GetYear(int timestamp, out int remainSeconds)
        {
            int year = 1969, totalSeconds = 0;

            while (true)
            {
                year += 1;
                int second = GetYearSeconds(year);
                //年份总秒数大于时间戳
                if (totalSeconds + second > timestamp)
                    break;

                totalSeconds += second;

            }

            remainSeconds = timestamp - totalSeconds;

            return year;
        }

        /// <summary>
        /// 得到每一年的总秒数
        /// </summary>
        /// <param name="year"></param>
        /// <returns></returns>
        private static int GetYearSeconds(int year)
        {
            if (IsLeepYear(year))
                return 366 * 24 * 60 * 60;
            else
                return 365 * 24 * 60 * 60;
        }

        /// <summary>
        /// 判断闰年
        /// </summary>
        /// <param name="year"></param>
        /// <returns></returns>
        private static bool IsLeepYear(int year)
        {

            if (year % 4 == 0 && year % 100 != 0)
                return true;
            else if (year % 400 == 0)
                return true;
            else
                return false;
        }

/**
 * Created by chong on 2017/7/4.
 */
public class DateHelper {
    /**
     * unix时间戳转时间
     *
     * @param timestamp 时间戳
     * @return
     * @throws ParseException
     */
    public static Date uixTimestmpToDate(int timestamp) throws ParseException {
        int[] year = GetYear(timestamp);
        int[] month = GetMonth(year[1], year[0]);
        int[] day = GetDay(month[1]);
        int[] hour = GetHours(day[1]);
        int[] minute = GetMinute(hour[1]);

        String strDate = String.format("%d-%d-%d %d:%d:%d", year[0], month[0], day[0], hour[0], minute[0], minute[1]);


        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //这次没有处理时区，所以直接输出的是UTC时间
        Date strtodate = formatter.parse(strDate);

        return strtodate;
    }

    /**
     * 计算分钟
     *
     * @param timestamp
     * @return
     */
    private static int[] GetMinute(int timestamp) {
        int minute = timestamp / 60;

        int remainSeconds = timestamp - minute * 60;

        return new int[]{minute, remainSeconds};
    }

    /**
     * 计算小时
     *
     * @param timestamp
     * @return
     */
    private static int[] GetHours(int timestamp) {
        int hour = timestamp / (60 * 60);

        int remainSeconds = timestamp - hour * 60 * 60;

        return new int[]{hour, remainSeconds};
    }

    /**
     * 计算日
     *
     * @param timestamp
     * @return
     */
    private static int[] GetDay(int timestamp) {
        int daySeconds = 24 * 60 * 60;

        int day = timestamp / daySeconds;

        int remainSeconds = timestamp - day * daySeconds;

        return new int[]{day + 1, remainSeconds};
    }

    /**
     * 计算月
     *
     * @param timestamp
     * @param year
     * @return
     */
    private static int[] GetMonth(int timestamp, int year) {
        // 每天的秒数
        int daySeconds = 24 * 60 * 60;
        //每月的总秒数
        int[] monthDays = new int[]{31 * daySeconds, 28 * daySeconds, 31 * daySeconds, 30 * daySeconds, 31 * daySeconds, 30 * daySeconds, 31 * daySeconds, 31 * daySeconds, 30 * daySeconds, 31 * daySeconds, 30 * daySeconds, 31 * daySeconds};


        if (IsLeepYear(year))
            monthDays[1] = 29 * daySeconds;

        int totalSeconds = 0, month = 0;
        for (int second : monthDays) {
            month += 1;
            if (second + totalSeconds > timestamp)
                break;

            totalSeconds += second;
        }
        int remainSeconds = timestamp - totalSeconds;
        return new int[]{month, remainSeconds};
    }

    /**
     * 计算年
     *
     * @param timestamp
     * @return
     */
    private static int[] GetYear(int timestamp) {
        int year = 1969, totalSeconds = 0;

        while (true) {
            year += 1;
            int second = GetYearSeconds(year);
            //年份总秒数大于时间戳
            if (totalSeconds + second > timestamp)
                break;

            totalSeconds += second;

        }
        int remainSeconds = timestamp - totalSeconds;

        return new int[]{year, remainSeconds};
    }

    /**
     * 得到每一年的总秒数
     *
     * @param year
     * @return
     */
    private static int GetYearSeconds(int year) {
        if (IsLeepYear(year))
            return 366 * 24 * 60 * 60;
        else
            return 365 * 24 * 60 * 60;
    }


    /**
     * 判断闰年
     *
     * @param year
     * @return
     */
    private static boolean IsLeepYear(int year) {

        if (year % 4 == 0 && year % 100 != 0)
            return true;
        else if (year % 400 == 0)
            return true;
        else
            return false;
    }


}