我刚刚在Java中玩游戏.写了这个小程序:
public class MaxValue{
public static void main(String[] args){
int i = Integer.MAX_VALUE;
for(int j = 1; j<=10;j++){
System.out.println(i*j);
}
}
}
输出如下:
2147483647
-2
2147483645
-4
2147483643
-6
2147483641
-8
2147483639
-10
现在我很惊讶.我不知道如何解释这个输出.我知道我可以使用long代替处理超过整数最大限制的值.但是我只想知道java如何计算这个？
是否有可能在发生整数溢出时抛出某种运行时异常,而不是静默失败.例如
int x = 100000000 * 1000000000;
1569325056由于溢出而打印,我想要的是获得某种运行时异常
我试图通过乘以毫秒来计算30天,但结果不断变为days_30值的负数,我不知道为什么.
任何建议都非常感谢!
代码链:
// check to ensure proper time has elapsed
SharedPreferences pref = getApplicationContext()
.getSharedPreferences("DataCountService", 0);
long days_30 = 1000 * 60 * 60 * 24 * 30;
long oldTime = pref.getLong("smstimestamp", 0);
long newTime = System.currentTimeMillis();
if(newTime - oldTime >= days_30){
days_30值的结果为:-1702967296
PS
double days_30 = 1000 * 60 * 60 * 24 * 30;
double oldTime = pref.getLong("smstimestamp", 0);
double newTime = System.currentTimeMillis();
if(newTime - oldTime >= days_30){
结果较小 - 但仍为负数.-1.702967296E9
我正在使用JodaTime jar和Oracle Java 8.我正在接收来自固件设备的数据包,它的开始时间是2000年1月1日的开始.我需要获得自2000年1月1日以来的秒数.数学似乎很简单,但由于某种原因,它给了我一个负值,它出现在1999年的一个时间,而不是当前时间:
import org.joda.time.DateTime;
import org.joda.time.DateTimeZone;
public class TimeIssue {
private DateTime currentTime = DateTime.now(DateTimeZone.UTC);
private DateTime zeroPointTime = new DateTime(2000, 1, 1, 0, 0, DateTimeZone.UTC);
private void checkTime(){
System.out.println("current time: " + currentTime);
System.out.println("current time to secs: " + timetos(currentTime));
}
private int timetos(DateTime time){
return (int)(time.getMillis() - zeroPointTime.getMillis())/1000;
}
public static void main(String[] args) {
TimeIssue issue = new TimeIssue();
issue.checkTime();
}
}
输出:
current time: 2014-07-09T21:28:46.435Z
current time in seconds: -1304974
current time from seconds: …我有一个需要转换为整数的long值.当我使用强制转换时,时间整数值给出一个负值,这是不期望的.但是当我使用该intValue()方法时Long,会出现预期的结果.
我想知道cast和using intValue()方法的区别
铸造实例
int days = (int) ((toDate.getTime() - fromDate.getTime()) / (1000 * 60 * 60 * 24));
intValue示例
int days = ((Long) ((toDate.getTime() - fromDate.getTime()) / (1000 * 60 * 60 * 24))).intValue();
编辑:更详细说明示例以显示减值而不会出现溢出,如评论中所示.在转换之前,结果是27.当转换时,值变为-22.但是如果使用intValue方法,结果是27.
码
System.out.println("nextDeliveryDate = " + nextDeliveryDate);
System.out.println("nextDeliveryDate.getTime() = " + nextDeliveryDate.getTime());
System.out.println("expectedDeliveryDate = " + expectedDeliveryDate);
System.out.println("expectedDeliveryDate.getTime() = " + expectedDeliveryDate.getTime());
System.out.println("nextDeliveryDate.getTime() - expectedDeliveryDate.getTime() = " + (nextDeliveryDate.getTime() - expectedDeliveryDate.getTime()));
System.out.println("(nextDeliveryDate.getTime() - expectedDeliveryDate.getTime()) / (1000 * 60 * 60 …我写了一个计算方法来计算父亲多久以前和他儿子一样多的年龄,以及从现在开始多少年这是真的.出乎意料的是,对于一个8岁的父亲和一个3岁的儿子来说,它回归"2 - 2年前".同样出人意料的是,对于一个3岁的父亲和一个2岁的儿子,它将在"1年后回归".我并不担心如何改进代码,因为我已经知道如何做到这一点.相反,我很困惑为什么for循环计数器在它应该递增时似乎递减.
这是我的代码.
public class TwiceAsOld {
public static void twiceAsOld (int currentFathersAge, int currentSonsAge) {
int yearsAgo;
int yearsFromNow;
int pastFathersAge = currentFathersAge;
int pastSonsAge = currentSonsAge;
int futureFathersAge = currentFathersAge;
int futureSonsAge = currentSonsAge;
for (yearsAgo = 0; pastFathersAge != 2 * pastSonsAge; yearsAgo++) {
pastFathersAge--;
pastSonsAge--;
}
System.out.println("The father was last twice as old as the son " + yearsAgo + " years ago.");
for (yearsFromNow = 0; futureFathersAge != 2 * futureSonsAge; yearsFromNow++) {
futureFathersAge++; …我的问题与此有关 我如何检查Java中的两个数字相乘是否会导致溢出？
在我的应用程序中,x和y是动态计算的,在我的公式中的某处我必须乘以x和y.
int x=64371;
int y=64635;
System.out.println((x*y));
我得错了输出 -134347711
我可以通过更改变量x和y类型快速修复上面的内容int,long并获得上述案例的正确答案.但是,没有出示担保说x和y不会增长超过最大容量long为好.
题
为什么我在这里得到一个负数,即使我没有将最终结果存储在任何变量中？(为了好奇)
因为,我不会提前知道x和y的值,有没有更快的方法来避免这种溢出.也许通过将所有x和y除以某个大常数来整个应用程序运行,或者我应该log在乘以它们之前采用x和y？(实际问题)
编辑:
澄清
应用程序在大数据集上运行,这需要数小时才能完成.拥有一个不太慢的解决方案会更好.
由于最终结果用于比较(它们只需要与原始结果成比例),如果能够获得巨大的性能提升,则最终值中的误差为±5%是可以接受的.
这可能看起来很简单，但我没有任何答案。当我写：
System.out.println (100 * 1000 * 10000 * 100000);
System.out.println (100 * 1000 * 10000 * 100000.0);
它返回这些值：
276447232
1.0E14
我知道这与某些数据类型的最大值有关。但我只想明确回答为什么它为两个方程返回这些确切值。如果有人可以向我解释这一点，我将不胜感激。
第一个返回值与 int 数据类型的最大值不匹配，这就是我感到困惑的原因。我假设的第二个返回值是双精度值或浮点值，但我不确定。
我已经学会了如何创建自己的Comparator，例如，创建一个简单的比较基于absolute value
class absComparator implements Comparator<Integer> {
public int compare(Integer a, Integer b) {
return a * a - b * b;
}
}
当然，这可以用于自定义排序：
List<Integer> list_1 = new ArrayList<>(Arrays.asList(-3, -2, -1, 0, 1, 2));
list_1.sort(new absComparator());
>>> [0, -1, 1, -2, 2, -3]
所以这一切都很好，但是如果我只想比较基于这个比较器的两个整数来给出一个布尔值怎么办？
// Currently:
System.out.println(-2>1);
>>> false
那么我如何true通过比较-2和1使用来获得 a absComparator？