一、基本數(shù)據(jù)類型

1.1 整形

1.1.1 int

int a = Integer.MAX_VALUE;//int最大值
int b = Integer.MIN_VALUE;//int最小值

在java中int占4個字節(jié)，和操作系統(tǒng)每任何關(guān)系。這也是java的可移植性。

int 能表示的范圍為-231~231-1，如果超出最大值或者小于最小值則會發(fā)生溢出。

public static void main(String[] args) {
            int a = Integer.MAX_VALUE;//int最大值
            int b = Integer.MIN_VALUE;//int最小值
            System.out.println("MAX_VALUE="+a);
            System.out.println("MIN_VALUE="+b);
            a = a+1;
            b = b-1;
            System.out.println("---------------");
            System.out.println("MAX_VALUE+1="+a);
            System.out.println("MIN_VALUE-1="+b);
}

我們發(fā)現(xiàn)int的最大值加1會等于int的最小值，而int的最小值減1會等于int的最大值。這種情況不僅在int，在long和short都存在

1.1.2 長整形：long

long占8個字節(jié)，可表示的范圍是 -263~-263-1

long a = 100L;
long b = 100l;
long c = 100;

在創(chuàng)建長整形變量時，a,b,c三種都可以，當我們一般用第一種，大寫L更好識別它時長整形

1.1.3 短整形：short

short占2個字節(jié)，所能表示的范圍為-215~215-1
short能表示的范圍 -32768~32767 ,所表示的范圍比較小一般不推薦使用，所以我們以后 int 和 long 時使用的比較多的。

1.2 浮點型

1.2.1 雙精度浮點型：double

public static void main(String[] args) {
            int a1 = 1;
            int a2 = 2;
            double b1 = 1.0;
            double b2 = 2.0;
            System.out.println("a1/a2="+a1/a2);
            System.out.println("b1/b2="+b1/b2);
}

在java當中int除以 int 只能得到 int 類型，因為小數(shù)部分會被舍去。如果要得到小數(shù)則需要用浮點數(shù)來計算。

再來看一個有意思的代碼

public static void main(String[] args) {
            double a = 1.1;
            System.out.println(a*a);

}

這里a*a理論上說時等于1.21的但這里為什么不是呢？

1.Java 中的 double 雖然也是 8 個字節(jié), 但是浮點數(shù)的內(nèi)存布局和整數(shù)差別很大, 不能單純的用 2n 的形式表示數(shù)據(jù)范

2.Java 的 double 類型的內(nèi)存布局遵守 IEEE 754 標準(和C語言一樣), 嘗試使用有限的內(nèi)存空間表示可能無限的小數(shù), 勢
必會存在一定的精度誤差圍,而且計算機中小數(shù)是沒有精確的數(shù)字的

1.2.2 單精度浮點型：float

flaot占4個字節(jié)

public static void main(String[] args) {
            float a1 = 1.1;
            float a2 = (float)1.1;
            float b = 1.1F;
            float c = 1.1f;
}    

這里為什么報錯呢？因為Java是一個強類型語言，安全性更高。在Java當中小數(shù)默認是double類型的，在創(chuàng)建float變量的時候，需要在小數(shù)后面加上一個F(f)或者強制類型轉(zhuǎn)換。

不過float能表示的精度較小，所以我們一般都是用double

1.3 字符類型變量char

在java中char不同于C語言它是占兩個字節(jié)的，計算機中的字符本質(zhì)上是一個整數(shù). 在 C 語言中使用 ASCII 表示字符, 而 Java 中使用 Unicode 表示字符. 因此一個字符占用兩個字節(jié), 表示的字符種類更多, 包括中文.

public static void main(String[] args) {
            char a = 97;
            char b = 65;
            char c = '好';
            System.out.println(a);
            System.out.println(b);
            System.out.println(c);
}       

在Java當中字符類型就是字符類型不要和數(shù)字掛鉤，記住java中字符類型是不能夠給負數(shù)的。

1.4 字節(jié)類型變量byte

byte占1個字節(jié)，能表示的范圍為 -128~127
byte不能賦值超過它范圍外的數(shù)字，從而可以推到出其它類型也是一樣的。

來看一段代碼：

這里的 b3和b5都報錯，而b4沒有報錯呢？

1.這是因為執(zhí)行 b3 這段代碼時，b1和b2都是變量編譯器不知道里面是什么，為了安全起見所以報錯。

2.而b4不報錯時因為在編譯的時候 5+10就已經(jīng)被替換為15了，相當于 b4 = 15.

3.那b5報錯又是為什么呢？這里就牽扯到了整形提升，

簡單說一下整形提升：當變量小于4個字節(jié)的時候，比如這里的byte在計算時會把它先提升為整形int再進行計算。而byte是1個字節(jié)接收不了int類型的變量，所以報錯。后面會再提到整形提升

1.5 布爾類型變量 boolean

boolean a = false;
boolean b = true;

1.在java中布爾類型只有兩個取值 false 和 true 。

2.java中的boolean和int 類型不能相互轉(zhuǎn)換，不存在1表示true ，0表示false這種用法

3.boolean 類型有些 JVM 的實現(xiàn)是占 1 個字節(jié), 有些是占 1 個比特位。并沒有明確規(guī)定大小

1.6 字符串類型變量 String

Java的字符串可以用+進行拼接

public static void main(String[] args) {
            String str1 = "這是一個字符串";
            String str2 = "java";
            String tmp = str1 + str2;
            System.out.println(tmp);
}

同樣也可以拼接數(shù)字

public static void main(String[] args) {
            String str1 = "這是一個字符串";
            String str2 = "java";
            String tmp = str1 + str2;
            System.out.println(tmp);
            int a = 10;
            int b = 20;
            System.out.println(tmp+a+b);
            System.out.println(a+b+tmp);
}

輸出的時候如果前面是字符串則后面的數(shù)字會被當作字符進行拼接，可以根據(jù)自己的需要進行運算或者拼接

1.Java 使用 雙引號 + 若干字符 的方式表示字符串字面值.

2. 和上面的類型不同, String 不是基本類型, 而是引用類型(在以后的文章會說到).

二、常量

上面討論的都是各種規(guī)則的變量, 每種類型的變量也對應著一種相同類型的常量.

常量指的是運行時類型不能發(fā)生改變.

常量主要有以下兩種體現(xiàn)形式

2.1 字面常量

2.2 … final 關(guān)鍵字修飾的常量

final修飾的常量是不能被直接修改的

三、 類型轉(zhuǎn)換和數(shù)值轉(zhuǎn)換

3.1 類型轉(zhuǎn)換

java 作為一個強類型編程語言, 當不同類型之間的變量相互賦值的時候, 會有教嚴格的校驗.來看一下列子

long 表示的范圍更大, 可以將 int 賦值給 long, 但是不能將 long 賦值給 int.

double 表示的范圍更大, 可以將 int 賦值給 double, 但是不能將 double 賦值給 int.

結(jié)論: 不同數(shù)字類型的變量之間賦值, 表示范圍更小的類型能隱式轉(zhuǎn)換成范圍較大的類型, 反之則不行.

3.1.1 強制類型轉(zhuǎn)換

結(jié)論: 使用 (類型) 的方式可以將 double 類型強制轉(zhuǎn)成 int. 但是

1.強制類型轉(zhuǎn)換可能會導致精度丟失. 如剛才的例子中, 賦值之后, 20.5 就變成 20 了, 小數(shù)點后面的部分被忽略.

2.強制類型轉(zhuǎn)換不是一定能成功, 互不相干的類型之間無法強轉(zhuǎn)

比如這個列子 int 和 boolean這兩種完全不相關(guān)的類型是不可以強轉(zhuǎn)的。

類型轉(zhuǎn)換小結(jié)：

1. 不同數(shù)字類型的變量之間賦值, 表示范圍更小的類型能隱式轉(zhuǎn)換成范圍較大的類型.
2. 如果需要把范圍大的類型賦值給范圍小的, 需要強制類型轉(zhuǎn)換, 但是可能精度丟失.
3. 將一個字面值常量進行賦值的時候, Java 會自動針對數(shù)字范圍進行檢查.

3.2 數(shù)值提升

結(jié)論: 當 int 和 long 混合運算的時候, int 會提升成 long, 得到的結(jié)果仍然是 long 類型, 需要使用 long 類型的變量來
接收結(jié)果. 如果非要用 int 來接收結(jié)果, 就需要使用強制類型轉(zhuǎn)換.

再來看一個例子，前面在byte類型的時候就已經(jīng)說到了，這里再詳細說一下。

結(jié)論: byte 和 byte 都是相同類型, 但是出現(xiàn)編譯報錯. 原因是, 雖然 a 和 b 都是 byte, 但是計算 a + b 會先將 a 和 b 都提升成 int, 再進行計算, 得到的結(jié)果也是 int, 這時賦給 c, 就會出現(xiàn)上述錯誤。

由于計算機的 CPU 通常是按照 4 個字節(jié)為單位從內(nèi)存中讀寫數(shù)據(jù). 為了硬件上實現(xiàn)方便, 諸如 byte 和 short 這種低于4 個字節(jié)的類型, 會先提升成 int, 再參與計算。
簡單來說類型提升就是為了加快cpu運算速度

如果非要這樣計算，則需要強轉(zhuǎn)。

類型提升小結(jié):

1.不同類型的數(shù)據(jù)混合運算, 范圍小的會提升成范圍大的.

2.對于 short, byte 這種比 4 個字節(jié)小的類型, 會先提升成 4 個字節(jié)的 int , 再運算.

四、 int 和 String 之間的相互轉(zhuǎn)換

4.1 int轉(zhuǎn)String

public static void main(String[] args) {
            int a = 10;
            //方法1
            String str1 = 10+" ";
            //方法2
            String str2 = String.valueOf(a);
}

4.2 String轉(zhuǎn)int

public static void main(String[] args) {
            String str = "123456";
            int b = Integer.valueOf(str);
            int c = Integer.parseInt(str);
}

五、總結(jié)

內(nèi)置數(shù)據(jù)類型共有8種，每一個內(nèi)置類型都會對應一個包裝類，這里也不深入講解。簡單來說就是方便了數(shù)據(jù)的處理
感謝閱讀！

到此這篇關(guān)于java基礎(chǔ)詳解之數(shù)據(jù)類型知識點總結(jié)的文章就介紹到這了,更多相關(guān)java數(shù)據(jù)類型總結(jié)內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！