java是什么意思英語 java是什么意思怎么讀

2026-04-30 小知識

文章插圖

java是什么意思英語 java是什么意思怎么讀

文章插圖
一、基本數據類型的包裝類
八種基本數據類型并不是對象，為了將基本類型數據和對象之間實現互相轉化，JDK 為每一個基本數據類型提供了相應的包裝類。
1.1 包裝類基本知識
Java 是面向對象的語言，但并不是“純面向對象”的，因為我們經常用到的基本數據類型就不是對象。但是我們在實際應用中經常需要將基本數據轉化成對象，以便于操作。比如：將基本數據類型存儲到 Object[ ]數組或集合中的操作等等。
為了解決這個不足，Java 在設計類時為每個基本數據類型設計了一個對應的類進行代表，這樣八個和基本數據類型對應的類統稱為包裝類(Wrapper Class) 。
包裝類均位于 java.lang 包，八種包裝類和基本數據類型的對應關系如表所示：

基本數據類型對應的包裝類基本數據類型包裝類byteBytebooleanBooleanshortShortcharCharacterintIntegerlongLongfloatFloatdoubleDouble在這八個類名中，除了 Integer 和 Character 類以外，其它六個類的類名和基本數據類型一致，只是類名的第一個字母大寫而已。
在這八個類中，除了 Character 和 Boolean 以外，其他的都是“數字型”，“數字型”都是 java.lang.Number 的子類。

Number 類是抽象類，因此它的抽象方法，所有子類都需要提供實現。Number 類提供了抽象方法：intValue()、longValue()、floatValue()、doubleValue()，意味著所有的“數字型”包裝類都可以互相轉型。
示例：

public class WrapperClassTest{public static void main(String[] args){Integer i=new Integer(10);Integer j=new Integer(50);}}

內存分析圖：

1.2 包裝類的用途
對于包裝類來說，這些類的用途主要包含兩種：
1. 作為和基本數據類型對應的類型存在，方便涉及到對象的操作，如 Object[ ]、集合等的操作。
2. 包含每種基本數據類型的相關屬性如最大值、最小值等，以及相關的操作方法（這些操作方法的作用是在基本數據類型、包裝類對象、字符串之間提供相互之間的轉化?。?。
包裝類的使用：

package cn.pxy.test;public class Test {/**測試Integer的用法，其他包裝類與Integer類似*/void testInteger(){//基本類型轉化成Integer對象Integer int1=new Integer(10);//已經廢棄，不推薦使用Integer int2=Integer.valueOf(20);//官方推薦這種寫法//Integer對象轉化神intint a=int1.intValue();//字符串轉化成Integer對象Integer int3=Integer.parseInt("334");Integer int4=new Integer("999");//Integer對象轉化成字符串String str1=int3.toString();//一些常見int類型相關的常量System.out.println("int能表示的最大整數："+Integer.MAX_VALUE);}public static void main(String[] args) {Test test=new Test();test.testInteger();}}

運行結果：

1.3 自動裝箱和拆箱
自動裝箱和拆箱就是將基本數據類型和包裝類之間進行自動的互相轉換。JDK1.5 后，Java 引入了自動裝箱(autoboxing)/拆箱(unboxing) 。
自動裝箱：
基本類型的數據處于需要對象的環境中時，會自動轉為“對象” 。以 Integer 為例：
在 JDK1.5 以前，這樣的代碼 Integer i = 5 是錯誤的，必須要通過 Integer i = new Integer(5) 這樣的語句來實現基本數據類型轉換成包裝類的過程；
而在 JDK1.5 以后，Java 提供了自動裝箱的功能，因此只需 Integer i = 5 這樣的語句就能實現基本數據類型轉換成包裝類，這是因為 JVM 為我們執行了 Integer i =Integer.valueOf(5)這樣的操作，這就是 Java 的自動裝箱。

/*示例*/Integer i=100;//自動裝箱//相當于編譯器自動作以下的語法編譯Integer i=Integer.valueOf(100);//調用的是valueOf（100），而不是new Integer（100）

自動拆箱：
每當需要一個值時，對象會自動轉成基本數據類型，沒必要再去顯式調用 intValue()、doubleValue()等轉型方法。如 Integer i = 5;int j = i; 這樣的過程就是自動拆箱。
/*示例*/Integer i=100;int j=i;//自動拆箱//相當于編譯器自動作以下的語法編譯int j=i.intValue();我們可以用一句話總結自動裝箱/拆箱：
自動裝箱過程是通過調用包裝類的 valueOf()方法實現的，而自動拆箱過程是通過調用包裝類的 xxxValue()方法實現的（xxx 代表對應的基本數據類型，如 intValue()、doubleValue()等）。
自動裝箱與拆箱的功能事實上是編譯器來幫的忙，編譯器在編譯時依據您所編寫的語法，決定是否進行裝箱或拆箱動作。
所以自動裝箱與拆箱的功能是所謂的“編譯器蜜糖(Compiler Sugar)”，雖然使用這個功能很方便，但在程序運行階段您得了解 Java 的語義。

//示例package cn.pxy.test;public class Test2 {/** * 測試自動裝箱和拆箱 */public static void main(String[] args) {Integer b=23;//自動裝箱int a=new Integer(20);//自動拆箱//下面問題需要注意Integer c=null;int d=c;//可以通過編譯，但此處會出現空指針異常，因為此處其實就是：c.intValue()}}

1.4 包裝類的緩存問題
整型、char類型所對應的包裝類，在自動裝箱時，對于-128~127之間的值會進行緩存處理，其目的是提高效率。
緩存處理的原理為：如果數據在-128~127這個區間，那么在類加載時就已經為該區間的每個數值創建了對象，并將這256個對象存放到一個名為cache的數組中。每當自動裝箱過程發生時（或者手動調用valueOf()時），就會先判斷數據是否在該區間，如果在則直接獲取數組中對應的包裝類對象的引用，如果不在該區間，則會通過new調用包裝類的構造方法來創建對象。
下面我們以Integer類為例，看一看Java為我們提供的源碼，加深對緩存技術的理解：
Integer類相關源碼：

public static Integer valueOf(int i) {if (i >= IntegerCache.low && i <= IntegerCache.high)return IntegerCache.cache[i + (-IntegerCache.low)];return new Integer(i);}

這段代碼中我們需要解釋下面幾個問題：
1. IntegerCache類為Integer類的一個靜態內部類，僅供Integer類使用。
2. 一般情況下 IntegerCache.low為-128，IntegerCache.high為127，
IntegerCache.cache為內部類的一個靜態屬性。
IntegerCache類相關源碼：

private static class IntegerCache {static final int low = -128;static final int high;static final Integer[] cache;static Integer[] archivedCache;static {// high value may be configured by propertyint h = 127;String integerCacheHighPropValue =http://www.mnbkw.com/jxjc/181683/VM.getSavedProperty("java.lang.Integer.IntegerCache.high");if (integerCacheHighPropValue != null) {try {h = Math.max(parseInt(integerCacheHighPropValue), 127);// Maximum array size is Integer.MAX_VALUEh = Math.min(h, Integer.MAX_VALUE - (-low) -1);} catch( NumberFormatException nfe) {// If the property cannot be parsed into an int, ignore it.}}high = h;// Load IntegerCache.archivedCache from archive, if possibleVM.initializeFromArchive(IntegerCache.class);int size = (high - low) + 1;// Use the archived cache if it exists and is large enoughif (archivedCache == null || size > archivedCache.length) {Integer[] c = new Integer[size];int j = low;for(int i = 0; i < c.length; i++) {c[i] = new Integer(j++);}archivedCache = c;}cache = archivedCache;// range [-128, 127] must be interned (JLS7 5.1.7)assert IntegerCache.high >= 127;}private IntegerCache() {}}

由上面的源碼我們可以看到，靜態代碼塊的目的就是初始化數組cache的，這個過程會在類加載時完成。
包裝類的緩存測試：

package cn.pxy.test;public class Test2 {public static void main(String[] args) {Integer in1=-128;Integer in2=-128;System.out.println(in1==in2);//true，因為在緩存范圍內System.out.println(in1.equals(in2));//trueInteger in3=1234;Integer in4=1234;System.out.println(in3==in4);//false,因為1234不在緩存范圍內System.out.println(in3.equals(in4));//true}}

執行結果：

內存分析如圖：

1.5 自定義一個簡單的包裝類

package cn.pxy.test;/** * 定義一個簡單的包裝類 * @author 胖咸魚 * */public class MyInteger {private int value;private static MyInteger[] cache=new MyInteger[256];public static final int LOW=-128;public static final int HIGH=127;static {//[-128,127]for(int i=MyInteger.LOW;i<=HIGH;i++) {//-128,0;-127,1;-126,2;cache[i+128]=new MyInteger(i);}}public static MyInteger valueOf(int i) {if(i>=LOW&&i<=HIGH) {return cache[i+128];}return new MyInteger(i);}public String toString() {return this.value+"";}public int intValue() {return value;}private MyInteger(int i) {this.value=http://www.mnbkw.com/jxjc/181683/i;}public static void main(String[] args) {MyInteger m=MyInteger.valueOf(30);System.out.println(m);}}

運行結果：

二、字符串相關類
String 類、StringBuilder 類、StringBuffer 類是三個字符串相關類。String 類是的對象代表不可變的字符序列，StringBuilder 類和 StringBuffer 類代表可變字符序列。關于這三個類詳細的用法，在筆試面試以及實際開發中經常用到，我們必須掌握好它們。
2.1 String類源碼分析
String 類對象代表不可變的 Unicode 字符序列，因此我們可以將 String 對象稱為“不可變對象” 。那什么叫做“不可變對象”呢？指的是對象內部的成員變量的值無法再改變。我們打開 String 類的源碼，如圖所示：

我們發現字符串內容全部存儲到 value[ ]數組中，而變量 value 是 final 類型的，也就是常量(即只能被賦值一次) 。這就是“不可變對象”的典型定義方式。
我們發現String 的某些方法，比如：substring()是對字符串的截取操作，但本質是讀取原字符串內容生成了新的字符串。測試代碼如下：

package cn.pxy.test;public class TestString1 {public static void main(String[] args) {String s1=new String("abcdef");String s2=s1.substring(2,4);//打印：ab199863System.out.println(Integer.toHexString(s1.hashCode()));//打?。篶61，顯然s1、s2不是同一個對象System.out.println(Integer.toHexString(s2.hashCode()));}}

運行結果：

在遇到字符串常量之間的拼接時，編譯器會做出優化，即在編譯期間就會完成字符串的拼接。因此，在使用==進行 String 對象之間的比較時，我們需要特別注意：

//字符串拼接時的優化package cn.pxy.test;public class TestString2 {public static void main(String[] args) {//編譯器做了優化，直接在編譯的時候將字符串進行拼接String str1="hello"+"java";//相當于str1="hello java"String str2="hellojava";System.out.println(str1==str2);//trueString str3="hello";String str4="java";//編譯的時候不知道變量中存儲的是什么，所以沒辦法在編譯的時候優化String str5=str3+str4;System.out.println(str2==str5);//false}}

運行結果：

2.2 StringBuffer和StringBuilder
StringBuffer 和 StringBuilder 非常類似，均代表可變的字符序列。這兩個類都是抽象類 AbstractStringBuilder 的子類，方法幾乎一模一樣。打開 AbstractStringBuilder的部分源碼如下：

abstract class AbstractStringBuilder implements Appendable, CharSequence {/*** The value is used for character storage.*/char value[ ];//以下代碼省略 }

顯然，內部也是一個字符數組，但這個字符數組沒有用 final 修飾，隨時可以修改。因此，StringBuilder 和 StringBuffer 稱之為“可變字符序列” 。
那兩者有什么區別：
*StringBuffer JDK1.0 版本提供的類，線程安全，做線程同步檢查，效率較低。
*StringBuilder JDK1.5 版本提供的類，線程不安全，不做線程同步檢查，因此效率較高，建議采用該類。
常用方法列表：
1.重載的 public StringBuilder append(…)方法，可以為該 StringBuilder 對象添加字符序列，仍然返回自身對象。
2.方法 public StringBuilder delete(int start,int end)，可以刪除從 start 開始到 end-1 為止的一段字符序列，仍然返回自身對象。
3.方法 public StringBuilder deleteCharAt(int index)，移除此序列指定位置上的 char，仍然返回自身對象。
4.重載的 public StringBuilder insert(…)方法，可以為該 StringBuilder 對象在指定位置插入字符序列，仍然返回自身對象。
5.方法 public StringBuilder reverse()，用于將字符序列逆序，仍然返回自身對象。
6.方法 public String toString() 返回此序列中數據的字符串表示形式。
7.和 String 類含義類似的方法：

public int indexOf(String str) public int indexOf(String str,int fromIndex) public String substring(int start) public String substring(int start,int end) public int length() char charAt(int index)

StringBuffer/StringBuilder 基本用法：

package cn.pxy.test;public class TestStringBufferAndBuilder {public static void main(String[] args) {/**StringBuilder*/StringBuilder sb=new StringBuilder();for(int i=0;i<7;i++) {sb.append((char)('a'+i));//追加單個字符}System.out.println(sb.toString());//轉換成String輸出sb.append(",I can sing my abc!");//追加字符串System.out.println(sb.toString());/**StringBuffer,下面的方法同樣適用StringBuilder*/StringBuffer sb2=new StringBuffer("胖咸魚先生說");sb2.insert(0, "愛").insert(0, "我");//插入字符串System.out.println(sb2);sb2.delete(0, 2);//刪除子字符串System.out.println(sb2);sb2.deleteCharAt(0).deleteCharAt(0);//刪除某個字符System.out.println(sb2.charAt(0));//獲取某個字符System.out.println(sb2.reverse());//字符串逆序}}

運行結果：

2.3 不可變和可變字符序列使用陷阱
String 使用的陷阱：
String 一經初始化后，就不會再改變其內容了。對 String 字符串的操作實際上是對其副本（原始拷貝）的操作，原來的字符串一點都沒有改變。比如：String s =”a”; 創建了一個字符串s = s+”b”; 實際上原來的”a”字符串對象已經丟棄了，現在又產生了另一個字符串s+”b”（也就是”ab”) 。如果多次執行這些改變串內容的操作，會導致大量副本字符串對象存留在內存中，降低效率。如果這樣的操作放到循環中，會極大影響程序的時間和空間性能，甚至會造成服務器的崩潰。
相反，StringBuilder 和 StringBuffer 類是對原字符串本身操作的，可以對字符串進行修改而不產生副本拷貝或者產生少量的副本。因此可以在循環中使用。
示例：String和StringBuilder在字符串頻繁修改時的效率測試

package cn.pxy.test;public class Test {public static void main(String[] args) {/**使用String進行字符串的拼接*/String str8="";//本質上使用StringBuilder拼接，但是每次循環都會生成一個StringBuilder對象long num1=Runtime.getRuntime().freeMemory();//獲取系統剩余的內部空間long time1=System.currentTimeMillis();//獲取系統的當前時間for(int i=0;i<5000;i++) {str8=str8+i;//相當于產生了5000個對象}long num2=Runtime.getRuntime().freeMemory();long time2=System.currentTimeMillis();System.out.println("String 占用內存："+(num1-num2));System.out.println("String 占用時間："+(time2-time1));/**使用StringBuilder進行字符串拼接*/StringBuilder sb1=new StringBuilder("");long num3=Runtime.getRuntime().freeMemory();long time3=System.currentTimeMillis();for(int i=0;i<5000;i++) {sb1.append(i);}long num4=Runtime.getRuntime().freeMemory();long time4=System.currentTimeMillis();System.out.println("StringBuilder 占用內存："+(num3-num4));System.out.println("StringBuilder 占用時間："+(time4-time3));}}

運行結果：

三、時間處理相關類
時間是一維的，我們需要一把刻度尺來表達和度量時間。在計算機世界，我們把 1970 年 1 月 1 日 00:00:00 定為基準時間，每個度量單位是毫秒(1 秒的千分之一) 。
我們用 long 類型的變量來表示時間，從基準時間往前幾億年，往后幾億年都能表示。如果想獲得現在時刻的“時刻數值”，可以使用：

long now = System.currentTimeMillis();//代表當前時刻的毫秒數

這個“時刻數值”是所有時間類的核心值，年月日都是根據這個“數值”計算出來的。我們工作學習涉及的時間相關類有如下這些：

3.1 Date時間類（java.util.Date）
在標準 Java 類庫中包含一個 Date 類。它的對象表示一個特定的瞬間，精確到毫秒。
1.Date() 分配一個 Date 對象，并初始化此對象為系統當前的日期和時間，可以精確到毫秒）。
2.Date(long date) 分配 Date 對象并初始化此對象，以表示自從標準基準時間（稱為“歷元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）以來的指定毫秒數。
3.boolean after(Date when) 測試此日期是否在指定日期之后。
4.booleanbefore(Date when) 測試此日期是否在指定日期之前。
5.boolean equals(Object obj) 比較兩個日期的相等性。
6.long getTime() 返回自 1970 年 1 月 1 日 00:00:00 GMT 以來此 Date 對象表示的毫秒數。
7.String toString() 把此 Date 對象轉換為以下形式的 String：
dow mon dd hh:mm:ss zzz yyyy 其中：dow 是一周中的某一天 (Sun、Mon、Tue、Wed、 Thu、 Fri、 Sat) 。
使用示例：

package cn.pxy.test;import java.util.Date;public class Test {public static void main(String[] args) {long nowNum=System.currentTimeMillis();//當前時刻對應的毫秒數Date d=new Date();//沒有傳參，代表當前時刻的對象System.out.println(d.getTime());//返回時間對應的毫秒數Date d2=new Date(1000L*3600*24*365*150);//距離1970年150年System.out.println(d2);}}

運行結果：

JDK1.1 之前的Date 包含了：日期操作、字符串轉化成時間對象等操作。JDK1.1 之后，日期操作一般使用Calendar 類，而字符串的轉化使用 DateFormat 類。
3.2 DateFormat類和SimpleDateFormat類
DateFormat 類的作用：
把時間對象轉化成指定格式的字符串。反之，把指定格式的字符串轉化成時間對象。DateFormat 是一個抽象類，一般使用它的的子類 SimpleDateFormat 類來實現。
示例：DateFormat類和SimpleDateFormat類的使用

package cn.pxy.test;import java.text.ParseException;import java.text.SimpleDateFormat;import java.util.Date;public class TestDateFormat {public static void main(String[] args) throws ParseException {//new出SimpleDateFormat對象SimpleDateFormat s1=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");SimpleDateFormat s2=new SimpleDateFormat("yyyy-MM-dd");//將時間對象轉換成字符串String daytime=s1.format(new Date());System.out.println(daytime);System.out.println(s2.format(new Date()));System.out.println(new SimpleDateFormat("hh:mm:ss").format(new Date()));//將符合指定格式的字符串轉化成時間對象，字符串格式需要和指定格式一致String time="2027-10-07";Date date=s2.parse(time);//字符串轉化為時間對象System.out.println("date1:"+date);time="2027-10-07 20:15:30";date=s1.parse(time);System.out.println("date2:"+date);}}

運行結果：

代碼中格式化字符的含義字母日期或時間元素表示示例GEra標志符TextADy年Year1996；96M年中的月份MonthJuly;Jul;07w年中的周數Number27W月中的周數Number2D年中的天數Number189d月中的天數Number10F月中的星期Number2E星期中的天數TestTuesday；TueaAm/pm標記TestPMH一天中的小時數（0-23）Number0k一天中的小時數（1-24）Number24Kam/pm中的小時數（0-11）Number0ham/pm中的小時數（1-12）Number12m小時中的分鐘數Number30s分鐘中的秒數Number55S毫秒數Number978z時區General time zonePacific Standard Time; PST;GMT-08:00Z時區RFC 822 time zone0800時間格式字符也可以為我們提供其他的便利。比如：獲得當前時間是今年的第幾天。代碼如下：

package cn.pxy.test;import java.text.SimpleDateFormat;import java.util.Date;public class TestDateFormat {public static void main(String[] args) {SimpleDateFormat s1=new SimpleDateFormat("D");SimpleDateFormat s2=new SimpleDateFormat("yyyy-MM-dd");System.out.println("今天是："+s2.format(new Date()));String daytime=s1.format(new Date());System.out.println("今天是一年中的第幾天："+daytime);}}

運行結果：

3.3 Calendar日歷類
Calendar 類是一個抽象類，為我們提供了關于日期計算的相關功能，比如：年、月、日、時、分、秒的展示和計算。
GregorianCalendar 是 Calendar 的一個具體子類，提供了世界上大多數國家/地區使用的標準日歷系統。
注：月份的表示，一月是 0，二月是 1，以此類推，12 月是 11 。因為大多數人習慣于使用單詞而不是使用數字來表示月份，這樣程序也許更易讀，父類 Calendar 使用常量來表示月份：JANUARY、FEBRUARY 等等。
示例：GregorianCalendar 類和 Calendar 類的使用

package cn.pxy.test;import java.util.Calendar;import java.util.Date;import java.util.GregorianCalendar;public class TestCalendar {public static void main(String[] args) {//得到相關日期元素GregorianCalendar calendar=new GregorianCalendar(2999,10,9,22,10,50);int year=calendar.get(Calendar.YEAR);//打印2999int month=calendar.get(Calendar.MONTH);//打印10int day=calendar.get(Calendar.DAY_OF_MONTH);//打印9int day2=calendar.get(Calendar.DATE);//打印9//日：Calendar.DAY_OF_MONTH與Calendar.DATE同義int date=calendar.get(Calendar.DAY_OF_WEEK);//打印7//星期幾，這里是：1-7.周日是1，周一是2. 。。。周六是7System.out.println(year);System.out.println(month);System.out.println(day);System.out.println(day2);System.out.println(date);//設置日期GregorianCalendar calendar2=new GregorianCalendar();calendar2.set(Calendar.YEAR, 2999);calendar2.set(Calendar.MONTH, Calendar.FEBRUARY);calendar2.set(Calendar.DATE, 3);calendar2.set(Calendar.HOUR_OF_DAY, 10);calendar2.set(Calendar.MINUTE, 20);calendar2.set(Calendar.SECOND, 23);printCalendar(calendar2);//計算日期GregorianCalendar calendar3=new GregorianCalendar(2999,10,9,22,10,50);calendar3.add(Calendar.MONTH, -7);//月份減7calendar3.add(Calendar.DATE, 7);//增加7天printCalendar(calendar3);//日歷對象和時間對象轉換Date d=calendar3.getTime();GregorianCalendar calendar4=new GregorianCalendar();calendar4.setTime(new Date());}static void printCalendar(Calendar calendar) {int year=calendar.get(Calendar.YEAR);int month=calendar.get(Calendar.MONTH)+1;int day=calendar.get(Calendar.DAY_OF_MONTH);int date=calendar.get(Calendar.DAY_OF_WEEK)-1;String week=""+((date==0)?"日": date );int hour=calendar.get(Calendar.HOUR);int minute=calendar.get(Calendar.MINUTE);int second=calendar.get(Calendar.SECOND);System.out.printf("%d年%d月%d日，星期%s%d:%d:%dn",year,month,day,week+"",hour,minute,second);}}

運行結果：

四、其他常用類4.1 Math類
java.lang.Math 提供了一系列靜態方法用于科學計算；其方法的參數和返回值類型一般為 double 型。如果需要更加強大的數學運算能力，計算高等數學中的相關內容，可以使用 apache commons 下面的 Math 類庫。
Math 類的常用方法：
1.abs 絕對值
2.acos,asin,atan,cos,sin,tan 三角函數
3.sqrt 平方根
4.pow(double a, double b) a 的 b 次冪
5.max(double a, double b) 取大值
6.min(double a, double b) 取小值
7.ceil(double a) 大于 a 的最小整數
8.floor(double a) 小于 a 的最大整數
9.random() 返回 0.0 到 1.0 的隨機數
10.long round(double a) double 型的數據 a 轉換為 long 型（四舍五入）
11.toDegrees(double angrad) 弧度->角度
12.toRadians(double angdeg) 角度->弧度
使用示例：

package cn.pxy.test;public class TestMath {public static void main(String[] args) {//取整相關操作System.out.println(Math.ceil(3.2));System.out.println(Math.floor(3.2));System.out.println(Math.round(3.2));System.out.println(Math.round(3.8));//絕對值、開方、a的b次冪等操作System.out.println(Math.abs(-45));System.out.println(Math.sqrt(64));System.out.println(Math.pow(5, 2));System.out.println(Math.pow(2,5));//Math類中常用的常量System.out.println(Math.PI);System.out.println(Math.E);//隨機數System.out.println(Math.random());//[0,1)}}

運行結果：

4.2 Random類
Math 類中雖然為我們提供了產生隨機數的方法 Math.random()，但是通常我們需要的隨機數范圍并不是[0, 1)之間的 double 類型的數據，這就需要對其進行一些復雜的運算。如果使用 Math.random()計算過于復雜的話，我們可以使用例外一種方式得到隨機數，即Random 類，這個類是專門用來生成隨機數的，并且 Math.random()底層調用的就是Random 的 nextDouble()方法。

package cn.pxy.test;import java.util.Random;public class TestRandom {public static void main(String[] args) {Random rand=new Random();//隨機生成【0,1）之間的double類型的數據System.out.println(rand.nextDouble());//隨機生成int類型允許范圍之內的整型數據System.out.println(rand.nextInt());//隨機生成【0,1）之間的float類型的數據System.out.println(rand.nextFloat());//隨機生成false或者trueSystem.out.println(rand.nextBoolean());//隨機生成【0,10）之間的int類型的數據System.out.println(rand.nextInt(10));//隨機生成【20,30）之間的int類型的數據System.out.println(20+rand.nextInt(10));//隨機生成【20,30）之間的int類型的數據（此方法計算比較復雜）System.out.println(20+(int)(rand.nextDouble()*10));}}

執行結果：

4.3 File類
File 類用來代表文件和目錄。
File 類的基本用法
java.io.File 類：代表文件和目錄。在開發中，讀取文件、生成文件、刪除文件、修改文件的屬性時經常會用到本類。
File 類的常見構造方法：public File(String pathname)
以 pathname 為路徑創建 File 對象，如果 pathname 是相對路徑，則默認的當前路徑在系統屬性 user.dir 中存儲，如示例：

package cn.pxy.test;import java.io.File;import java.io.IOException;public class TestFile1 {public static void main(String[] args) throws IOException {System.out.println(System.getProperty("user.dir"));//獲取項目根路徑File f=new File("a.txt");//相對路徑，默認放到user.dir目錄下面f.createNewFile();//創建文件File f2=new File("d:/b.txt");//絕對路徑f2.createNewFile();}}

創建結果：

通過 File 對象可以訪問文件的屬性：

File 類訪問屬性的方法列表方法說明public boolean exists()判斷 File 是否存在public boolean isDirectory()判斷 File 是否是目錄public boolean isFile()判斷 File 是否是文件public long lastModified()返回 File 最后修改時間public long length()返回 File 大小public String getName()返回文件名public String getPath()返回文件的目錄路徑示例：

package cn.pxy.test;import java.io.File;import java.io.IOException;import java.util.Date;public class TestFile1 {public static void main(String[] args) throws IOException {File f = new File("d:/b.txt"); f.createNewFile();System.out.println("File 是否存在："+f.exists()); System.out.println("File 是否是目錄："+f.isDirectory()); System.out.println("File 是否是文件："+f.isFile());System.out.println("File 最后修改時間："+new Date(f.lastModified())); System.out.println("File 的大?。?+f.length()); System.out.println("File 的文件名："+f.getName()); System.out.println("File 的目錄路徑："+f.getPath());}}

運行結果：

通過 File 對象創建空文件或目錄（在該對象所指的文件或目錄不存在的情況下）

File 類創建文件或目錄的方法列表方法說明createNewFile()創建新的Filedelete（）刪除File對應的文件mkdir（）創建一個目錄；中間某個目錄缺失，則創建失敗mkdirs（）創建多個目錄；中間某個目錄缺失，則創建該缺失目錄示例：

//mkdirpackage cn.pxy.test;import java.io.File;import java.io.IOException;public class TestFile1 {public static void main(String[] args) throws IOException{File f = new File("d:/c.txt"); f.createNewFile();f.delete();File f2=new File("d:/電影/華語/大陸");boolean flag=f2.mkdir();//目錄結構中有一個不存在，則不會創建整個目錄樹System.out.println(flag);//創建失敗}}

//mkdirspackage cn.pxy.test;import java.io.File;import java.io.IOException;public class TestFile1 {public static void main(String[] args) throws IOException{File f = new File("d:/c.txt"); f.createNewFile(); // 會在 d 盤下面生成 c.txt 文件 f.delete(); // 將該文件或目錄從硬盤上刪除 File f2 = new File("d:/動漫/日本/宮崎駿"); boolean flag = f2.mkdirs();//目錄結構中有一個不存在也沒關系；創建整個目錄 樹 System.out.println(flag);//創建成功}}

遞歸遍歷目錄結構和樹狀展現
在電影目錄下增加幾個子文件夾或者文件，用于測試。

package cn.pxy.test;import java.io.File;import java.io.IOException;public class TestFile1 {public static void main(String[] args) throws IOException{File f=new File("d:/電影");printFile(f,0);}/** * 打印文件信息 * @param file 文件名稱 * @param level 層次數（實際是：第幾次遞歸調用） */static void printFile(File file, int level) {//輸出層次數for(int i=0;i<level;i++) {System.out.print("-");}//輸出文件名System.out.println(file.getName());//如果file是目錄，則獲取子文件列表，并對每個子文件進行相同操作if(file.isDirectory()) {File[] files=file.listFiles();for(File temp:files) {//遞歸調用該方法printFile(temp,level+1);}}}}

運行結果：

4.4 枚舉
JDK1.5 引入了枚舉類型。枚舉類型的定義包括枚舉聲明和枚舉體。格式如下：

enum 枚舉名 {
枚舉體（常量列表）
}
例如：
enum Season {
SPRING, SUMMER, AUTUMN, WINDER
}

所有的枚舉類型隱性地繼承自 java.lang.Enum 。枚舉實質上還是類！而每個被枚舉的成員實質就是一個枚舉類型的實例，他們默認都是 public static final 修飾的 ?？梢灾苯油ㄟ^枚舉類型名使用它們。
注：當你需要定義一組常量時，可以使用枚舉類型。但盡量不要使用枚舉的高級特性，事實上高級特性都可以使用普通類來實現，沒有必要引入枚舉，增加程序的復雜性！

//枚舉的使用package cn.pxy.test;import java.util.Random;public class TestEnum {public static void main(String[] args) {// 枚舉遍歷 for (Week k : Week.values()) { System.out.println(k); }// switch 語句中使用枚舉 int a = new Random().nextInt(4); // 生成 0，1，2，3 的隨機數switch (Season.values()[a]) { case SPRING: System.out.println("春天"); break; case SUMMER: System.out.println("夏天"); break; case AUTUMN: System.out.println("秋天"); break; case WINDTER: System.out.println("冬天"); break; }}}/**季節*/ enum Season { SPRING, SUMMER, AUTUMN, WINDTER }/**星期*/ enum Week { 星期一, 星期二, 星期三, 星期四, 星期五, 星期六, 星期日 }

【java是什么意思英語 java是什么意思怎么讀】運行結果：

上一篇：行李箱輪子被頭發纏繞怎么辦

下一篇：教你如何徹底用完一支牙膏