任意输入两个年月份，求出它们之间的天数，不能使用任何Date提供的方法。

呃，哪里的面试题啊，黑马的吗？
我想了下，不知道对不对，打个比方：求2014年3月到2012年8月这两个之间的，
可以把天数分为三个部分来求，第一个部分2012年剩下的天数，第二个部分2012年到2014年间整年数的天数，第三个部分2014年过去的天数，然后把三个天数想加就得到总天数了。
大概思路就这样，不知道对不对。

天天酱油~~

我的思路是:
1.将两个时间分别转换成对应的毫秒值;
2.将两个毫秒值相减,获取差;
3.用差值/1000/60/60/24,这样就得出相差的天数.


但是我的date相关的学的不好,代码就不写了

☆枫の云 发表于 2014-7-18 01:05
呃，哪里的面试题啊，黑马的吗？
我想了下，不知道对不对，打个比方：求2014年3月到2012年8月这两个之间的 ...

不是黑马的，是我面试西安的一公司的笔试题。面试的时候是手写的我也不知道对不对，你的思路自己可以实现一下，但是首先要判断瑞年，也就是二月份的天数，然后就想到了基础视频中的构表法，把12个月份的天数写到数组中，循环想加。这是只能在一年中的算法，隔年的，判断瑞年或者不是瑞年的，再加356或着355。我的思路是这样的，不过隔年份的不好判断，所以我就只做了一年之中计算天数的！

idency 发表于 2014-7-18 01:23
我的思路是:
1.将两个时间分别转换成对应的毫秒值;
2.将两个毫秒值相减,获取差;

嗯，可行！挺好的！不过还得判断瑞年！

看看这样行不行哦：
public static int getActualDaysOfClass(Calendar from, Calendar to) {
    int count = 0;
    Calendar temp = from;
    //把to这一天也包括
    to.add(Calendar.DAY_OF_MONTH, 1);
    while (temp.before(to)) {
        count++;
        temp.add(Calendar.DAY_OF_MONTH, 1);
    }
    return count;
}

看看这样行不行：
public static int getIntervalDays(Calendar from, Calendar to) {
    int count = 0;
    Calendar temp = from;
    //把to这一天也包括
    to.add(Calendar.DAY_OF_MONTH, 1);
    while (temp.before(to)) {
        count++;
        temp.add(Calendar.DAY_OF_MONTH, 1);
    }
    return count;
}

网络问题。多次提交。╮(╯▽╰)╭

这是我的思路，刚学Java没几天，质量不太好，不过还能计算出来，勉强的看一下吧！:'(
思路: 1.首先判断起始年和终止年每年的天数，包含起始年不包含终止年
         2.判断一年中每个月份的天数
         3.判断输入的日期是否符合要求
         4.计算一年中已经过了的天数
         5.起始年和终止年之间的天数=起始年到终止年整年的天数+终止年已过的天数-起始年已过的天数

1. class DateDemo
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 int y1=1989,m1=7,d1=1;
   
6.                 int y2=1990,m2=8,d2=3;
   
7.                 int year=0,count=0,result=0;
   
8.                 //把整年换算成天
   
9.                 for(int i=y1;i<y2;i++)
   
10.                 {
    
11.                         if(i%4==0&&i%100!=0||i%400==0)
    
12.                                 year=366;
    
13.                         else
    
14.                                 year=365;
    
15.                         count+=year;
    
16.                 }
    
17.                 //终止年已经过的天数加上[起始年,终止年)整年的天数，再减去起始年已经过的天数
    
18.                 System.out.println(count+mathDays(y2,m2,d2)-mathDays(d1,m1,d1));
    
19.         }
    
20.         public static int mathDays(int Y,int M,int D)
    
21.         {
    
22.                 int days=0,count=0;
    
23.                 //判断闰年2月为29天，平年2月为28天，4、6、9、11月为30天，其余月份为31天
    
24.                 if(M==2)
    
25.                 {
    
26.                         if(Y%4==0&&Y%100!=0||Y%400==0)
    
27.                                 days=29;
    
28.                         else
    
29.                                 days=28;
    
30.                 }
    
31.                 else if(M==4||M==6||M==9||M==11)
    
32.                                 days=30;
    
33.                 else
    
34.                                 days=31;
    
35.                 //年份小于0，或月份不在[1，12]，或天数不符合前面月份判断条件的，不存在该日期
    
36.                 if(Y<0||(M<1||M>12)||(D<1||D>days))
    
37.                 {
    
38.                         System.out.println("不存在该日期！");
    
39.                         return 0;
    
40.                 }
    
41.                 //计算年份中已经过的天数
    
42.                 for(int i=0;i<=M;i++)
    
43.                 {
    
44.                         if(i==M)
    
45.                                 count+=D;
    
46.                         else
    
47.                                 count+=days;
    
48.                 }
    
49.                 return count;
    
50.         }
    
51. }
    

复制代码

正确性应该没问题，拿Python内置的功能验算过几个日期。但觉得daysToDate()方法相当ugly，有空再优化。面试手写还不能调试，肯定过不了关的，当练习了。

1. public class Test {
   
2. 
   
3.     public static void main(String[] args) {
   
4. 
   
5.         MyDate d1 = new MyDate(1999, 1, 1);
   
6.         MyDate d2 = new MyDate(2006, 7, 1);
   
7.         System.out.println(d1.daysToDate(d2));
   
8.     }
   
9. 
   
10. 
    
11. }
    
12. 
    
13. class MyDate {
    
14.     private static final int[] DAYSINMONTH = {31, 28, 31, 30, 31, 30, 31, 31, 30
    
15.         ,31, 30, 31};
    
16.     private int year;
    
17.     private int month;
    
18.     private int day;
    
19. 
    
20.     MyDate(int year, int month, int day) {
    
21.         this.year = year;
    
22.         this.month = month;
    
23.         this.day = day;
    
24.     }
    
25. 
    
26.     public int daysToDate(MyDate aDate) {
    
27.         int compareResult = this.compareTo(aDate);
    
28.         if (compareResult == 0)
    
29.             return 0;
    
30.         else if (compareResult > 0)
    
31.             return aDate.daysToDate(this);
    
32. 
    
33.         int yearDiff = aDate.year - year;
    
34.         // same year
    
35.         if (yearDiff == 0)
    
36.             return daysToDateInSameYear(aDate);
    
37. 
    
38.         int totalDaysDiff = (yearDiff - 1) * 365;
    
39.         for(int i = year + 1; i < aDate.year; i++)
    
40.             if (isLeapYear(i))
    
41.                 totalDaysDiff++;
    
42. 
    
43.         // days between this and year-end
    
44.         totalDaysDiff += daysToDateInSameYear(new MyDate(year, 12, 31));
    
45. 
    
46.         // days between Jan 1st and aDate
    
47.         totalDaysDiff = totalDaysDiff + 1 +
    
48.             new MyDate(aDate.year, 1, 1).daysToDateInSameYear(aDate);
    
49. 
    
50.         return totalDaysDiff;
    
51.     }
    
52. 
    
53.     private boolean isLeapYear(int yr) {
    
54.         if (yr % 100 != 0 && yr % 4 == 0 || yr % 400 == 0)
    
55.             return true;
    
56.         return false;
    
57.     }
    
58. 
    
59.     private int compareTo(MyDate aDate) {
    
60.         if (year == aDate.year) {
    
61.             if (month == aDate.month) {
    
62.                 if (day == aDate.day)
    
63.                     return 0;
    
64.                 else
    
65.                     return day - aDate.day;
    
66.             }
    
67.             else
    
68.                 return month - aDate.month;
    
69.         }
    
70.         else
    
71.             return year - aDate.year;
    
72.     }
    
73. 
    
74.     private int daysToDateInSameYear(MyDate aDate) {
    
75. 
    
76.         int daysDiff = 0;
    
77.         if (month == aDate.month)
    
78.             daysDiff = aDate.day - day;
    
79.         else {
    
80.             for (int i = month; i <= aDate.month; i++) {
    
81.                 if (i == month) {
    
82.                     daysDiff += DAYSINMONTH[i - 1] - day;
    
83.                 }
    
84.                 else if (i == aDate.month)
    
85.                     daysDiff += aDate.day;
    
86.                 else
    
87.                     daysDiff += DAYSINMONTH[i - 1];
    
88.             }
    
89.         }
    
90.         if (isLeapYear(year)) {
    
91.             if (month * 100 + day <= 228 &&
    
92.                     aDate.month * 100 + aDate.day > 228)
    
93.                 daysDiff ++;
    
94.         }
    
95.         return daysDiff;
    
96.     }
    
97.    
    
98. }

复制代码

1.         public static void compare() {
   
2.                 Scanner scanner = new Scanner(System.in);
   
3.                 System.out.print("year 1 :\t");
   
4.                 int year1 = scanner.nextInt();
   
5.                 System.out.print("month 1 :\t");
   
6.                 int month1 = scanner.nextInt();
   
7.                 System.out.print("date 1 :\t");
   
8.                 int date1 = scanner.nextInt();
   
9.                 System.out.print("year 2 :\t");
   
10.                 int year2 = scanner.nextInt();
    
11.                 System.out.print("month 2 :\t");
    
12.                 int month2 = scanner.nextInt();
    
13.                 System.out.print("date 2 :\t");
    
14.                 int date2 = scanner.nextInt();
    
15. 
    
16.                 Calendar d1 = Calendar.getInstance();
    
17.                 d1.set(year1, month1, date1);
    
18.                 Calendar d2 = Calendar.getInstance();
    
19.                 d2.set(year2, month2, date2);
    
20.                 System.out.println(getDaysBetween(d1, d2));
    
21.                
    
22.                 scanner.close();
    
23.         }
    
24. 
    
25.         static int getDaysBetween(Calendar d1, Calendar d2) {
    
26.                 if (d1.after(d2)) {
    
27.                         Calendar swap = d1;
    
28.                         d1 = d2;
    
29.                         d2 = swap;
    
30.                 }
    
31.                 int days = d2.get(Calendar.DAY_OF_YEAR) - d1.get(Calendar.DAY_OF_YEAR);
    
32.                 int y2 = d2.get(Calendar.YEAR);
    
33.                 if (d1.get(Calendar.YEAR) != y2) {
    
34.                         d1 = (Calendar) d1.clone();
    
35.                         do {
    
36.                                 days += d1.getActualMaximum(Calendar.DAY_OF_YEAR);
    
37.                                 d1.add(Calendar.YEAR, 1);
    
38.                         } while (d1.get(Calendar.YEAR) != y2);
    
39.                 }
    
40.                 return days;
    
41.         }

复制代码

能用 Calendar 吧

fantacyleo 发表于 2014-7-18 13:02
正确性应该没问题，拿Python内置的功能验算过几个日期。但觉得daysToDate()方法相当ugly，有空再优化。面试 ...

高手就是不一样！:funk:

M单色调 发表于 2014-7-18 02:05
嗯，可行！挺好的！不过还得判断瑞年！

要求不是说两个时间之间的天数吗,我觉得不用考虑闰年吧!因为不管是什么年,每一天的时间都是24小时哈!是吧..

新手路过。

1. #include <stdio.h>
   
2. #define leap(y)   (y%4==0 && y%100!=0 || y%400==0)
   
3. 
   
4. struct d{int y,m,d;};
   
5. 
   
6. long days(struct d d1,struct d d2)
   
7. {
   
8.         int mon[2][13]= {  {0,31,28,31,30,31,30,31,31,30,31,30,31}, {0,31,29,31,30,31,30,31,31,30,31,30,31} };
   
9.         int i;
   
10.         long td=0;
    
11.         for(i=d1.y;i<d2.y;i++)//
    
12.                 td+=leap(i)?366:365;
    
13.         
    
14.         for(i=1;i<d1.m;i++)
    
15.                 td-=mon[leap(d1.y)][i];
    
16.         td-=d1.d-1;
    
17.         
    
18.         for(i=1;i<d2.m;i++)
    
19.                 td+=mon[leap(d2.y)][i];
    
20.         td+=d2.d-1;
    
21.         return td;
    
22. }
    
23. 
    
24. 
    
25. void main()
    
26. {
    
27.         struct d d1,d2;
    
28.         long td;
    
29.         printf("first date:");
    
30.         scanf("%d-%d-%d",&d1.y,&d1.m,&d1.d);
    
31.         printf("second date:");
    
32.         scanf("%d-%d-%d",&d2.y,&d2.m,&d2.d);
    
33.         td=days(d1,d2);
    
34.         printf("%ld",td);
    
35. }

复制代码

先说下思路<假设输入的日期都是合法的>
思路：分为年月日三部分差的和作为最后的结果
（1）判断起始日期和结束日期之间相差的年。将这些年累加（每年判断是否是闰年，通过一个全局变量
（2）减去起始日期的已过月份所占的天数，加上结束日期已过月份的天数（通过查表法累加或减）
（3）减去起始日期的所在的天数，加上结束日期所在天数（通过查表法累加或减）上面是C实现的，java还没写，意思都一样

idency 发表于 2014-7-18 15:14
要求不是说两个时间之间的天数吗,我觉得不用考虑闰年吧!因为不管是什么年,每一天的时间都是24小时哈!是吧 ...

闰年多一天！就多24个小时呢？

应该用毫秒算》》。。

理了半天,没有思路过来看看