Java 數據類型 · ZetCode 中文系列教程

# Java 數據類型原文：http://zetcode.com/lang/java/datatypes/ 在 Java 教程的這一部分中，我們將討論數據類型。計算機程序（包括電子表格，文本編輯器，計算器或聊天客戶端）可以處理數據。用于各種數據類型的工具是現代計算機語言的基本組成部分。數據類型是一組值以及對這些值的允許操作。 Java 編程語言是一種靜態類型的語言。這意味著每個變量和每個表達式都具有在編譯時已知的類型。 Java 語言也是一種強類型語言，因為類型會限制變量可以容納的值或表達式可以產生的值，限制對這些值支持的操作，并確定操作的含義。強大的靜態類型有助于在編譯時檢測錯誤。動態類型語言（例如 Ruby 或 Python）中的變量會隨著時間的推移接收不同的數據類型。在 Java 中，一旦變量聲明為某種數據類型，就無法保存其他數據類型的值。 Java 中有兩種基本數據類型：基本類型和引用類型。基本類型為： * `boolean` * `char` * `byte` * `short` * `int` * `long` * `float` * `double` Java 中每種類型都有一個特定的關鍵字。基本類型不是 Java 中的對象。原始數據類型不能存儲在僅適用于對象的 Java 集合中。可以將它們放置在數組中。引用類型為： * 類類型 * 接口類型 * 數組類型還有一個特殊的`null`類型，它代表不存在的值。在 Ruby 編程語言中，一切都是對象。甚至是基本數據類型。 ```java #!/usr/bin/ruby 4.times { puts "Ruby" } ``` 這個 Ruby 腳本會在控制臺上打印四次`"Ruby"`字符串。我們在 4 號上調用次方法。該數字是 Ruby 中的對象。 Java 有不同的方法。它具有原始數據類型和包裝器類。包裝器類將原始類型轉換為對象。包裝器類將在下一章中介紹。 ## 布爾值我們的世界建立了雙重性。有天與地，水與火，陰與陽，男人與女人，愛與恨。在 Java 中，`boolean`數據類型是具有以下兩個值之一的原始數據類型：`true`或`false`。快樂的父母正在等待孩子的出生。他們為兩種可能性都選擇了名稱。如果要成為男孩，他們選擇了羅伯特。如果要成為女孩，他們會選擇維多利亞。 `com/zetcode/BooleanType.java` ```java package com.zetcode; import java.util.Random; public class BooleanType { public static void main(String[] args) { String name = ""; Random r = new Random(); boolean male = r.nextBoolean(); if (male == true) { name = "Robert"; } if (male == false) { name = "Victoria"; } System.out.format("We will use name %s%n", name); System.out.println(9 > 8); } } ``` 該程序使用隨機數生成器來模擬我們的情況。 ```java Random r = new Random(); boolean male = r.nextBoolean(); ``` `Random`類用于產生隨機數。 `nextBoolean()`方法隨機返回一個布爾值。 ```java if (male == true) { name = "Robert"; } ``` 如果布爾變量`male`等于`true`，則將名稱變量設置為`"Robert"`。 `if`關鍵字適用于布爾值。 ```java if (male == false) { name = "Victoria"; } ``` 如果隨機生成器選擇`false`，則將名稱變量設置為`"Victoria"`。 ```java System.out.println(9 > 8); ``` 關系運算符導致布爾值。此行在控制臺上顯示為`true`。 ```java $ java BooleanType.java We will use name Robert true $ java BooleanType.java We will use name Robert true $ java BooleanType.java We will use name Victoria true ``` 多次運行該程序。 ## 整數整數是實數的子集。它們寫時沒有小數或小數部分。整數落入集合`Z = {..., -2, -1, 0, 1, 2, ......}`中整數是無限的。在計算機語言中，整數（通常）是原始數據類型。實際上，計算機只能使用整數值的子集，因為計算機的容量有限。整數用于計算離散實體。我們可以有 3、4 或 6 個人，但不能有 3.33 個人。我們可以擁有 3.33 公斤，4.564 天或 0.4532 公里。 | 類型 | 大小 | 范圍 | | --- | --- | --- | | `byte` | 8 位 | -128 至 127 | | `short` | 16 位 | -32,768 至 32,767 | | `char` | 16 位 | 0 至 65,535 | | `int` | 32 位 | -2,147,483,648 至 2,147,483,647 | | `long` | 64 位 | -9,223,372,036,854,775,808 至 9,223,372,036,854,775,807 | Table: Integer types in Java 可以根據我們的需要使用這些整數類型。然后，我們可以將`byte`類型用于存儲婦女生育的孩子數量的變量。經過驗證的年齡最大的人死于 122 歲，因此我們可能至少選擇`short`類型作為年齡變量。這將為我們節省一些內存。整數字面值可以用十進制，十六進制，八進制或二進制表示法表示。如果數字后綴為 ASCII 字母`L`或`l`，則其類型為`long`。否則為`int`類型。大寫字母`L`首選用于指定長數字，因為小寫字母`l`容易與數字 1 混淆。 ```java int a = 34; byte b = 120; short c = 32000; long d = 45000; long e = 320000L; ``` 我們有五個賦值。值 34、120、32000 和 45000 是`int`類型的整數字面值。 `byte`和`short`類型沒有整數字面值。如果這些值適合目標類型，則編譯器不會抱怨并自動執行轉換。對于小于`Integer.MAX_VALUE`的`long`數字，`L`后綴是可選的。 ```java long x = 2147483648L; long y = 2147483649L; ``` 對于大于`Integer.MAX_VALUE`的`long`數字，我們必須添加`L`后綴。當我們使用整數時，我們處理離散項。例如，我們可以使用整數來計算蘋果。 `com/zetcode/Apples.java` ```java package com.zetcode; public class Apples { public static void main(String[] args) { int baskets = 16; int applesInBasket = 24; int total = baskets * applesInBasket; System.out.format("There are total of %d apples%n", total); } } ``` 在我們的程序中，我們計算了蘋果的總量。我們使用乘法運算。 ```java int baskets = 16; int applesInBasket = 24; ``` 籃子數和每個籃子中的蘋果數是整數值。 ```java int total = baskets * applesInBasket; ``` 將這些值相乘，我們也得到一個整數。 ```java $ java Apples.java There are total of 384 apples ``` 這是程序的輸出。可以在 Java 中使用四種不同的表示法指定整數：十進制，八進制，十六進制和二進制。二進制符號是在 Java 7 中引入的。眾所周知，通常使用小數。八進制數字以`0`字符開頭，后跟八進制數字。十六進制數字以`0x`字符開頭，后跟十六進制數字。二進制數字以`0b`開頭，后跟二進制數字（零和一）。 `com/zetcode/IntegerNotations.java` ```java package com.zetcode; public class IntegerNotations { public static void main(String[] args) { int n1 = 31; int n2 = 0x31; int n3 = 031; int n4 = 0b1001; System.out.println(n1); System.out.println(n2); System.out.println(n3); System.out.println(n4); } } ``` 我們有四個整數變量。每個變量都被分配了一個具有不同整數符號的值。 ```java int n1 = 31; int n2 = 0x31; int n3 = 031; int n4 = 0b1001; ``` 第一個是十進制，第二個十六進制，第三個八進制和第四個二進制。 ```java $ java IntegerNotations.java 31 49 25 9 ``` 我們看到了程序的輸出。大數字很難閱讀。如果我們有一個像 245342395423452 這樣的數字，我們會發現很難快速閱讀它。在計算機外部，大數字之間用空格或逗號分隔。從 Java SE 1.7 開始，可以用下劃線分隔整數。下劃線不能在數字的開頭或結尾，浮點字面量中的小數點附近以及`F`或`L`后綴之前使用。 `com/zetcode/UsingUnderscores.java` ```java package com.zetcode; public class UsingUnderscores { public static void main(String[] args) { long a = 23482345629L; long b = 23_482_345_629L; System.out.println(a == b); } } ``` 此代碼示例演示了 Java 中下劃線的用法。 ```java long a = 23482345629L; long b = 23_482_345_629L; ``` 我們有兩個相同的長數字。在第二個數字中，我們將數字中的每三個數字分開。比較這兩個數字，我們得到一個布爾值`true`。 `L`后綴告訴編譯器我們有一個長整數。使用的 Java `byte`，`short`，`int`和`long`類型確實表示固定精度數字。這意味著它們可以表示有限數量的整數。長類型可以代表的最大整數是 9223372036854775807。如果要處理更大的數字，則必須使用`java.math.BigInteger`類。它用于表示不可變的任意精度整數。任意精度整數僅受可用計算機內存量的限制。 `com/zetcode/VeryLargeIntegers.java` ```java package com.zetcode; import java.math.BigInteger; public class VeryLargeIntegers { public static void main(String[] args) { System.out.println(Long.MAX_VALUE); BigInteger b = new BigInteger("92233720368547758071"); BigInteger c = new BigInteger("52498235605326345645"); BigInteger a = b.multiply(c); System.out.println(a); } } ``` 在`java.math.BigInteger`類的幫助下，我們將兩個非常大的數字相乘。 ```java System.out.println(Long.MAX_VALUE); ``` 我們打印可以用`long`類型表示的最大整數值。 ```java BigInteger b = new BigInteger("92233720368547758071"); BigInteger c = new BigInteger("52498235605326345645"); ``` 我們定義了兩個`BigInteger`對象。它們都具有`long`類型可以容納的更大的值。 ```java BigInteger a = b.multiply(c); ``` 使用`multiply()`方法，我們將兩個數字相乘。請注意，`BigInteger`數字是不可變的。該操作返回一個新值，我們將其分配給新變量。 ```java System.out.println(a); ``` 計算出的整數將打印到控制臺。 ```java $ java VeryLargeIntegers.java 9223372036854775807 4842107582663807707870321673775984450795 ``` 這是示例輸出。 ## 算術溢出算術溢出是在計算產生的結果的大小大于給定寄存器或存儲位置可以存儲或表示的結果時發生的條件。 `com/zetcode/Overflow.java` ```java package com.zetcode; public class Overflow { public static void main(String[] args) { byte a = 126; System.out.println(a); a++; System.out.println(a); a++; System.out.println(a); a++; System.out.println(a); } } ``` 在此示例中，我們嘗試分配一個超出數據類型范圍的值。這導致算術溢出。 ```java $ java Overflow.java 126 127 -128 -127 ``` 發生溢出時，變量將重置為負的上限值。 ## 浮點數字實數測量連續的數量，例如重量，高度或速度。浮點數表示計算中實數的近似值。在 Java 中，我們有兩種原始浮點類型：`float`和`double`。 `float`是單精度類型，以 32 位存儲數字。 `double`是雙精度類型，以 64 位存儲數字。這兩種類型具有固定的精度，不能完全表示所有實數。在必須使用精確數字進行處理的情況下，可以使用`BigDecimal`類。帶有`F/f`后綴的浮點數是`float`類型，`double`數字有`D/d`后綴。 `double`數字的后綴是可選的。假設一個短跑運動員跑了 1 個小時，跑了 9.87 秒。他的公里/小時速度是多少？ `com/zetcode/Sprinter.java` ```java package com.zetcode; public class Sprinter { public static void main(String[] args) { float distance; float time; float speed; distance = 0.1f; time = 9.87f / 3600; speed = distance / time; System.out.format("The average speed of a sprinter is %f km/h%n", speed); } } ``` 在此示例中，必須使用浮點值。在這種情況下，浮點數據類型的低精度不會造成問題。 ```java distance = 0.1f; ``` 100m 是 0.1km。 ```java time = 9.87f / 3600; ``` 9.87s 是`9.87 / 60 * 60 h`。 ```java speed = distance / time; ``` 為了獲得速度，我們將距離除以時間。 ```java $ java Sprinter.java The average speed of a sprinter is 36.474163 km/h ``` 這是程序的輸出。小數舍入誤差不會影響我們對短跑運動員速度的理解。 `float`和`double`類型不精確。 `com/zetcode/FloatingInPrecision.java` ```java package com.zetcode; public class FloatingInPrecision { public static void main(String[] args) { double a = 0.1 + 0.1 + 0.1; double b = 0.3; System.out.println(a); System.out.println(b); System.out.println(a == b); } } ``` 該代碼示例說明了浮點值的不精確性質。 ```java double a = 0.1 + 0.1 + 0.1; double b = 0.3; ``` 我們定義兩個`double`值。 `D/d`后綴是可選的。乍一看，它們應該相等。 ```java System.out.println(a); System.out.println(b); ``` 打印它們將顯示很小的差異。 ```java System.out.println(a == b); ``` 該行將返回`false`。 ```java $ java FloatingInPrecision.java 0.30000000000000004 0.3 false ``` 邊距誤差很小。因此，比較運算符返回布爾值`false`。當我們使用貨幣，貨幣以及通常用于業務應用時，我們需要使用精確的數字。基本浮點類型的舍入誤差是不可接受的。 `com/zetcode/CountingMoney.java` ```java package com.zetcode; public class CountingMoney { public static void main(String[] args) { float c = 1.46f; float sum = 0f; for (int i=0; i<100_000; i++) { sum += c; } System.out.println(sum); } } ``` `1.46f`代表 1 歐元和 46 美分。我們從 100000 個這樣的金額中創建一個總和。 ```java for (int i=0; i<100_000; i++) { sum += c; } ``` 在此循環中，我們從 100000 這樣的金額中創建一個總和。 ```java $ java CountingMoney.java 146002.55 ``` 計算得出的錯誤為 2 歐元和 55 美分。為了避免此裕度誤差，我們利用了`BigDecimal`類。它用于保存不可變的，任意精度的帶符號十進制數字。 `com/zetcode/CountingMoney2.java` ```java package com.zetcode; import java.math.BigDecimal; public class CountingMoney2 { public static void main(String[] args) { BigDecimal c = new BigDecimal("1.46"); BigDecimal sum = new BigDecimal("0"); for (int i=0; i<100_000; i++) { sum = sum.add(c); } System.out.println(sum); } } ``` 我們用相同的金額執行相同的操作。 ```java BigDecimal c = new BigDecimal("1.46"); BigDecimal sum = new BigDecimal("0"); ``` 我們定義兩個`BigDecimal`數字。 ```java for (int i=0; i<100_000; i++) { sum = sum.add(c); } ``` `BigDecimal`數字是不可變的，因此在每個循環中始終將一個新對象分配給`sum`變量。 ```java $ java CountingMoney2.java 146000.00 ``` 在此示例中，我們獲得了精確值。 Java 支持浮點值的科學語法。也稱為指數表示法，它是一種寫數字太大或太小而不能方便地用標準十進制表示法寫的方式。 `com/zetcode/ScientificNotation.java` ```java package com.zetcode; import java.math.BigDecimal; import java.text.DecimalFormat; public class ScientificNotation { public static void main(String[] args) { double n = 1.235E10; DecimalFormat dec = new DecimalFormat("#.00"); System.out.println(dec.format(n)); BigDecimal bd = new BigDecimal("1.212e-19"); System.out.println(bd.toEngineeringString()); System.out.println(bd.toPlainString()); } } ``` 我們使用科學計數法定義兩個浮點值。 ```java double n = 1.235E10; ``` 這是`double`類型的浮點值，以科學計數法表示。 ```java DecimalFormat dec = new DecimalFormat("#.00"); System.out.println(dec.format(n)); ``` 我們使用`DecimalFormat`類將`double`值排列為標準十進制格式。 ```java BigDecimal bd = new BigDecimal("1.212e-19"); System.out.println(bd.toEngineeringString()); System.out.println(bd.toPlainString()); ``` `BigDecimal`類采用科學計數法中的浮點值作為參數。我們使用該類的兩種方法來打印工程字符串和純字符串中的值。 ```java $ java ScientificNotation.java 12350000000.00 121.2E-21 0.0000000000000000001212 ``` This is the example output. ## 枚舉枚舉類型是一種特殊的數據類型，它使變量成為一組預定義的常量。可以將任何枚舉器分配為已聲明為具有枚舉類型的變量作為值。枚舉使代碼更具可讀性。當我們處理只能從一小部分可能的值中取出一個的變量時，枚舉很有用。 `com/zetcode/Enumerations.java` ```java package com.zetcode; public class Enumerations { enum Days { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY } public static void main(String[] args) { Days day = Days.MONDAY; if (day == Days.MONDAY) { System.out.println("It is Monday"); } System.out.println(day); for (Days d : Days.values()) { System.out.println(d); } } } ``` 在我們的代碼示例中，我們為工作日創建一個枚舉。 ```java enum Days { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY } ``` 使用`enum`關鍵字創建代表星期幾的枚舉。枚舉項是常量。按照約定，常量用大寫字母表示。 ```java Days day = Days.MONDAY; ``` 我們有一個名為`day`的變量，其類型為`Days`。它被初始化為星期一。 ```java if (day == Days.MONDAY) { System.out.println("It is Monday"); } ``` 與將日變量與某個數字進行比較相比，此代碼更具可讀性。 ```java System.out.println(day); ``` 該行將在星期一打印到控制臺。 ```java for (Days d : Days.values()) { System.out.println(d); } ``` 此循環將整天打印到控制臺。靜態`values()`方法按聲明順序返回包含此`enum`類型常量的數組。此方法可用于通過增強的`for`語句迭代常量。增強的`for`逐元素遍歷數組，并將其打印到終端。 ```java $ java Enumerations.java It is Monday MONDAY MONDAY TUESDAY WEDNESDAY THURSDAY FRIDAY SATURDAY SUNDAY ``` This is the example output. 可以給枚舉常量一些值。 `com/zetcode/Enumerations2.java` ```java package com.zetcode; enum Season { SPRING(10), SUMMER(20), AUTUMN(30), WINTER(40); private int value; private Season(int value) { this.value = value; } public int getValue() { return value; } } public class Enumerations2 { public static void main(String[] args) { for (Season season : Season.values()) { System.out.println(season + " " + season.getValue()); } } } ``` 該示例包含一個`Season`枚舉，該枚舉具有四個常量。 ```java SPRING(10), SUMMER(20), AUTUMN(30), WINTER(40); ``` 在這里，我們定義`enum`的四個常數。給常數指定特定值。 ```java private int value; private Season(int value) { this.value = value; } ``` 當定義常量時，我??們還必須創建一個構造器。構造器將在本教程的后面部分介紹。 ```java SPRING 10 SUMMER 20 AUTUMN 30 WINTER 40 ``` This is the example output. ## 字符串和字符 `String`是代表計算機程序中文本數據的數據類型。 Java 中的字符串是字符序列。 `char`是單個字符。字符串用雙引號引起來。由于字符串在每種編程語言中都非常重要，因此我們將為它們專門整整一章。在這里，我們僅舉一個小例子。 `com/zetcode/StringsChars.java` ```java package com.zetcode; public class StringsChars { public static void main(String[] args) { String word = "ZetCode"; char c = word.charAt(0); char d = word.charAt(3); System.out.println(c); System.out.println(d); } } ``` 程序將`Z`字符打印到終端。 ```java String word = "ZetCode"; ``` 在這里，我們創建一個字符串變量，并為其分配`"ZetCode"`值。 ```java char c = word.charAt(0); ``` `charAt()`方法返回指定索引處的`char`值。序列的第一個`char`值在索引 0 處，第二個在索引 1 處，依此類推。 ```java $ java StringsChars.java Z C ``` 該程序將`"ZetCode"`字符串的第一個和第四個字符打印到控制臺。 ## 數組數組是處理元素集合的復雜數據類型。每個元素都可以通過索引訪問。數組的所有元素必須具有相同的數據類型。我們將整章專門介紹數組。這里我們僅顯示一個小例子。 `com/zetcode/ArraysEx.java` ```java package com.zetcode; public class ArraysEx { public static void main(String[] args) { int[] numbers = new int[5]; numbers[0] = 3; numbers[1] = 2; numbers[2] = 1; numbers[3] = 5; numbers[4] = 6; int len = numbers.length; for (int i = 0; i < len; i++) { System.out.println(numbers[i]); } } } ``` 在此示例中，我們聲明一個數組，用數據填充它，然后將數組的內容打印到控制臺。 ```java int[] numbers = new int[5]; ``` 我們創建一個整數數組，該數組最多可以存儲 5 個整數。因此，我們有五個元素組成的數組，索引為`0..4`。 ```java numbers[0] = 3; numbers[1] = 2; numbers[2] = 1; numbers[3] = 5; numbers[4] = 6; ``` 在這里，我們為創建的數組分配值。我們可以通過數組訪問符號訪問數組的元素。它由數組名稱和方括號組成。在方括號內，我們指定所需元素的索引。 ```java int len = numbers.length; ``` 每個數組都有一個`length`屬性，該屬性返回數組中的元素數。 ```java for (int i = 0; i < len; i++) { System.out.println(numbers[i]); } ``` 我們遍歷數組并將數據打印到控制臺。 ```java $ java ArraysEx.java 3 2 1 5 6 ``` This is the output of the program. 在 Java 教程的這一部分中，我們介紹了 Java 中的數據類型。