如何在Java中获取两个日期之间的季度数

我有

fromDate

as

“01-Jan-2015”

和

toDate

as

“01-Apr-2015”

。我想查找

fromDate

和

toDate

之间的季度数。我的代码是

String fromDate = "01-Jan-2015";
            String toDate = "01-Apr-2015";

            ArrayList<String> quarters = new ArrayList<String>();
            DateFormat df = new SimpleDateFormat("dd-MMM-yyyy");
            DateFormat dfYY = new SimpleDateFormat("yy");

            Calendar cal = Calendar.getInstance();
            cal.setTime(df.parse(fromDate));

            Calendar cal1 = Calendar.getInstance();
            cal1.setTime(df.parse(toDate));

            while (cal1.getTime().after(cal.getTime())) {
                int month = cal.get(Calendar.MONTH) + 1;

                int quarter = month % 3 == 0 ? (month / 3) : (month / 3) + 1;

                quarters.add("Q" + quarter + "-" + dfYY.format(cal.getTime()));
                cal.add(Calendar.MONTH, 3);
            }

字符串fromDate=“01-Jan-2015”；
字符串toDate=“01-Apr-2015”；
ArrayList quarters=新的ArrayList（）；
DateFormat df=新的简化格式（“dd MMM yyyy”）；
DateFormat dfYY=新的简化格式（“yy”）；
Calendar cal=Calendar.getInstance（）；
cal.setTime（df.parse（fromDate））；
Calendar cal1=Calendar.getInstance（）；
cal1.setTime（df.parse（toDate））；
while（cal1.getTime（）.after（cal.getTime（）））{
int MOUNT=cal.get（日历月）+1；
国际季度=第%3个月==0？（第/3个月）：（第/3个月）+1；
添加（“Q”+quarter+“-”+dfYY.format（cal.getTime（）））；
计算添加（日历月，3）；
}

但它给出的输出是Q1-15，缺少Q2-15。如果我输入

toDate

作为“2015年4月2日”，则给出Q1-15、Q2-15。请告诉我哪里出了问题

while (cal1.getTime().after(cal.getTime()))

只要

cal1.getTime（）

是“2015年4月1日”，它就不再是“

cal.getTime（）

之后的”，因此while循环将停止。 这就是为什么它没有进行最后一次迭代，这会给你最后一个季度

你可以这样说：

while (cal1.getTime().after(cal.getTime()) || cal1.getTime().equals(cal.getTime()))

---

在循环的第一次迭代中，您将fromDate增加三个月。这使得它等于toDate，所以您不会得到另一个迭代

您需要

---

（cal1.getTime（）.after（cal.getTime（））| |（cal1.getTime（）.equals（cal.getTime（））

更新有关更简单、更短的解决方案，请参阅

我把我的答案留在这里，是为了演示这门课在相关工作中可能很方便

使用java.time 使用现代java.time类比使用麻烦的旧日期时间类容易得多。这些旧类现在是遗留的

这个答案假设“季度”指的是标准ISO 8601季度，即日历年中三个月的第一、第二、第三和第四组

该类表示一个仅限日期的值，不包含一天中的时间和时区

LocalDate start = LocalDate.of ( 2015 , Month.JANUARY , 1 );
LocalDate stop = LocalDate.of ( 2015 , Month.APRIL , 1 );

YearQuarter

将项目库添加到项目中以访问该类

开始和停止约会的四分之一

YearQuarter yqStart = YearQuarter.from ( start );
YearQuarter yqStop = YearQuarter.from ( stop );

一次循环四分之一，直到达到极限

这里的代码将循环建立在定义时间跨度的半开放方法的基础上，这种方法通常用于日期时间工作。开始是包含的，而结束是独占的。我建议在整个逻辑中始终使用这种方法，以避免歧义、混乱和错误。如果相反，您坚持使用封闭方法（包括开头和结尾），将

while

测试更改为“while not after”，

while（！yq.isAfter（yqStop））

int initialCapacity = ( int ) ( ( ChronoUnit.MONTHS.between ( start , stop ) / 3 ) + 3 ); // Probably `+1` is good enough, but I've not thought it through.
List<YearQuarter> yqs = new ArrayList<> ( initialCapacity );
YearQuarter yq = yqStart;
while ( yq.isBefore ( yqStop ) ) {  // Using Half-Open approach where the beginning is *inclusive* while the ending is *exclusive*.
    yqs.add ( yq );  // Collect this quarter.
    // Set up next loop.
    yq = yq.plusQuarters ( 1 );  // Move to next quarter.
}

启动/停止：2015-01-01/2015-04-01

yqStart/yqStop:2015-Q1/2015-Q2

yqs:[2015-Q1]

---

关于java.time 该框架内置于Java8及更高版本中。这些类取代了麻烦的旧日期时间类，如，&

该项目现已启动，建议迁移到类

要了解更多信息，请参阅.和搜索堆栈溢出以获取许多示例和解释。规范为

从哪里获得java.time类

• 后来
  • 内置的
  • 标准JavaAPI的一部分，带有捆绑实现
  • Java9添加了一些次要功能和修复
• 及
  • 大部分java.time功能都在中向后移植到Java6和Java7
• • 该项目专门为Android采用了ThreeTen Backport（如上所述）
  • 看

该项目使用其他类扩展了java.time。该项目是将来可能添加到java.time的一个试验场。您可以在这里找到一些有用的类，如、、。

IsoFields.QUARTER\u YEARS

Java8及更高版本中有一个专门的单元用于此目的：实现及其方法

---

试试这些方法，对我有用

public int getQuartersBetweenDates(Date startDate, Date endDate) {

    int numofquarters=0;
    String[] yearquarter=null;
    Date temp=startDate;
    String[] targetYearQuarter= getYearQuarter(endDate);
    if(endDate.after(startDate)){
        yearquarter=getYearQuarter(temp);
        while(!(targetYearQuarter[0].equalsIgnoreCase(yearquarter[0])
                      && targetYearQuarter[1].equalsIgnoreCase(yearquarter[1]))){
            yearquarter=addQuarters(1,yearquarter[0],yearquarter[1]);
            numofquarters++;
        }
    }
    else{
        yearquarter=getYearQuarter(temp);
        while(!(targetYearQuarter[0].equalsIgnoreCase(yearquarter[0])
                      && targetYearQuarter[1].equalsIgnoreCase(yearquarter[1]))){
            yearquarter=addQuarters(-1,yearquarter[0],yearquarter[1]);
            numofquarters--;
        }
    }
    return  numofquarters;
}

public String[] addQuarters(int numofQuarters,String year,String quarter){

    int tempyear=Integer.parseInt(year)+(numofQuarters/4);
    int tempquarter=Integer.parseInt(quarter.replace("Q",""))+(numofQuarters%4);
    if(tempquarter>4){
        tempquarter=tempquarter-4;
        tempyear+=1;
    }
    if(tempquarter<1){
        tempquarter=tempquarter+4;
        tempyear-=1;
    }
    year=String.valueOf(tempyear);
    quarter="Q"+tempquarter;
    return new String[]{year,quarter};
}

public int getquartersbetween日期（日期开始日期、日期结束日期）{
int numofquarters=0；
字符串[]yearquarter=null；
日期温度=开始日期；
字符串[]targetYearQuarter=getYearQuarter（endDate）；
如果（开始日期之后的结束日期））{
yearquarter=getYearQuarter（温度）；
while（！（targetYearQuarter[0]。相等信号情况（yearquarter[0]）
&&targetYearQuarter[1]。相等信号情况（yearquarter[1]））{
yearquarter=addQuarters（1，yearquarter[0]，yearquarter[1]）；
NUMOF++；
}
}
否则{
yearquarter=getYearQuarter（温度）；
while（！（targetYearQuarter[0]。相等信号情况（yearquarter[0]）
&&targetYearQuarter[1]。相等信号情况（yearquarter[1]））{
yearquarter=addQuarters（-1，yearquarter[0]，yearquarter[1]）；
Numof宿舍--；
}
}
返回宿舍；
}
公共字符串[]addQuarters（整数个季度、字符串年、字符串季度）{
int tempyear=Integer.parseInt（年）+（numofQuarters/4）；
int tempquarter=Integer.parseInt（quarter.replace（“Q”）+（numofQuarters%4）；
如果（临时季度>4）{
tempquarter=tempquarter-4；
年份+=1；
}
如果你在使用while循环或下载其他库时太尴尬了，请看我的答案。事实上，它要好得多，如此简短而甜蜜。
long delta = 
    IsoFields.QUARTER_YEARS.between(
        LocalDate.of(2015, 1, 1), 
        LocalDate.of(2015, 4, 1));
System.out.println(delta); // 1

public int getQuartersBetweenDates(Date startDate, Date endDate) {

    int numofquarters=0;
    String[] yearquarter=null;
    Date temp=startDate;
    String[] targetYearQuarter= getYearQuarter(endDate);
    if(endDate.after(startDate)){
        yearquarter=getYearQuarter(temp);
        while(!(targetYearQuarter[0].equalsIgnoreCase(yearquarter[0])
                      && targetYearQuarter[1].equalsIgnoreCase(yearquarter[1]))){
            yearquarter=addQuarters(1,yearquarter[0],yearquarter[1]);
            numofquarters++;
        }
    }
    else{
        yearquarter=getYearQuarter(temp);
        while(!(targetYearQuarter[0].equalsIgnoreCase(yearquarter[0])
                      && targetYearQuarter[1].equalsIgnoreCase(yearquarter[1]))){
            yearquarter=addQuarters(-1,yearquarter[0],yearquarter[1]);
            numofquarters--;
        }
    }
    return  numofquarters;
}

public String[] addQuarters(int numofQuarters,String year,String quarter){

    int tempyear=Integer.parseInt(year)+(numofQuarters/4);
    int tempquarter=Integer.parseInt(quarter.replace("Q",""))+(numofQuarters%4);
    if(tempquarter>4){
        tempquarter=tempquarter-4;
        tempyear+=1;
    }
    if(tempquarter<1){
        tempquarter=tempquarter+4;
        tempyear-=1;
    }
    year=String.valueOf(tempyear);
    quarter="Q"+tempquarter;
    return new String[]{year,quarter};
}