时间处理方法集合 java

最新推荐文章于 2024-11-03 11:01:20 发布
最新推荐文章于 2024-11-03 11:01:20 发布
阅读量129 收藏
点赞数
分类专栏： java算法 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qweasdzxc01233210/article/details/103990915
版权

时间处理方法集合 java

package com.XXX.utils;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Locale;

public class MyDateUtil {
	
	private final static String DATE_FORMAT_YYYY = "yyyy";
	private final static String DATE_FORMAT_MM = "MM";
	private final static String DATE_FORMAT_dd = "dd";
	private final static String DATE_FORMAT_YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";
	private final static String DATE_FORMAT_YYMMDDHHMMSS = "yyMMddHHmmss";
	private final static String DATE_FORMAT_YYYYMMDDHHMMSSSSS = "yyyyMMddHHmmssSSS";
	 
	/**
     * 得到去年:yyyy
     * 例：2018
     * @return
     */
    public static String getLastYear() {
        SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT_YYYY);
        return String.valueOf(Integer.valueOf(sdf.format(new Date()))-1);
    }
    
	/**
     * 得到当前年:yyyy
     * 例：2019
     * @return
     */
    public static String getNowYear() {
        SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT_YYYY);
        return sdf.format(new Date());
    }
    
    /**
     * 得到当前月:MM
     * 例：01
     * @return
     */
    public static String getNowMonth() {
        SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT_MM);
        return sdf.format(new Date());
    }
    
    /**
     * 得到当前日:dd
     * 例：25
     * @return
     */
    public static String getNowDay() {
        SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT_dd);
        return sdf.format(new Date());
    }
    
    
	/**
     * 得到当前时间:yyyy-MM-dd HH:mm:ss
     * 例：2019-01-09 16:10:00
     * @return
     */
    public static String getNowDate() {
        SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT_YYYY_MM_DD_HH_MM_SS);
        return sdf.format(new Date());
    }
    
	 /**
     * 得到当前时间:yyMMddhhmmss
     * 例：181226104457
     * @return
     */
    public static String getYearToSecondString() {
        SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT_YYMMDDHHMMSS);
        return sdf.format(new Date());
    }
    
    /**
     * 得到当前时间:yyyyMMddhhmmssSSS
     * 例：20190301114059123
     * @return
     */
    public static String getYearToMillisecondString() {
        SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT_YYYYMMDDHHMMSSSSS);
        return sdf.format(new Date());
    }
    
    /**
     * 日期转换
     * 例：2018/9/1 0:00:00	转换成	2018-09-01 00:00:00
     * @return
     */
    public static String getConvertDatesFormat(String dateData) {
    	String newDateData = "";
    	if(dateData!=null && !"".equals(dateData.trim())){
    		String dateArray[] = dateData.split(" ")[0].split("/");
            String timeArray[] = dateData.split(" ")[1].split(":");
            
            String yearString = dateArray[0].trim();
            String monthString = dateArray[1].trim();
            String dayString = dateArray[2].trim();
            String hourString = timeArray[0].trim();
            String minuteString = timeArray[1].trim();
            String secondString = timeArray[2].trim();
            
            monthString = monthString.length()<2?("0"+monthString):monthString;
            dayString = dayString.length()<2?("0"+dayString):dayString;
            hourString = hourString.length()<2?("0"+hourString):hourString;
            minuteString = minuteString.length()<2?("0"+minuteString):minuteString;
            secondString = secondString.length()<2?("0"+secondString):secondString;
            
            newDateData = yearString+"-"+monthString+"-"+dayString+" "+hourString+":"+minuteString+":"+secondString;
    	}
    	return newDateData;
    }
    
    /**
	* 日期转换2
	* 例：2019-08-01T00:00:00+08:00	转换成	2019-08-01 00:00:00
     * @return
     */
    public static String getConvertDatesFormat2(String dateData) {
    	String dateStr = "";
		if(dateData!=null && dateData.indexOf("T")>=0 && dateData.indexOf("+")>=0) {
			try {
				DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
				Date date = df.parse(dateData);
				SimpleDateFormat df1 = new SimpleDateFormat ("EEE MMM dd HH:mm:ss Z yyyy", Locale.UK);
			    Date date1 =  df1.parse(date.toString());
			    DateFormat df2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			    dateStr = df2.format(date1);
			} catch (ParseException e) {
				e.printStackTrace();
			}
		}
		return dateStr;
    }
    
    /**
     * 获取前后日期yyyy-MM-dd
     * @param index
     * @return
     */
    public static String getLastOrNextDays(int index) {
    	String dateString = "";
    	
		Calendar calendar = Calendar.getInstance();  
	    calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) + index);  
	    Date today = calendar.getTime();  
	    SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
	    dateString = format.format(today);
	    
		return dateString;
	}
    
    //获取时间段列表
    /**
     * 输出前？天的所有日期	[...,"2019-01-02","2019-01-03",...."今天的日期"]
     * @param days
     * @return
     */
    public static List<List<String>> getDateList(int days) {
    	List<List<String>> dateList = new ArrayList<List<String>>();
    	for(int i=days;i<0;i++){
    		List<String> dateListItem = new ArrayList<String>();
    		
    		String dateBegin = MyDateUtil.getLastOrNextDays(i);
        	String dateEnd = MyDateUtil.getLastOrNextDays(i+1);
        	
        	dateListItem.add(dateBegin);
        	dateListItem.add(dateEnd);
        	dateList.add(dateListItem);
        	
    	}
		return dateList;
	}
    
    /**
     * 获取两个日期之间的所有日期
     * @param startTime	2018-06-28
     * @param endTime	2018-07-28
     * @return ["2018-06-28","2018-06-29",...."2018-07-28"]
     */
    public static List<String> getDateSegment(String startTime, String endTime) {
    	// 返回的日期集合
        List<String> days = new ArrayList<String>();
        
        try {
        	if(startTime.equals(endTime)) {
        		days.add(startTime);
        	}else {
        		DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
                Date start = dateFormat.parse(startTime);
                Date end = dateFormat.parse(endTime);

                Calendar tempStart = Calendar.getInstance();
                tempStart.setTime(start);

                Calendar tempEnd = Calendar.getInstance();
                tempEnd.setTime(end);
                tempEnd.add(Calendar.DATE, +1);// 日期加1(包含结束)
                while (tempStart.before(tempEnd)) {
                    days.add(dateFormat.format(tempStart.getTime()));
                    tempStart.add(Calendar.DAY_OF_YEAR, 1);
                }
        	}

        } catch (ParseException e) {
            e.printStackTrace();
        }

        return days;
    }
    
    /**
     * 获取某个日期的前几天的日期或后几天的日期
     * @param dateStr	2019-01-31
     * @param num	2
     * @return	2019-02-02
     * @throws Exception
     */
    public static String getDateByBeforeOrAfter(String dateStr, int num){
        Calendar c = Calendar.getInstance();
        Date date = null;
        try {
            date = new SimpleDateFormat("yy-MM-dd").parse(dateStr);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        c.setTime(date);
        int day1 = c.get(Calendar.DATE);
        c.set(Calendar.DATE, day1 + num);
 
        String newDate = new SimpleDateFormat("yyyy-MM-dd").format(c.getTime());
        return newDate;
    }
    
    /**
     * 计算指定日期之前或者之后的多少分钟
     * @param date
     * @param minute
     * @return
     */
    public static String getTimeByMinute(String oldTime, int minute) {
    	String newTime = "";
    	SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT_YYYY_MM_DD_HH_MM_SS);
    	try {
    		if(oldTime==null || "".equals(oldTime) || oldTime.length()<10) {
    			return newTime;
    		}
    		if(oldTime.length()==10) {
    			if(minute>=0) {
    				oldTime = oldTime + " 00:00:00";
    			}else {
    				oldTime = oldTime + " 23:59:59";
    			}
    			
    		}
    		
    		Date date = sdf.parse(oldTime);
    		Calendar calendar = Calendar.getInstance();
            calendar.setTime(date);
            calendar.add(Calendar.MINUTE, minute);
            newTime = sdf.format(calendar.getTime());
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			//e.printStackTrace();
			newTime = "";
		}
        
        return newTime;

    }
    
	/**
	 *  计算时差 单位：分钟
	 * @param actualLandingData
	 * @param actualDepartureTime
	 * @return
	 */
	public static String getTimeDifference(String minuendTime, String reductionTime) {
		// TODO Auto-generated method stub
		String timeDifference = "";
		try {
			if(minuendTime!=null && !"".equals(minuendTime) && minuendTime.length()==19 
					&& reductionTime!=null && !"".equals(reductionTime) && reductionTime.length()==19) {
				minuendTime = minuendTime.replaceAll("/", "-");
				reductionTime = reductionTime.replaceAll("/", "-");
				
				SimpleDateFormat simpleFormat = new SimpleDateFormat(DATE_FORMAT_YYYY_MM_DD_HH_MM_SS);
				Date minuendDate = simpleFormat.parse(minuendTime);
				Date reductionDate = simpleFormat.parse(reductionTime);  
			    long minuend = minuendDate.getTime();  
			    long reduction = reductionDate.getTime();  
			    int minutes = (int) ((minuend - reduction) / (1000 * 60));  
			    timeDifference = String.valueOf(minutes);
			}
		    
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			//e.printStackTrace();
			timeDifference = "";
		}  
	    
		return timeDifference;
	}
	
	/**
	 *  计算时差 单位：天
	 * @param actualLandingData
	 * @param actualDepartureTime
	 * @return
	 */
	public static String getTimeDifferenceForByDay(String minuendTime, String reductionTime) {
		// TODO Auto-generated method stub
		String timeDifference = "";
		try {
			if(minuendTime!=null && !"".equals(minuendTime)
					&& reductionTime!=null && !"".equals(reductionTime)) {
				
				minuendTime = minuendTime.length()==10?(minuendTime + " 00:00:00"):minuendTime;
				reductionTime = reductionTime.length()==10?(reductionTime + " 00:00:00"):reductionTime;
				
				minuendTime = minuendTime.replaceAll("/", "-");
				reductionTime = reductionTime.replaceAll("/", "-");
				
				SimpleDateFormat simpleFormat = new SimpleDateFormat(DATE_FORMAT_YYYY_MM_DD_HH_MM_SS);
				Date minuendDate = simpleFormat.parse(minuendTime);
				Date reductionDate = simpleFormat.parse(reductionTime);  
			    long minuend = minuendDate.getTime();  
			    long reduction = reductionDate.getTime();  
			    int day = (int) ((minuend - reduction) / (1000 * 60 * 60 * 24));  
			    timeDifference = String.valueOf(day);
			}
		    
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			//e.printStackTrace();
			timeDifference = "";
		}  
	    
		return timeDifference;
	}

    public static void main(String[] args) {
    	try {
    		System.out.println(getTimeByMinute("2019-04-05 00:50:00", 420-480));
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

    
}
妖怪131
关注
专栏目录
java 集合练习题
07-26
在这个“java集合练习题”中，我们主要关注如何使用Java集合框架来处理数据，特别是对于学生信息的存储、排序和输出。以下是对这个练习题的详细解析： 1. **集合框架简介**： Java集合框架是Java API的一部分，它...
Java异常处理+集合+IO流+多线程+网络编程
06-10
本课程是《Java初级至应用》系统课程的第三模块，全套课程精细讲解，课程超过其他机构30%的课程量，经过我们全套课程系统学习的同学，可轻松从事Java工程师或系统架构师岗位，课程提供全套代码笔记其它相关素材及...
Java时间处理集合
tingyu_521的专栏
08-27 99
package collections; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; import java.util.GregorianCalendar; //时间格式处理收集 public class DateFomatCollection { ...
时间日期处理工具类
Tomcat_wr8的博客
09-21 209
import org.apache.commons.lang3.StringUtils; import java.text.DateFormat; import java.text.ParseException; import java.text.ParsePosition; import java.text.SimpleDateFormat; import java.util.*; im...
java8处理日期时间的方法集合
Boy_Martin的博客
09-02 1509
java8处理时间的方法集合
java线程池分段处理list集合
qq_36005400的博客
07-22 1667
java线程池分段批量处理集合数据
Java集合之一—HashMap
热门推荐
深入浅出学JAVA
11-02 60万+
深入浅出学Java——HashMap 哈希表（hash table） 也叫散列表，是一种非常重要的数据结构，应用场景及其丰富，许多缓存技术（比如memcached）的核心其实就是在内存中维护一张大的哈希表，本文会对java集合框架中的对应实现HashMap的实现原理进行讲解，然后会对JDK7的HashMap源码进行分析。 一、什么是哈希表 在讨论哈希表之前，我们先大概了解下其他数据结构在新增，...
java 集合详解
weixin_62801797的博客
08-16 3094
Java 集合，也叫作容器，主要是由两大接口派生而来：一个是Collection接口，主要用于存放单一元素；另一个是Map接口，主要用于存放键值对。Collection接口有三个子主要的子接口：List ,Set,Queue。下面我们就来详细的介绍：List ,Set, Queue，MapList：存储的元素是有序可重复的。Set:存储的元素是无序不可重复的。Queue: 按特定的排队规则来确定先后顺序,可重复。
Java 基础面试题——集合
代码星辰的博客
02-14 2972
本文记录了 Java 基础中集合的相关面试题。
Java集合（全）
小杨的博客
05-03 1万+
一.Java集合框架概述 一方面，面向对象语言对事物的体现都是以对象的形式，为了方便对多个对象的操作，就要对对象进行存储。另一方面，使用Array存储对象方面具有一些弊端，而Java集合就像一种容器，可以动态的把多个对象的引用放入容器中。 1.数组Array存储 （1）数组在内存存储方面的特点： ①数组初始化以后，长度就确定了。 ②数组声明的类型，就决定了进行元素初始化的类型。 （2）数组在存储数据方面的弊端： ①数组初始化以后，.........
java中的集合
Janik的博客
11-21 2万+
java集合概述 Java 集合可分为 Collection 和 Map 两种体系 Collection接口：单列数据，定义了存取一组对象的方法的集合 List：元素有序(指的是存储时，与存放顺序保持一致)、可重复的集合 Set：元素无序、不可重复的集合 Map接口：双列数据，保存具有映射关系“key-value对”的集合 ArrayList和LinkedList的异同？ 答：二者都线程不安全，相对线程安全的Vector，执行效率高。此外，ArrayList是实现了基于动态数组的数据结构，Li
Java集合体系
Hello World!
07-29 4698
集合与数组的区别（1）长度区别集合长度可变，数组长度不可变（2）内容区别集合可存储不同类型元素，数组存储只可单一类型元素（3）元素区别集合只能存储引用类型元素，数组可存储引用类型，也可存储基本类型Java集合类可以用于存储数量不等的多个对象，还可用于保存具有映射关系的关联数组。在这里主要讲一些我们平常很常用的一些接口和一些实现类。Java集合可分为Collection和Map两种体系Collection接口单列数据，定义了存取一组对象的方法的集合Map接口。.........
在java中获取List集合中最大的日期时间操作
08-18
在 Java 中获取 List 集合中最大的日期时间操作是一个常见的需求，特别是在处理日期类型的数据时。下面将详细介绍如何获取 List 集合中最大的日期时间操作。 获取 List 集合中最大的日期时间操作 Java 中提供了...
java8如何通过Lambda处理List集合
08-25
Java 8 中使用 Lambda 处理 List 集合 Java 8 中引入了 Lambda 表达式，极大地简化了编程过程，提高了编程效率。今天，我们将探讨如何使用 Lambda 处理 List 集合，主要涉及到遍历、转换为 Map、分组和过滤等操作。...
java判定数组或集合是否存在某个元素的实例
08-31
Java编程语言提供了多种方法来判断数组或集合中是否存在特定的元素。...在特定场景下，如需进一步处理，可以利用`removeAll()`等集合操作方法。在实际编程中，应根据具体需求和性能要求选择合适的方法。
HashMap为什么线程不安全？
最新发布
rnnf_yyds的博客
11-03 419
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 930
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
服务器虚拟化
Hellc007的博客
10-30 971
服务器虚拟化是一种将物理服务器的计算资源分割为多个独立虚拟环境的技术，通过软件层将底层硬件资源抽象化并在上层构建多个虚拟机（Virtual Machine, VM）。每个虚拟机运行独立的操作系统和应用程序，相互之间不受干扰，具备类似于物理服务器的功能。这种技术使得一台物理服务器能够承担多台虚拟服务器的角色，从而极大地提升了硬件资源的利用率。服务器虚拟化的概念最早可追溯到20世纪60年代IBM大型机时代，当时虚拟化被用来将大型机的资源分配给多个任务，使得企业在有限的资源下能够同时运行多个应用。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 976
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
Java时间处理方法集锦
"Java时间处理方法集合" 在Java编程中，处理时间是一项常见的任务，包括获取当前时间、格式化时间字符串以及进行时间计算等。以下是对给定代码中相关知识点的详细说明： 首先，Java提供了多种类来处理时间，如`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值