用Java计算当前时间对象与形参传入时间对象之间间隔秒数的方法

Posted 2023-05-16

1)传进Calendar对象
/** *//**计算两个时间之间相隔天数
* @param startday 开始时间
* @param endday 结束时间
* @return
*/
public int getIntervalDays(Calendar startday,Calendar endday)...
//确保startday在endday之前
if(startday.after(endday))...
Calendar cal=startday;
startday=endday;
endday=cal;

//分别得到两个时间的毫秒数
long sl=startday.getTimeInMillis();
long el=endday.getTimeInMillis();

long ei=el-sl;
//根据毫秒数计算间隔天数
return (int)(ei/(1000*60*60*24));
(2)传进Date对象
/** *//**计算两个时间之间相隔天数
* @param startday 开始时间
* @param endday 结束时间
* @return
*/
public int getIntervalDays(Date startday,Date endday)...
//确保startday在endday之前
if(startday.after(endday))...
Date cal=startday;
startday=endday;
endday=cal;

//分别得到两个时间的毫秒数
long sl=startday.getTime();
long el=endday.getTime();

long ei=el-sl;
//根据毫秒数计算间隔天数
return (int)(ei/(1000*60*60*24));
同理，可以用相同的方法计算出任意两个时间相隔的小时数，分钟数，秒钟数等
注：以上方法是完全按时间计算，有时并不能令人满意，如：
startday="2006-10-11 20:00:00"
endday="2006-10-12 8:00:00"
计算结果为0，但是我们也许相让计算结果变为1，此时可以用如下方法实现：
在传参之前，先设定endday的时间，如：
endday.set(Calendar.HOUR_OF_DAY, 23);
endday.set(Calendar.MINUTE, 59);
endday.set(Calendar.SECOND, 59);
endday.set(Calendar.MILLISECOND, 59);
这样再传进去startday,endday，则结果就如我们所愿了。不过，如果嫌以上方法麻烦，可以参考以下方法：
(3)改进精确计算相隔天数的方法
public int getDaysBetween (Calendar d1, Calendar d2) ...
if (d1.after(d2)) ... // swap dates so that d1 is start and d2 is end
java.util.Calendar swap = d1;
d1 = d2;
d2 = swap;

int days = d2.get(Calendar.DAY_OF_YEAR) - d1.get(Calendar.DAY_OF_YEAR);
int y2 = d2.get(Calendar.YEAR);
if (d1.get(Calendar.YEAR) != y2) ...
d1 = (Calendar) d1.clone();
do ...
days += d1.getActualMaximum(Calendar.DAY_OF_YEAR);//得到当年的实际天数
d1.add(Calendar.YEAR, 1);
while (d1.get(Calendar.YEAR) != y2);

return days;
参考技术A 你用Calendar做的话：
//这是获取当前时间
Calendar ca1=Calendar.getInstance();
Calendar ca2=Calendar.getInstance();
//设置要传参的数 假设你传进来的参数为(都是int型的) year(年) month(月) date(日) hour(小时) minute(分钟) second(秒钟)
ca2.set(year,month,date,hour,minute,second);
//设置一个变量接收返回的相差值
int cha;
//如果ca1的时间在ca2的时间之前，则返回小于0 的值；如果ca1的时间在ca2的时间之后，则返回大于0的值。
cha=Math.abs(ca1.compareTo(ca2));
//由于取的是整型值，可能为负数所以用到数学包中的取绝对值，如果不取绝对值的话可以判断ca1是ca2后还是前的时前，我就不详细化了

js_函数参数的相关问题

目录

• arguments
  • argument对象是什么
  • 在传入实参情况下arguments对象与形参的对应关系
  • 在不传入参数情况下arguments对象与形参的对应关系
  • 在传入实参数与形参数不对等情况下形参与arguments对象的对应关系
  • 在预定义形参的情况下，形参与arguments的对应关系
• 总结

arguments

argument对象是什么

arguments是用来保存函数实参的对象，它在函数创建时会自动创建，在函数调用时会初始化。它保存有实参的值，callee属性（函数的指针），length属性（传入实参的数量）

在传入实参情况下arguments对象与形参的对应关系

        function a(val) {
            console.log(val); //3
            console.log(arguments[0]); //3
            arguments[0] = 7;
            console.log(val); //7
            val = 10;
            console.log(arguments[0]);//10
        }
        a(3);

在不传入参数情况下arguments对象与形参的对应关系

        function a(val) {
            console.log(val); //undefined
            console.log(arguments.length); //0
            arguments[0] = 7;
            console.log(val); //undefined
            console.log(arguments.length); //0
            val = 10;
            console.log(arguments[0]); //7
        }
        a();

在传入实参数与形参数不对等情况下形参与arguments对象的对应关系

        function a(val1, val2) {
            console.log(val1, val2); //3,undefined
            console.log(arguments[0], arguments[1], arguments.length); //3,undefined,1
            val1 = 10;
            val2 = 20;
            console.log(val1, val2); //10,20
            console.log(arguments[0], arguments[1], arguments.length); //10,undefined,1
            arguments[1] = 30;
            console.log(val2);//20
        }
        a(3);

在预定义形参的情况下，形参与arguments的对应关系

        function a(val1, val2 = 5) {
            console.log(val1, val2); //7,5
            console.log(arguments[0], arguments[1], arguments.length); //7,undefined,1
            val1 = 10;
            val2 = 20;
            console.log(val1, val2); //10,20
            console.log(arguments[0], arguments[1], arguments.length); //7,undefined,1
        }
        a(7);

总结

• arguments对象只有在传入参数时会与对应的形参进行绑定，此时修改形参会同时修改对应的arguments对象属性，修改arguments对象属性也会修改对应的形参值。
• 如果传入实参数与声明的形参数不对等。传入的实参会被写入arguments对象中，也会赋值给形参，在整个函数的运行中都只有它们会双向绑定，在此之后对剩余形参的赋值不会再和arguments对象进行绑定。也就是说，传入多少个实参，arguments就双向绑定多少个形参。
• 对任何形参进行预定义的情况下，arguments与形参不会进行双向绑定。修改形参的值或修该arguments的值不会影响到另一方。