java里int类型的整数减去double类型的浮点类型数

最新推荐文章于 2025-08-25 12:19:32 发布

原创最新推荐文章于 2025-08-25 12:19:32 发布 · 3k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java

本文通过一个简单的Java程序示例，展示了整型(int)与浮点型(double)进行运算时可能出现的精度损失问题，并解释了这是由于十进制小数转换为二进制时的精度丢失导致。

int a=2;
double b=1.9;
System.Out.println（a-b）;

运行结果：0.100000009

十进制小数转换二进制的过程中又有精度损失
double类型是64位的数据类型而int是32位的数据类型。

确定要放弃本次机会？

福利倒计时

: :

立减 ¥

普通VIP年卡可用

立即使用

LinXi_Briup

关注关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
分享

复制链接

分享到 QQ

分享到新浪微博

扫一扫
举报

举报

Java八大类型详解

Jean·z的博客

05-23

1029

ASCII (ASCII 编码表一个字节表示 , 一个128个字符)Unicode (Unicode 编码表固定的大小的编码使用两个字节来表示字符, 字母和汉字统一都是占用两个字节, 这样浪费空间)utf-8 (编码表, 大小可变的编码, 字母使用1个字节, 汉字使用3个字节)gbk (可以表示汉字, 而且范围广, 字母使用1个字节, 汉字2个字节)gb2312 (可以表示汉字, gb2312 < gbk)big5 码(繁体中文, 台湾, 香港)

解决 java double 减 int 型产生的精度问题

DevilZn的博客

09-27

6723

1.01-1=0.010000000000000009? 我们先来看一段代码public class Test_1 { public static void main(String[] args) { String e = "1.01";//这里顺便写下把一个小数分为整数和小数部分 double s = Double.valueOf(e);//1.01

参与评论您还未登录，请先登录后发表或查看评论

java陷阱——浮点数相减

z466459262的专栏

08-17

873

[code] public class Test { public static void main(String[] args) { System.out.println(2.0 - 1.9); } } 计算的结果出乎意料：0.10000000000000009 但是加又没错。。为什么呢？某大侠说：计算机无法处理浮点数值额...!! 为什么...

java运算int转double_Java数值类型之间转换

weixin_34370110的博客

02-13

3994

Java之间的数值转换如图所示，实心箭头代表无数据丢失，虚线箭头代表可能丢失例如：123456789是一个大的整数，包含的位数比float类型能够表达的位数多，但这个数转换为float类型时，将会得到同样大小的结果，但却失去了一定的精度。int n = 123456789;float f =n; //f is 1.23456792E8当转换前后两个数进行二元操作时(例如n+f，n为整...

Java中Double类型的精确计算

柒弦宇轩

12-23

1546

复制代码 import java.math.BigDecimal; public class DoubleUtil { private static final int DEF_DIV_SCALE = 5; // 小数点后的保留位数 /** * Double精确的加法运算 * @param d1 被加数 * @param d2 加...

java处理浮点类型的加减乘除法出现小数点精度错乱的解决方法

ZW_KK的专栏

10-09

6292

如果你在java里面运行一下一段代码，你会发现会出现错乱的小数点： double d1 = 100.0234; double d2 = 12.0652; System.out.println(d1-d2);输出的结果可能是这样的：87.95819999999999 这个结果绝对不是我们所需要的结果咯，因为这个是科学计数的结果，如果你想要得到正确的结果，

7、C语言中的算术类型：整数与浮点类型解析

php55的博客

08-25

本文深入解析了C语言中的算术类型，包括整数和浮点类型的表示、范围、精度以及常见问题。详细讨论了有符号和无符号整数的区别、整数溢出与回绕的行为，以及浮点数的特殊值和精度误差。同时涵盖了隐式和显式类型转换的基本规则，并提供了避免常见算术错误的实用技巧。通过了解这些核心概念，开发者可以编写更健壮、可移植的C语言程序。

7、探索Java编程中的数字与类型

m9n0o的博客

05-29

145

本文深入探讨了Java编程中数字与类型的基础知识，包括整数和浮点数类型的使用方法、运算符的应用以及如何根据实际需求选择合适的数据类型。通过实例代码和练习题，帮助读者更好地掌握Java中数据类型的高效使用技巧。

12、Java基础数据类型全解析

zeta9的博客

05-31

本博客深入解析了Java的基础数据类型，包括整数和浮点数的特点及其局限性，详细介绍了数值运算中可能出现的溢出和舍入误差问题及解决方案。同时涵盖了常量的正确使用、算术表达式的编写、字符串处理方法，以及如何读取程序输入和生成格式化输出。通过实例讲解了如何使用BigInteger和BigDecimal来处理大数和高精度计算，并提供了完整的代码示例帮助读者加深理解。

53、Java 运算符与类型转换详解

y4z5a6b7的博客

08-07

本文详细解析了 Java 中的运算符与类型转换，涵盖了一元运算符、乘法、除法、取余和加法运算符的使用规则及特性，同时介绍了类型转换的语法、规则和注意事项。文章还讨论了异常处理、运算符优先级、结合性以及字符串连接的优化技巧，旨在帮助开发者正确高效地使用 Java 进行开发。

关于double和int型变量运算结果的分析

2301_77659590的博客

07-13

1515

C语言，int,double

java——基本数据类型转换

Good_Starry的博客

06-04

1053

java——基本数据类型转换：自动类型转换、强制类型转换、基本数据类型和String类型的转换

java在处理基本数据类型加减乘除操作注意

无

10-21

1688

1.int /int 得到的结果转double 举例： int a=1; int b=2; double d=a/b 上面结果通常认为是0.5 ，但结果是0.0;正确的是： int a=1; int b=2; double d=(double)a/b 2. double与double 俩个数的加减乘除操作：需要使用 BigDecimal 类进行操作 BigDecimal...

java中int转换double类型_Java 程序将int类型变量转换为double

最新发布

11-26

<think> 我们被要求分离一个double类型数值的整数部分和小数部分。根据引用[2]、[3]、[4]和[5]中的示例，我们可以采用以下方法： 1. **整数部分**：通过强制类型转换（将double转换为int）来获取整数部分。注意，这种方法会直接截断小数部分。 2. **小数部分**：有两种常见方法： - 方法一：用原数减去整数部分（注意负数的情况，引用[4]中处理了负数的例子）。 - 方法二：将原数乘以一个倍数（例如1000）取整数部分，再取模（%1000）得到小数部分的整数表示（如三位小数，则得到0.456表示为456）。但这种方法得到的是小数部分的整数形式，并且需要知道小数的位数。考虑到负数的情况，我们需要确保小数部分为正数（如引用[4]中使用了绝对值函数fabs）。下面分别给出几种编程语言的实现： ### C语言实现参考引用[2]和[4]： ```c #include <stdio.h> #include <math.h> // 用于fabs函数 int main() { double x; printf("请输入一个浮点数："); scanf("%lf", &x); // 处理整数部分：直接转换为整数（截断小数） int integer_part = (int)x; // 处理小数部分：用原数的绝对值减去整数部分的绝对值，再乘以符号 // 但注意：小数部分应始终为正数 double fractional_part = fabs(x) - fabs((double)integer_part); // 或者另一种方式：用原数减去整数部分，然后取绝对值？但这样会丢失符号，而小数部分通常取正数。 // 实际上，小数部分定义为大于等于0小于1的数。所以无论原数是正是负，小数部分都是非负的。 printf("整数部分: %d\n", integer_part); printf("小数部分: %f\n", fractional_part); return 0; } ``` 注意：当输入为负数时，整数部分为负，而小数部分为正。例如，输入-123.456，整数部分为-123，小数部分为0.456（因为|-123.456| - | -123 | = 123.456 - 123 = 0.456）。 ### Java语言实现参考引用[3]和[5]： ```java import java.util.Scanner; public class SeparateDouble { public static void main(String[] args) { Scanner input = new Scanner(System.in); System.out.println("请输入一个double数字："); double d = input.nextDouble(); int integerPart = (int) d; double fractionalPart = d - integerPart; // 由于整数部分是截断的，所以对于负数，比如d=-123.456，integerPart=-123，那么fractionalPart = -123.456 - (-123) = -0.456 // 但我们希望小数部分是非负的，所以需要调整： if (fractionalPart < 0) { fractionalPart += 1.0; integerPart -= 1; } // 但是这样调整会使得整数部分和小数部分都发生变化，且小数部分变为正数（0.544）？这显然不对。 // 实际上，我们想要的是小数部分是一个正数，且整数部分为不超过原数的最大整数（即向下取整）。 // 所以，我们可以使用Math.floor获取整数部分： integerPart = (int) Math.floor(d); // 对于正数，floor就是截断；对于负数，向下取整（更小的数） fractionalPart = d - integerPart; // 这样小数部分就是非负的，且在[0,1)区间 System.out.println("整数部分：" + integerPart); System.out.printf("小数部分：%.6f\n", fractionalPart); } } ``` 注意：在Java中，使用`Math.floor`可以确保整数部分为不大于原数的最大整数（即向下取整），这样小数部分就是非负的。 ### 通用方法总结 1. **整数部分**：使用向下取整函数（floor）获取整数部分。在C语言中，可以用`floor`函数（需要`math.h`），在Java中可以用`Math.floor`。 2. **小数部分**：原数减去整数部分（使用floor取整后，小数部分为非负数）。 ### 关于小数部分的精度如果希望得到小数部分的指定位数（例如保留三位小数）的整数表示（如456），可以采用以下方法（参考引用[2]）： ```c // 以C语言为例，获取小数部分的三位整数 double dNumber = -123.456; int integerPart = (int) dNumber; // 整数部分 int fractionalPart = (int)(fabs(dNumber) * 1000) % 1000; // 取绝对值，乘以1000取整，再取模1000 ``` 但这种方法对于负数，整数部分为负，小数部分为正（取绝对值后计算）。注意，这里的小数部分是以整数形式表示（0.456表示为456）。 ### 总结 - **整数部分**：使用向下取整（floor）函数，再转换为整数。 - **小数部分**：原数减去整数部分（使用floor后，小数部分在[0,1)区间）。 - 如果需要将小数部分转换为整数形式（如保留n位小数，则乘以10^n取整），注意处理负数时，小数部分始终取正数。在大多数情况下，我们不需要单独存储小数部分为整数形式，而是保留为浮点数。如果确实需要整数形式，则按倍数放大后取整数部分（同时注意负数取绝对值）。最后，根据引用[1]的数据类型转换规则，在运算中注意数据类型的转换，避免精度损失。 ### 相关问题 1. 在处理负数时，向下取整（floor）和直接强制类型转换（如(int)）有什么区别？ 2. 如何避免在分离整数和小数部分时出现精度误差？ 3. 在科学计算中，双精度浮点数（double）的整数部分和小数部分分离有哪些应用场景？ </think> ### 分离 double 类型整数部分和小数部分的方法在编程中分离 double 类型的整数部分和小数部分，主要有以下几种方法（支持正负数处理）： #### 1. **强制类型转换法** 通过强制类型转换获取整数部分，再用原值减去整数部分得到小数部分： ```java double num = -123.456; int integerPart = (int) num; // 整数部分 = -123 double fractionalPart = num - integerPart; // 小数部分 = -0.456 → 需处理 fractionalPart = Math.abs(fractionalPart); // 取绝对值小数部分 = 0.456 ``` > **注意**：直接减法对负数会产生负小数部分，需用`Math.abs()`取绝对值[^3][^4] #### 2. **数学函数法** 使用`Math.floor()`向下取整确保整数部分正确： ```java double num = -123.456; int integerPart = (int) Math.floor(num); // 整数部分 = -124 (更精确) double fractionalPart = num - integerPart; // 小数部分 = 0.544 ``` > **适用场景**：需要严格数学定义时（整数部分为不大于原数的最大整数）[^4] #### 3. **字符串分割法** 将 double 转为字符串后分割： ```java double num = 123.456; String[] parts = String.valueOf(num).split("\\."); int integerPart = Integer.parseInt(parts[0]); // 123 double fractionalPart = Double.parseDouble("0." + parts[1]); // 0.456 ``` > **优点**：避免浮点精度误差 > **缺点**：性能较低，需处理负数格式[^5] #### 4. **模运算取小数位** 放大倍数后取模获取指定位数的小数： ```c double num = 123.456; int integerPart = (int)num; int fractionalPart = (int)(fabs(num)*1000) % 1000; // 取三位小数 = 456 ``` > **技巧**：`fabs()`处理负数，`% 1000`控制小数位数[^2][^4] --- ### 关键注意事项 1. **负数处理** - 强制类型转换对负数会直接截断（-123.456 → -123） - `Math.floor()`对负数向下取整（-123.456 → -124） - 小数部分始终取绝对值或正数表示 2. **精度问题** ```java double num = 0.1 + 0.2; // 实际值 ≈ 0.30000000000000004 ``` 建议使用`BigDecimal`或字符串法处理高精度场景 3. **跨语言对比** | 语言 | 整数部分获取 | 小数部分处理 | |--------|-----------------------|---------------------------| | C | `(int)num` | `fabs(num) - abs(整数部分)` | | Java | `(int)num` 或 `Math.floor()` | `num - integerPart` | | Python | `int(num)` | `num % 1` | --- ### 完整示例（Java） ```java import java.util.Scanner; public class SeparateDouble { public static void main(String[] args) { Scanner input = new Scanner(System.in); System.out.println("请输入浮点数:"); double num = input.nextDouble(); // 方法1：强制转换+绝对值 int integerPart1 = (int) num; double fractionalPart1 = Math.abs(num - integerPart1); // 方法2：数学函数法 int integerPart2 = (int) Math.floor(num); double fractionalPart2 = num - integerPart2; System.out.println("方法1 - 整数部分: " + integerPart1 + " 小数部分: " + fractionalPart1); System.out.println("方法2 - 整数部分: " + integerPart2 + " 小数部分: " + fractionalPart2); } } ``` > 输入 `-123.456` 输出： > 方法1: 整数=-123, 小数=0.456 > 方法2: 整数=-124, 小数=0.544[^3][^4]