“核心技术：基本程序设计结构”的版本间差异

来自Wikioe
跳到导航 跳到搜索
无编辑摘要
第2行： 第2行：


== 数据类型 ==
== 数据类型 ==
{| class="wikitable"
! 类型 !! 存储需求 !! 默认值 !! 取值范围
|-
! colspan="4"| 整型
|-
| int
| 4字节
| 0
| -2 147 483 648 - 2 147 483 647
# Integer.MIN_VALUE=-2147483648
# Integer.MAX_VALUE=2147483647
|-
| short
| 2字节
| 0
| -32 768 - 32767
# Short.MIN_VALUE=-32768
# Short.MAX_VALUE=32767
|-
| long
| 8字节
| 0L
| -9 223 372 036 854 775 808 - 9 223 372 036 854 775 807
# Long.MIN_VALUE=-9223372036854775808
# Long.MAX_VALUE=9223372036854775807
|-
| byte
| 1字节
| 0
| -128 - 127
# Byte.MIN_VALUE=-128
# Byte.MAX_VALUE=127
|-
! colspan="4"| 浮点
|-
| float
| 4字节
| 0.0f
| 大约 +- 3.402 823 47E+38F（有效位数为6、7位）
# Float.MIN_VALUE=1.4E-45
# Float.MAX_VALUE=3.4028235E38
|-
| double
| 8字节
| 0.0d
| 大约 +- 1.797 693 134 862 315 70E+308（有效位数为15位）
# Double.MIN_VALUE=4.9E-324
# Double.MAX_VALUE=1.7976931348623157E308
|-
! colspan="4"| 字符
|-
| char
| 2字节
| 'u0000'
| \u0000 - \uffff
|-
! colspan="4"| 布尔
|-
| boolean
| 1位
| false
| <nowiki>true | false</nowiki>
|}
* 常量“Double.POSITIVE_INFINITY”、“Double.NEGATIVE_INFINITY”、“Double.NAN”分别表示“正无穷大”、“负无穷大”、“NaN（不是一个数字）”；
=== 取值范围 ===
* 整数用原码，负数用补码表示
以int为例，在java中占4字节，即32位：
# 其中第一位为符号位（0正，1负）
# 所以负数范围为：-2^31 = -2147483648
# 整数的范围为：2^31-1 = 2147483647 （减去全为0时的情况，0无正负）
即：-2147483648 - 2147483647 （-2^31 — 2^31-1）
=== 关于0.2 + 0.1 不等于 0.3 ===
使用自然类型计算小数的时候，会出现：“0.2+0.1=0.30000000000000004”，而“0.1+0.6=0.7”的情况：
:[[File:小数计算1.jpg|800px]]
:[[File:小数计算2.jpg|800px]]
其原因如下：<br/>
<pre>
计算机存储、计算或者展示，都需要转换2进制。
在现实世界中，数字主要有整数和小数两种，整数包括正整数、负整数以及零。
计算机中表示整数的方式有很多，如原码、反码以及补码等。
在计算机中存储的整数则分为有符号数和无符号数。
对于无符号数，采用哪种编码方式都无所谓，对于有符号数的编码方式，常用的是补码。
那么，一个十进制数字想要获得其二进制的补码，需要先通过一定的算法得到他对应的原码。
</pre>
# 十进制整数转换为二进制，可以采用“除2取余，逆序排列”，或者xxx法（列出“...128，64，32，26，8，4，2，1”，根据十进制数在对应位置1或0）；
# 十进制小数转换为二进制：则采用“乘2取整，顺序排列”的方法；
如，0.625的二进制转换如下：<br/>
[[File:0.625的二进制.jpg|600px]]
<br/>
而0.1的二进制：<br/>
[[File:0.1的二进制.jpg|600px]]
<br/>
可以得知：0.1的二进制转换中出现了无限循环的情况，也就是(0.1)10 = (0.000110011001100…)2，而不能把0.1转换为确定的二进制数<br/>
即'''计算机无法用二进制精确的表示0.1'''<br/>
<pre>
IEEE 754规定了四种表示浮点数值的方式：单精确度（32位）、双精确度（64位）、延伸单精确度（43比特以上，很少使用）与延伸双精确度（79比特以上，通常以80位实现）
</pre>
但仅是用近似值表示小数，并非真实值，如果使用float、double等类型进行小数计算，仍然会丢失数值。并没有解决问题。<br/>
所以：为了解决这样的精度问题，Java中提供了'''BigDecimal'''来进行精确运算。
* BigDecimal 并不是Java的数据类型，而是一个Java对象！


== 变量 ==
== 变量 ==

2020年10月16日 (五) 11:47的版本


数据类型

类型 存储需求 默认值 取值范围
整型
int 4字节 0 -2 147 483 648 - 2 147 483 647
  1. Integer.MIN_VALUE=-2147483648
  2. Integer.MAX_VALUE=2147483647
short 2字节 0 -32 768 - 32767
  1. Short.MIN_VALUE=-32768
  2. Short.MAX_VALUE=32767
long 8字节 0L -9 223 372 036 854 775 808 - 9 223 372 036 854 775 807
  1. Long.MIN_VALUE=-9223372036854775808
  2. Long.MAX_VALUE=9223372036854775807
byte 1字节 0 -128 - 127
  1. Byte.MIN_VALUE=-128
  2. Byte.MAX_VALUE=127
浮点
float 4字节 0.0f 大约 +- 3.402 823 47E+38F（有效位数为6、7位）
  1. Float.MIN_VALUE=1.4E-45
  2. Float.MAX_VALUE=3.4028235E38
double 8字节 0.0d 大约 +- 1.797 693 134 862 315 70E+308（有效位数为15位）
  1. Double.MIN_VALUE=4.9E-324
  2. Double.MAX_VALUE=1.7976931348623157E308
字符
char 2字节 'u0000' \u0000 - \uffff
布尔
boolean 1位 false true | false
  • 常量“Double.POSITIVE_INFINITY”、“Double.NEGATIVE_INFINITY”、“Double.NAN”分别表示“正无穷大”、“负无穷大”、“NaN（不是一个数字）”；

取值范围

  • 整数用原码，负数用补码表示

以int为例，在java中占4字节，即32位：

  1. 其中第一位为符号位（0正，1负）
  2. 所以负数范围为：-2^31 = -2147483648
  3. 整数的范围为：2^31-1 = 2147483647 （减去全为0时的情况，0无正负）

即：-2147483648 - 2147483647 （-2^31 — 2^31-1）

关于0.2 + 0.1 不等于 0.3

使用自然类型计算小数的时候，会出现：“0.2+0.1=0.30000000000000004”，而“0.1+0.6=0.7”的情况：

小数计算1.jpg
小数计算2.jpg

其原因如下：

计算机存储、计算或者展示，都需要转换2进制。

在现实世界中，数字主要有整数和小数两种，整数包括正整数、负整数以及零。
计算机中表示整数的方式有很多，如原码、反码以及补码等。

在计算机中存储的整数则分为有符号数和无符号数。
对于无符号数，采用哪种编码方式都无所谓，对于有符号数的编码方式，常用的是补码。

那么，一个十进制数字想要获得其二进制的补码，需要先通过一定的算法得到他对应的原码。
  1. 十进制整数转换为二进制，可以采用“除2取余，逆序排列”，或者xxx法（列出“...128，64，32，26，8，4，2，1”，根据十进制数在对应位置1或0）；
  2. 十进制小数转换为二进制：则采用“乘2取整，顺序排列”的方法；

如，0.625的二进制转换如下：
0.625的二进制.jpg
而0.1的二进制：
0.1的二进制.jpg
可以得知：0.1的二进制转换中出现了无限循环的情况，也就是(0.1)10 = (0.000110011001100…)2，而不能把0.1转换为确定的二进制数
即计算机无法用二进制精确的表示0.1


IEEE 754规定了四种表示浮点数值的方式：单精确度（32位）、双精确度（64位）、延伸单精确度（43比特以上，很少使用）与延伸双精确度（79比特以上，通常以80位实现）

但仅是用近似值表示小数，并非真实值，如果使用float、double等类型进行小数计算，仍然会丢失数值。并没有解决问题。
所以：为了解决这样的精度问题，Java中提供了BigDecimal来进行精确运算。

  • BigDecimal 并不是Java的数据类型，而是一个Java对象！

变量

运算符

字符串

输入输出

流程控制

大数值

数组

取自“http://wiki.eijux.com/index.php?title=核心技术：基本程序设计结构&oldid=1120”