Java 經典入門（一）

時間 2019-12-08

標籤 java 經典入門欄目 Java 简体版

原文原文鏈接

1、什麼是 Java 技術？爲什麼須要 Java？

　　Java 是由 Sun Microsystems 在 1995 年首先發布的編程語言和計算平臺。有許多應用程序和 Web 站點只有在安裝 Java 後才能正常工做，並且這樣的應用程序和 Web 站點日益增多。Java 快速、安全、可靠。從筆記本電腦到數據中心，從遊戲控制檯到科學超級計算機，從手機到互聯網，Java 無處不在！html

　　Java是一種計算機編程語言，擁有跨平臺、面向對象、泛型編程的特性，普遍應用於企業級Web應用開發和移動應用開發。java

　　任職於太陽微系統的詹姆斯·高斯林等人於1990年代初開發Java語言的雛形，最初被命名爲Oak，目標設置在家用電器等小型系統的程序語言，應用在電視機、電話、鬧鐘、烤麪包機等家用電器的控制和通訊。因爲這些智能化家電的市場需求沒有預期的高，Sun公司放棄了該項計劃。隨着1990年代互聯網的發展，Sun公司看見Oak在互聯網上應用的前景，因而改造了Oak，於1995年5月以Java的名稱正式發佈。Java伴隨着互聯網的迅猛發展而發展，逐漸成爲重要的網絡編程語言。git

　　Java編程語言的風格十分接近C++語言。繼承了C++語言面向對象技術的核心，Java捨棄了C++語言中容易引發錯誤的指針，改以引用替換，同時移除原C++與原來運算符重載，也移除多重繼承特性，改用接口替換，增長垃圾回收器功能。在Java SE 1.5版本中引入了泛型編程、類型安全的枚舉、不定長參數和自動裝/拆箱特性。太陽微系統對Java語言的解釋是：「Java編程語言是個簡單、面向對象、分佈式、解釋性、健壯、安全與系統無關、可移植、高性能、多線程和動態的語言」程序員

　　Java不一樣於通常的編譯語言或直譯語言。它首先將源代碼編譯成字節碼，而後依賴各類不一樣平臺上的虛擬機來解釋執行字節碼，從而實現了「一次編寫，處處運行」的跨平臺特性。在早期JVM中，這在必定程度上下降了Java程序的運行效率。但在J2SE1.4.2發佈後，Java的運行速度有了大幅提高。web

2、語言特性

Java之因此被開發，是要達到如下五個目的：正則表達式

應當使用面向對象程序設計方法學
應當容許同一程序在不一樣的計算機平臺執行
應當包括內建的對計算機網絡的支持
應當被設計成安全地執行遠端代碼
應當易於使用，並借鑑之前那些面嚮對象語言（如C++）的長處。

Java技術主要分紅幾個部分：Java語言、Java運行環境、類庫。通常狀況下說Java時並不區分指的是哪一個部分。算法

Java在1.5版本時，作了重大改變，太陽公司並1.5版本重命名爲Java 5.0。編程

面向對象數組

　　Java的特色之一就是面向對象，是程序設計方法的一種。「面向對象程序設計語言」的核心之一就是開發者在設計軟件的時候可使用自定義的類型和關聯操做。代碼和數據的實際集合體叫作「對象」。一個對象能夠想象成綁定了不少「行爲（代碼）」和「狀態（數據）」的物體。對於數據結構的改變須要和代碼進行通訊而後操做，反之亦然。面向對象設計讓大型軟件工程的計劃和設計變得更容易管理，能加強工程的健康度，減小失敗工程的數量。緩存

跨平臺性

　　Java語言的第二個特性就是跨平臺性，也就是說使用Java語言編寫的程序能夠在編譯後不用通過任何更改，就能在任何硬件設備條件下運行。這個特性常常被稱爲「一次編譯，處處運行」。

　　執行Java應用程序必須安裝Java Runtime Environment（JRE），JRE內部有一個Java虛擬機（Java Virtual Machine，JVM）以及一些標準的類庫（Class Library）。經過JVM才能在電腦系統執行Java應用程序（Java Application），這與.Net Framework的狀況同樣，因此電腦上沒有安裝JVM，那麼這些程序將不可以執行。

　　實現跨平臺性的方法是大多數編譯器在進行Java語言程序的編碼時候會生成一個用字節碼寫成的「半成品」，這個「半成品」會在Java虛擬機（解釋層）的幫助下運行，虛擬機會把它轉換成當前所處硬件平臺的原始代碼。以後，Java虛擬機會打開標準庫，進行數據（圖片、線程和網絡）的訪問工做。主要注意的是，儘管已經存在一個進行代碼翻譯的解釋層，有些時候Java的字節碼代碼仍是會被JIT編譯器進行二次編譯。

　　有些編譯器，好比GCJ，能夠自動生成原始代碼而不須要解釋層。可是這些編譯器所生成的代碼只能應用於特定平臺。而且GCJ目前只支持部分的Java API。

　　甲骨文公司對於Java的許但是「全兼容的」，這也致使了微軟和昇陽關於微軟的程序不支持RMI和JNI接口、而且增長特性爲己所用的法律爭端。昇陽最終贏得了官司，得到了大約兩千萬美圓的賠償，法院強制要求微軟執行昇陽公司關於Java的許可要求。做爲迴應，微軟再也不在Windows系統中捆綁Java，最新的Windows版本，Windows Vista和Internet Explorer 7.0版本也再也不提供對於Java應用程序和控件的支持。可是昇陽公司和其餘使用Java運行時系統的公司在Windows操做系統下對用戶提供無償的第三方插件和程序支持。

　　Java語言使用解釋層最初是爲了輕巧性。因此這些程序的運行效率比C語言和C++要低不少，用戶也對此很有微詞。不少最近的調查顯示Java的程序運行速度比幾年前要高出許多，有些一樣功能的程序的效率甚至超過了C++和C語言編寫的程序。

　　Java語言在最開始應用的時候是沒有解釋層的，全部須要編譯的代碼都直接轉換成機器的原始代碼。這樣作的後果就是得到了最佳的性能，可是程序臃腫異常。從JIT技術開始，Java的程序都通過一次轉換以後才變成機器碼。不少老牌的第三方虛擬機都使用一種叫作「動態編譯」的技術，也就是說虛擬機實時監測和分析程序的運行行爲，同時選擇性地對程序所須要的部分進行編譯和優化。全部這些技術都改善了代碼的運行速度，可是又不會讓程序的體積變得失常。

　　程序的輕便性事實上是軟件編寫很難達到的一個目標，Java雖然成功地實現了「一次編譯，處處運行」，可是因爲平臺和平臺之間的差別，所編寫的程序在轉換代碼的時候不免會出現微小的、不可察覺的錯誤和意外。有些程序員對此很是頭疼，他們嘲笑Java的程序不是「一次編譯，處處運行」，而是「一次編譯，處處調試」。以Java AWT爲例，早期Java AWT內提供的按鈕、文字區等均是以電腦系統所默認的樣式而顯示。這令Java程序在有些沒有提供圖案的電腦系統產生錯誤（在Microsoft Windows設有窗口管理器，在一些Linux distribution則沒有）。後來SUN公司針對Java AWT一些問題而推出Java Swing。

　　平臺無關性讓Java在服務器端軟件領域很是成功。不少服務器端軟件都使用Java或相關技術創建。

自動垃圾回收（Garbage Collection）

　　C++語言被用戶詬病的緣由之一是大多數C++編譯器不支持垃圾收集機制。一般使用C++編程的時候，程序員於程序中初始化對象時，會在主機內存堆棧上分配一塊內存與地址，當不須要此對象時，進行析構或者刪除的時候再釋放分配的內存地址。若是對象是在堆棧上分配的，而程序員又忘記進行刪除，那麼就會形成內存泄漏（Memory Leak）。久而久之，程序運行的時候可能會生成不少不清除的垃圾，浪費了沒必要要的內存空間。並且若是同一內存地址被刪除兩次的話，程序會變得不穩定，甚至崩潰。所以有經驗的C++程序員都會在刪除以後將指針重置爲NULL，而後在刪除以前先判斷指針是否爲NULL。

　　C++中也可使用「智能指針」（Smart Pointer）或者使用C++託管擴展編譯器的方法來實現自動化內存釋放，智能指針能夠在標準類庫中找到，而C++託管擴展被微軟的Visual C++ 7.0及以上版本所支持。智能指針的優勢是不需引入緩慢的垃圾收集機制，並且能夠不考慮線程安全的問題，可是缺點是若是不善使用智能指針的話，性能有可能不如垃圾收集機制，並且不斷地分配和釋放內存可能形成內存碎片，須要手動對堆進行壓縮。除此以外，因爲智能指針是一個基於模板的功能，因此沒有經驗的程序員在須要使用多態特性進行自動清理時也可能一籌莫展。

　　Java語言則不一樣，上述的狀況被自動垃圾收集功能自動處理。對象的建立和放置都是在內存堆棧上面進行的。當一個對象沒有任何引用的時候，Java的自動垃圾收集機制就發揮做用，自動刪除這個對象所佔用的空間，釋放內存以免內存泄漏。

　　注意程序員不須要修改finalize方法，自動垃圾收集也會發生做用。可是內存泄漏並非就此避免了，當程序員疏忽大意地忘記解除一個對象不該該有的引用時，內存泄漏仍然不可避免。

　　不一樣廠商、不一樣版本的JVM中的內存垃圾回收機制並不徹底同樣，一般越新版本的內存回收機制越快，IBM、BEA、SUN等等開發JVM的公司都曾宣稱過本身製造出了世界上最快的JVM，JVM性能的世界紀錄也在不斷的被打破並提升。

　　IBM有一篇有關Java內存回收機制比不激活垃圾收集機制的C++內存處理快數倍的技術文章，而著名的Java技術書籍《Java編程思想》（Thinking in Java）也有一段論述Java內存及性能達到甚至超過C++的章節。

3、環境

Java的三種技術架構:

JAVAEE：Java Platform Enterprise Edition，開發企業環境下的應用程序，主要針對web程序開發；

JAVASE：Java Platform Standard Edition，完成桌面應用程序的開發，是其它二者的基礎；

JAVAME：Java Platform Micro Edition，開發電子消費產品和嵌入式設備，如手機中的程序；

JDK下載地址：http://www.oracle.com/technetwork/cn/java/javase/downloads/jdk7-downloads-1880260.html

1，JDK：Java Development Kit，java的開發和運行環境，java的開發工具和jre。

2，JRE：Java Runtime Environment，java程序的運行環境，java運行的所需的類庫+JVM(java虛擬機)。

java運行分兩步：一個是編譯，一個是運行。

javac：負責的是編譯的部分，當執行javac時，會啓動java的編譯器程序。對指定擴展名的.java文件進行編譯。生成了jvm能夠識別的字節碼文件。也就是class文件，也就是java的運行程序。

java：負責運行的部分.會啓動jvm.加載運行時所需的類庫,並對class文件進行執行.

一個文件要被執行,必需要有一個執行的起始點,這個起始點就是main函數.

javac HelloWorld.java
java HelloWorld.class

.class文件主要分爲兩部分：

常量池:　　類名，成員變量名和方法引用
方法字節碼: 各個方法的字節碼

運行 java程序的運行過程有兩個階段：

加載即類的.class字節碼被加載到內存中，通常第一次使用的時候纔會加載(惰性加載)，這時候會爲每一個類建立一個Class對象。
初始化由可分爲靜態初始化和通常初始化，靜態初始化在類加載時完成，通常靜態初始化自會在Class對象首次加載的時候進行一次，當建立一個對象時，首先會在堆上分配足夠的存儲空間，這時候這塊存儲空間會被清零，即對象中的全部基本數據類型都會被設置成0，而後再執行字段定義處的初始化動做，最後執行構造器。

4、HelloWorld

public class HelloWorld 
{
    public static void main（String[] args） 
    {
        System.out.println（"Hello, World!"）;
    }
}

5、基本數據類型

4類8種：

1> 邏輯型 -- boolean

2> 文本型 -- char

3> 整數型 -- byte, short, int, long

4> 浮點數型 -- float, double

類型	佔用存儲空間/字節	表數範圍
boolean	1/8	true & false
char	2	存儲Unicode碼，單引號賦值
byte	1	-128 ~ 127
short	2	-215 ~ 215-1
int	4	-231 ~ 231-1
long	8	-263 ~ 263-1
float	4	-3.403E38 ~ 3.403E38
double	8	-1.798E308 ~ 1.798E308

float 與 double 的區別：

　　float表示單精度浮點數，32位二進制描述；

　　double表示雙精度浮點數，64位二進制表示；

　　double精度高，有效數字16位，float精度7位。但double消耗內存是float的兩倍，double的運算速度比float慢得多。

♥常量

實數常量默認爲 double；

整數常量默認爲 int。

0x 和 10 內存中沒區別。

　　1> 十六進制整型常量：以十六進制表示時，需以0x或0X開頭，如0xff,0X9A。

　　2> 八進制整型常量：八進制必須以0開頭，如0123，034。

　　3> 長整型：長整型必須以L做結尾，如9L,342L。

　　4> 浮點數常量：因爲小數常量的默認類型是double型，因此float類型的後面必定要加f(F)。一樣帶小數的變量默認爲double類型。如：f=1.3f;

　　5> 字符常量：字符型常量需用兩個單引號括起來（注意字符串常量是用兩個雙引號括起來）。

Java中的字符佔兩個字節。一些經常使用的轉義字符：

　　1> \r表示接受鍵盤輸入，至關於按下了回車鍵；

　　2> \n表示換行；

　　3> \t表示製表符，至關於Table鍵；

　　4> \b表示退格鍵，至關於Back Space鍵；

　　5> \'表示單引號；

　　6> \''表示雙引號；

　　7> \\表示一個斜槓\。

♥基本數據類型轉換

1> boolean 類型不能夠轉換爲其餘的數據類型。

2> 容量小的類型自動轉換爲容量大的數據類型（指表示值得範圍大小）：

byte, short, char --> int --> long --> float --> double

　　 byte, short, char 之間不會互相轉換，他們三者在計算時先會轉換爲 int 類型

3> 容量大的數據類型轉換爲容量小的數據類型時，要加上強制轉換符，可能會形成精度下降或溢出。

4> 有多種類型的數據混合運算時，系統首先自動的將全部數據類型轉換成容量最大的那一種數據類型，而後再進行計算。

c 語言之因此不能移植，是由於不一樣系統編譯後的類型長度不一致

    byte b;
    b = 1;
    int i=b;        // 1
    long l=b;       // 1
    float f=b;      // 1.0
    double d=b;     // 1.0    

// 若是低級類型爲char型，向高級類型（整型）轉換時，會轉換爲對應ASCII碼值，例:
    char c='c';
    int i=c;        // 99

//對於byte,short,char三種類型而言，他們是平級的，所以不能相互自動轉換，可使用下述的強制類型轉換。
    short i=99;
    char c=(char)i;    //c

// float 類型的兩種方式
// 在內存中的形式是不同的
    float f1=0.1f;             // 在內存中是float類型
    float f2=(float)(0.1);     // 在內存中是double類型，強制轉換爲float類型

// long類型
    long l1=123456;
    long l2=8888888888;        // 錯誤！！！
    long l3=8888888888L;       // 後面加L

// byte 類型
    byte b1=1;
    byte b2=2; 
    byte b3=129;    // 錯誤！！！超過最大值

6、運算符

1> 算數運算符

　　+、 -、 *、 /、 %、 ++、 --

2> 賦值運算符

　　=、 +=、 -=、 *=、 /=、 %=

3> 關係運算符

　　>、 <、 >=、 <=、 ==、 !=

4> 邏輯運算符

　　!、 ^、 &、 &&、 |、 ||

　　　　除了 !（邏輯非）都是用於鏈接兩個 boolean 類型表達式

　　　　&（邏輯與）: 只有兩邊都爲 true 結果是 true，不然 false;

　　　　&&（短路與）: 和 & 同樣，但若是左邊爲 false，右邊就不參與運算;

　　　　|（邏輯或）: 只有兩邊都爲 flase 結果是 false，不然是 true;

　　　　||（短路或）: 和 | 同樣，但若是左邊爲 true，右邊就不參與運算;

　　　　^（邏輯異）: 兩邊結果同樣爲 false，兩邊結果不同爲 true;

5> 位運算符

　　&、 |、 ^、 ~、 >>、 <<、 >>>

// 自加自減練習
// ++、--   在前面是先加減後賦值，在後面是先賦值在加減
        int i1 = 10;
    int i2 = 20;
    int i = i2++;
    System.out.println("i:" + i);    //20，是先賦值在自加！
    System.out.println("i2:" + i2);    //21
    i = ++i2;
    System.out.println("i:" + i);    //22
    System.out.println("i2:" + i2);    //22
    i = --i1;
    System.out.println("i:" + i);    //9
    System.out.println("i1:" + i1);    //9
    i = i1--;
    System.out.println("i:" + i);    //9
    System.out.println("i1:" + i1);    //8

自加自減練習

    // 邏輯運算符練習
    boolean a, b, c;
    a = true; b=false;
    c = !a;        System.out.println(c);    //false
    c = a ^ b;     System.out.println(c);    //true
    c = a & b;     System.out.println(c);    //false
    c = a && b; System.out.println(c);    //false
    c = a | b;     System.out.println(c);    //true
    c = a || b; System.out.println(c);    //true

邏輯運算符練習

7、基本語句

1> for 循環

　　　　for(初始化表達式;判斷表達式;遞增（遞減）表達式){
　　　　執行語句;
　　　　}

- 　　初始化表達式：初始化表達式的意義，在於定義循環以前變量的值是多少。
- 　　判斷表達式：判斷表達式的做用在於規定循環的終點。
- 　　遞增（遞減）表達式：這一項規定每執行一次程序，變量以多少增量或減量進行變化。

2> foreach 循環或者、增強型循環

for(類型變量 : 數組){
　　　　執行語句;
　　　　}

JDK 1.5 引進了一種新的循環類型，被稱爲 foreach 循環或者增強型循環，它能在不使用下標的狀況下遍歷數組。

3> while 循環

　　　　while (條件){
　　　　操做;
　　　　}

4> do while 循環語句

　　　　do/while 語句與 while 語句不一樣的是，在判斷條件以前，先執行大括號內的循環體。

5> switch 語句

　　　　switch (key) {
　　　　case value:

　　　　　　...
　　　　　　break;

　　　　default:

　　　　　　...
　　　　　　break;
　　　　}

- 　　使用 break 語句，避免 case 穿透；
- 　　多個 case key 合併到一塊兒；
- 　　default 能夠省略，也以寫在任意位置，若是將default語句放在了第一行，則無論value是否匹配，程序會從default開始執行直到第一個break出現；
- 　　java 中的 switch 支持的類型能夠爲 byte,char,short,int 中的一種，JDK版本爲1.7及以上支持String。

6> break & continue

　　　　跳出整個循環與跳出本次循環。

7> 三元運算

　　　　布爾表達式?值一:值二

　　　　布爾表達式爲true結果爲值一，表達式爲false結果爲值二

　　　　java三元表達式有字符強轉的功能,會把後面的強轉爲和前面的類型同樣

　　　　若是前面是int型會把後面字符變成對應的ascii碼。
　　　　若是前面是char型會把後面數字轉換成對應的字

public class OneHundredAnd{
    public static void main(String[] args){
        int result=0;
        for(int i=1;i<=100;i++){
            result+=i;
        }
        System.out.println(result);
    }
}

for 循環, 計算1+2+3+4......+100的結果

public class TestArray {
   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};
 
      // 打印全部數組元素
      for (double element: myList) {
         System.out.println(element);
      }
   }
}

foreach 循環

public class OneHundredAnd{
    public static void main(String[] args){
        int a=1,result=0;
        while(a<=100){
            result+=a++;
        }
        System.out.println(result);
    }
}

while 循環, 計算1+2+3+4......+100的結果

public class OneHundredAnd{
    public static void main(String[] args){
        int a=1,result=0;
        do{
            result+=a++;
        }while(a<=100);
        System.out.println(result);
    }
}

do while 循環, 計算1+2+3+4......+100的結果

public class PrimeNumbers{
    public static void main(String[] args){
        // 輸出100~200內的質數
        // 只有1和它自己這兩個因數的天然數叫作質數.還能夠說成質數只有1和它自己兩個約數.
        // 素數是這樣的整數,它除了能表示爲它本身和1的乘積之外,不能表示爲任 何其它兩個整數的乘積.
        // 例如: 12 ＝6×2＝4×3,因此12不是素數.
        
        for (int i=101; i<200; i+=2){
            for (int n=2; n<i; n++){
                if (i % n != 0){
                    System.out.println(i);
                    break;
                }
            }
        }
    }
}

輸出100~200內的質數

public class DataConversion {
    public static void main(String[] args){
        switch (18) {
        case 18:
            System.out.print("I'm eighteen years old, fighting.");
            break;
        case 19:
        case 20:
        case 21:
        case 22:
            System.out.print("I'm twenty years old, fighting.");
            break;
        default:
            System.out.print("Grow up to go away ^.^.");
            break;
        }
    }
}

case 語句 practice

public class SimpleUnary{
 public static void main(String[] args) {
 　　char a = 'a';
 　　int b = 8;

　　 System.out.println(false?a:b); //打印b，b是8，因此打印出8
 　　System.out.println(false?a:8); //打印8，但a是char型的，因此打印8的char字 //符，也就是backspace
 　　System.out.println(false?8:a); //打印int型，也就是a
 　　System.out.println(false?b:'a'); //打印a的ASCII碼
    
 }
}

三元運算 practice

8、Number 類

全部的包裝類（Integer、Long、Byte、Double、Float、Short）都是抽象類 Number 的子類。

序號	方法與描述
1	xxxValue() 將number對象轉換爲xxx數據類型的值並返回。
2	compareTo() 將number對象與參數比較。
3	equals() 判斷number對象是否與參數相等。
4	valueOf() 返回一個 Number 對象指定的內置數據類型
5	toString() 以字符串形式返回值。
6	parseInt() 將字符串解析爲int類型。
7	abs() 返回參數的絕對值。
8	ceil() 對整形變量向左取整，返回類型爲double型。
9	floor() 對整型變量向右取整。返回類型爲double類型。
10	rint() 返回與參數最接近的整數。返回類型爲double。
11	round() 返回一個最接近的int、long型值。
12	min() 返回兩個參數中的最小值。
13	max() 返回兩個參數中的最大值。
14	exp() 返回天然數底數e的參數次方。
15	log() 返回參數的天然數底數的對數值。
16	pow() 返回第一個參數的第二個參數次方。
17	sqrt() 求參數的算術平方根。
18	sin() 求指定double類型參數的正弦值。
19	cos() 求指定double類型參數的餘弦值。
20	tan() 求指定double類型參數的正切值。
21	asin() 求指定double類型參數的反正弦值。
22	acos() 求指定double類型參數的反餘弦值。
23	atan() 求指定double類型參數的反正切值。
24	atan2() 將笛卡爾座標轉換爲極座標，並返回極座標的角度值。
25	toDegrees() 將參數轉化爲角度。
26	toRadians() 將角度轉換爲弧度。
27	random() 返回一個隨機數。

public class Numbers {
    public static String getType(Object o){
        return o.getClass().toString();
    }
    public static void main(String[] args){
//        // xxxValue() 將number對象轉換爲xxx數據類型的值並返回。
//        Integer i1=1;
//        float f1 = i1.floatValue();
//        System.out.println(f1 + " " + getType(f1));    //1.0 class java.lang.Float
//        int f2 = i1.intValue();
//        System.out.println(f2 + " " + getType(f2));    //1 class java.lang.Integer
//        byte f3 = i1.byteValue();
//        System.out.println(f3 + " " + getType(f3));    //1 class java.lang.Byte
////        i1.compareTo(1);
        
//        // 比較這個Number對象的參數. 同樣返回0，不然-1.
//        Integer i1=1;
//        int i2 = i1.compareTo(1);
//        System.out.println(i2);
        
//        // 肯定這個數字對象是否等於參數.同樣返回true，不然false.
//        Integer i1=1;
//        byte i2=1;
//        boolean i3 = i1.equals(i2);
//        System.out.println(i3);    //false
        
//        //返回一個 Number 對象指定的內置數據類型
//        //nteger.valueOf()方法基於減小對象建立次數和節省內存的考慮，
//        //緩存了[-128,127]之間的數字。此數字範圍內傳參則直接返回緩存中的對象。
//        Integer i1=1;
//        Integer i2 = Integer.valueOf(i1);
//        System.out.println(i2);    //1
        
//        //以字符串形式返回值。
//        Integer i1=1;
//        String i2 = i1.toString();
//        System.out.println(i2);    //1
        
//        //將字符串解析爲int類型。
//        String i1="9";
//        Integer i2 = Integer.parseInt(i1);
//        System.out.println(i2);    //9
        
//        //返回參數的絕對值。
//        Integer i1=-1;
//        Integer i2 = Math.abs(i1);
//        System.out.println(i2);    //1
        
//        //對整形變量向左取整，返回類型爲double型。
//        int i1=1;
//        double i2 = Math.ceil(i1);
//        System.out.println(i2);    //1.0
        
//        //對整型變量向右取整。返回類型爲double類型。
//        int i1=1;
//        double i2 = Math.floor(i1);
//        System.out.println(i2);    //1.0
        
//        //返回與參數最接近的整數。返回類型爲double。
//        double i1=1.623;
//        double i2 = Math.rint(i1);
//        System.out.println(i2);    //2.0
        
//        //返回一個最接近的int、long型值。
//        double i1=1.623;
//        long i2 = Math.round(i1);
//        System.out.println(i2);    //2
        
//        //返回兩個參數中的最小值。
//        double i1=1.6;
//        double i2=1.8;
//        double i3 = Math.min(i1, i2);
//        System.out.println(i3);    //1.6
        
//        //返回兩個參數中的最大值。
//        int i1=9;
//        int i2=5;
//        int i3 = Math.max(i1, i2);
//        System.out.println(i3);    //9
        
//        //返回兩個參數中的最大值。
//        int i1=9;
//        int i2=5;
//        int i3 = Math.max(i1, i2);
//        System.out.println(i3);    //9
        
//        //返回天然數底數e的參數次方。
//        double i1=9;
//        double i2 = Math.exp(i1);
//        System.out.println(i2);    //8103.083927575384
        
//        //返回參數的天然數底數的對數值。
//        double i1=9;
//        double i2 = Math.log(i1);
//        System.out.println(i2); //2.1972245773362196
        
//        //返回第一個參數的第二個參數次方。2的3次方.
//        double i1=2;
//        double i2=3;
//        double i3 = Math.pow(i1, i2);
//        System.out.println(i3);    //8.0
        
//        //求參數的算術平方根。
//        double i1=9;
//        double i2 = Math.sqrt(i1);
//        System.out.println(i2);    //3.0
        
//        //求指定double類型參數的正弦值。
//        double i1=3;
//        double i2 = Math.sin(i1);
//        System.out.println(i2);    //3.0
        
//        //求指定double類型參數的餘弦值。
//        double i1=3;
//        double i2 = Math.cos(i1);
//        System.out.println(i2);    //-0.9899924966004454
        
//        //求指定double類型參數的正切值。
//        double i1=3;
//        double i2 = Math.tan(i1);
//        System.out.println(i2);    //-0.1425465430742778
                
//        //求指定double類型參數的反正弦值。NaN
//        double i1=1;
//        double i2 = Math.asin(i1);
//        System.out.println(i2);    //1.5707963267948966
        
//        //求指定double類型參數的反餘弦值。NaN
//        double i1=2;
//        double i2 = Math.acos(i1);
//        System.out.println(i2);    //0.0
        
//        //求指定double類型參數的反正切值。
//        double i1=3;
//        double i2 = Math.atan(i1);
//        System.out.println(i2);    //1.2490457723982544

//        //將笛卡爾座標轉換爲極座標，並返回極座標的角度值。
//        double i1=3;
//        double i2=3;
//        double i3 = Math.atan2(i1, i2);
//        System.out.println(i3); //0.7853981633974483
        
//        //將參數轉化爲角度。
//        double i1=3;
//        double i2 = Math.toDegrees(i1);
//        System.out.println(i2);    //171.88733853924697
        
//        //將角度轉換爲弧度。
//        double i1=3;
//        double i2 = Math.toRadians(i1);
//        System.out.println(i2);    //0.05235987755982988
        
//        //返回一個隨機數。
//        double i1 = Math.random();
//        System.out.println(i1);    //0.9591935059236623
        
    }
}

Number practice

9、Character 類

Character 類用於對單個字符進行操做。

Character 類在對象中包裝一個基本類型 char 的值

序號	方法與描述
1	isLetter() 是不是一個字母
2	isDigit() 是不是一個數字字符
3	isWhitespace() 是不是一個空格
4	isUpperCase() 是不是大寫字母
5	isLowerCase() 是不是小寫字母
6	toUpperCase() 指定字母的大寫形式
7	toLowerCase() 指定字母的小寫形式
8	toString() 返回字符的字符串形式，字符串的長度僅爲1

public class Characters {
    public static void main(String[] args){
        char c1 = 'm';
        
//        //是不是一個字母
//        boolean b1 = Character.isLetter(c1);
//        System.out.println(b1);    //true
        
//        //是不是一個數字字符
//        boolean b1 = Character.isDigit(c1);
//        System.out.println(b1);    //false
        
//        //是不是一個空格
//        boolean b1 = Character.isWhitespace(c1);
//        System.out.println(b1);    //false
        
//        //是不是大寫字母
//        boolean b1 = Character.isUpperCase(c1);
//        System.out.println(b1);    //false
        
//        //是不是小寫字母
//        boolean b1 = Character.isLowerCase(c1);
//        System.out.println(b1);    //true
        
//        //指定字母的大寫形式,變大寫
//        char b1 = Character.toUpperCase(c1);
//        System.out.println(b1);    //M
        
//        //指定字母的小寫形式,變小寫
//        char b1 = Character.toLowerCase(c1);
//        System.out.println(b1);    //m
        
//        //返回字符的字符串形式，字符串的長度僅爲1
//        String b1 = Character.toString(c1);
//        System.out.println(b1);    //m
    }    
}

Character practice

10、String 類

使用關鍵字和構造方法來建立 String 對象。

String 類是不可改變的，因此你一旦建立了 String 對象，那它的值就沒法改變了（若是須要對字符串作不少修改，那麼應該選擇使用 StringBuffer & StringBuilder 類）

String 類有 11 種構造方法，這些方法提供不一樣的參數來初始化字符串，好比提供一個字符數組參數:

public class StringDemo{
   public static void main(String args[]){
      char[] hello = { 's', 'u', 'o', 'n', 'i', 'n', 'g'};
      String hellos = new String(hello);  
      System.out.println( hellos );
   }
}

String() 
          初始化一個新建立的 String 對象，它表示一個空字符序列。 
String(byte[] bytes) 
          構造一個新的 String，方法是使用平臺的默認字符集解碼字節的指定數組。 
String(byte[] ascii, int hibyte) 
          已過期。 該方法沒法將字節正確轉換爲字符。從 JDK 1.1 起，完成該轉換的首選方法是經過 String 構造方法，該方法接受一個字符集名稱或使用平臺的默認字符集。 
String(byte[] bytes, int offset, int length) 
          構造一個新的 String，方法是使用指定的字符集解碼字節的指定子數組。 
String(byte[] ascii, int hibyte, int offset, int count) 
          已過期。 該方法沒法將字節正確轉換爲字符。從 JDK 1.1 開始，完成該轉換的首選方法是經過 String 構造方法，它接受一個字符集名稱，或者使用平臺默認的字符集。 
String(byte[] bytes, int offset, int length, String charsetName) 
          構造一個新的 String，方法是使用指定的字符集解碼字節的指定子數組。 
String(byte[] bytes, String charsetName) 
          構造一個新的 String，方法是使用指定的字符集解碼指定的字節數組。 
String(char[] value) 
          分配一個新的 String，它表示當前字符數組參數中包含的字符序列。 
String(char[] value, int offset, int count) 
          分配一個新的 String，它包含來自該字符數組參數的一個子數組的字符。 
String(int[] codePoints, int offset, int count) 
          分配一個新的 String，它包含該 Unicode 代碼點數組參數的一個子數組的字符。 
String(String original) 
          初始化一個新建立的 String 對象，表示一個與該參數相同的字符序列；換句話說，新建立的字符串是該參數字符串的一個副本。 
String(StringBuffer buffer) 
          分配一個新的字符串，它包含當前包含在字符串緩衝區參數中的字符序列。

String 類 11 種構造方法

序號	方法描述
1	char charAt(int index) 返回指定索引處的 char 值。
2	int compareTo(Object o) 把這個字符串和另外一個對象比較。
3	int compareTo(String anotherString) 按字典順序比較兩個字符串。
4	int compareToIgnoreCase(String str) 按字典順序比較兩個字符串，不考慮大小寫。
5	String concat(String str) 將指定字符串鏈接到此字符串的結尾。
6	boolean contentEquals(StringBuffer sb) 當且僅當字符串與指定的StringButter有相同順序的字符時候返回真。
7	static String copyValueOf(char[] data) 返回指定數組中表示該字符序列的 String。
8	static String copyValueOf(char[] data, int offset, int count) 返回指定數組中表示該字符序列的 String。
9	boolean endsWith(String suffix) 測試此字符串是否以指定的後綴結束。
10	boolean equals(Object anObject) 將此字符串與指定的對象比較。
11	boolean equalsIgnoreCase(String anotherString) 將此 String 與另外一個 String 比較，不考慮大小寫。
12	byte[] getBytes() 使用平臺的默認字符集將此 String 編碼爲 byte 序列，並將結果存儲到一個新的 byte 數組中。
13	byte[] getBytes(String charsetName) 使用指定的字符集將此 String 編碼爲 byte 序列，並將結果存儲到一個新的 byte 數組中。
14	void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 將字符今後字符串複製到目標字符數組。
15	int hashCode() 返回此字符串的哈希碼。
16	int indexOf(int ch) 返回指定字符在此字符串中第一次出現處的索引。
17	int indexOf(int ch, int fromIndex) 返回在此字符串中第一次出現指定字符處的索引，從指定的索引開始搜索。
18	int indexOf(String str) 返回指定子字符串在此字符串中第一次出現處的索引。
19	int indexOf(String str, int fromIndex) 返回指定子字符串在此字符串中第一次出現處的索引，從指定的索引開始。
20	String intern() 返回字符串對象的規範化表示形式。
21	int lastIndexOf(int ch) 返回指定字符在此字符串中最後一次出現處的索引。
22	int lastIndexOf(int ch, int fromIndex) 返回指定字符在此字符串中最後一次出現處的索引，從指定的索引處開始進行反向搜索。
23	int lastIndexOf(String str) 返回指定子字符串在此字符串中最右邊出現處的索引。
24	int lastIndexOf(String str, int fromIndex) 返回指定子字符串在此字符串中最後一次出現處的索引，從指定的索引開始反向搜索。
25	int length() 返回此字符串的長度。
26	boolean matches(String regex) 告知此字符串是否匹配給定的正則表達式。
27	boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len) 測試兩個字符串區域是否相等。
28	boolean regionMatches(int toffset, String other, int ooffset, int len) 測試兩個字符串區域是否相等。
29	String replace(char oldChar, char newChar) 返回一個新的字符串，它是經過用 newChar 替換此字符串中出現的全部 oldChar 獲得的。
30	String replaceAll(String regex, String replacement 使用給定的 replacement 替換此字符串全部匹配給定的正則表達式的子字符串。
31	String replaceFirst(String regex, String replacement) 使用給定的 replacement 替換此字符串匹配給定的正則表達式的第一個子字符串。
32	String[] split(String regex) 根據給定正則表達式的匹配拆分此字符串。
33	String[] split(String regex, int limit) 根據匹配給定的正則表達式來拆分此字符串。
34	boolean startsWith(String prefix) 測試此字符串是否以指定的前綴開始。
35	boolean startsWith(String prefix, int toffset) 測試此字符串從指定索引開始的子字符串是否以指定前綴開始。
36	CharSequence subSequence(int beginIndex, int endIndex) 返回一個新的字符序列，它是此序列的一個子序列。
37	String substring(int beginIndex) 返回一個新的字符串，它是此字符串的一個子字符串。
38	String substring(int beginIndex, int endIndex) 返回一個新字符串，它是此字符串的一個子字符串。
39	char[] toCharArray() 將此字符串轉換爲一個新的字符數組。
40	String toLowerCase() 使用默認語言環境的規則將此 String 中的全部字符都轉換爲小寫。
41	String toLowerCase(Locale locale) 使用給定 Locale 的規則將此 String 中的全部字符都轉換爲小寫。
42	String toString() 返回此對象自己（它已是一個字符串！）。
43	String toUpperCase() 使用默認語言環境的規則將此 String 中的全部字符都轉換爲大寫。
44	String toUpperCase(Locale locale) 使用給定 Locale 的規則將此 String 中的全部字符都轉換爲大寫。
45	String trim() 返回字符串的副本，忽略前導空白和尾部空白。
46	static String valueOf(primitive data type x) 返回給定data type類型x參數的字符串表示形式。

import java.nio.charset.Charset;

import javax.print.DocFlavor.BYTE_ARRAY;


public class Strings {
    public static void main(String[] args){
        String s1 = "suoning";
        String s2 = "nick";
        
//        //返回指定索引處的 char 值。
//        char c1 = s1.charAt(3);
//        System.out.println(c1);    //n
        
//        //把這個字符串和另外一個對象比較.等於返回0,此字符串小於字符串參數返回小於0,大於返回大於0.
//        int c1 = s1.compareTo(s2);
//        System.out.println(c1);    //5
        
//        //將指定字符串鏈接到此字符串的結尾。
//        String c1 = s1.concat(s2);
//        System.out.println(c1);    //suoningnick
        
//        //當且僅當字符串與指定的StringButter有相同順序的字符時候返回真。
//        StringBuffer s3 = new StringBuffer("suoning");
//        boolean c1 = s1.contentEquals(s3);
//        System.out.println(c1);    //true
        
//        //返回指定數組中表示該字符序列的 String。
//        char[] s3 = {'s', 'u', 'o', ' ', 'n', 'i', 'n', 'g'};
//        String c1 = s1.copyValueOf(s3);
//        System.out.println(c1);    //suo ning
//        String c2 = s1.copyValueOf(s3, 1, 6);
//        System.out.println(c2);    //uo nin
        
//        //測試此字符串是否以指定的後綴結束。
//        boolean c1 = s1.endsWith(s2);
//        System.out.println(c1);    //false
        
//        //將此字符串與指定的對象比較。
//        boolean c1 = s1.equals(s2);
//        System.out.println(c1);    //false
        
//        //將此 String 與另外一個 String 比較，不考慮大小寫。
//        boolean c1 = s1.equalsIgnoreCase(s2);
//        System.out.println(c1);    //false
        
//        //使用平臺的默認字符集將此 String 編碼爲 byte 序列，並將結果存儲到一個新的 byte 數組中。
//        byte[] c1 = s1.getBytes();
//        System.out.println(c1);    //[B@11e78461
        
//        //將字符今後字符串複製到目標字符數組。
//        //srcBegin -- 字符串中要複製的第一個字符的索引。 rcEnd -- 字符串中要複製的最後一個字符以後的索引。
//        //dst -- 目標數組。 dstBegin -- 目標數組中的起始偏移量。
//        //沒有返回值，但會拋出 IndexOutOfBoundsException 異常。
//        //char[] s3 = new char[5];
//        s1.getChars(1,6,s3,0);
//        System.out.println(s3);    //uonin
        
//        //返回此字符串的哈希碼。
//        int s3 = s1.hashCode();
//        System.out.println(s3);    //-1855756159
        
//        //返回指定字符在此字符串中第一次出現處的索引。
//        int s3 = s1.indexOf('s');
//        System.out.println(s3);    //0
//        //返回在此字符串中第一次出現指定字符處的索引，從指定的索引開始搜索。
//        int s3 = s1.indexOf('n', 3);
//        System.out.println(s3);    //3
        
//        // 返回字符串對象的規範化表示形式。
//        String s3 = s1.intern();
//        System.out.println(s3);    //suoning
        
//        // 返回指定字符在此字符串中最後一次出現處的索引。
//        int s3 = s1.lastIndexOf('n');
//        System.out.println(s3);    //5
//        // 返回指定字符在此字符串中最後一次出現處的索引，從指定的索引處開始進行反向搜索。
//        int s3 = s1.lastIndexOf('n', 3);
//        System.out.println(s3);    //3
//        // 返回指定子字符串在此字符串中最右邊出現處的索引。
//        String s4 = new String("ning");
//        int s3 = s1.lastIndexOf(s4);
//        System.out.println(s3);    //3
//        //返回指定子字符串在此字符串中最後一次出現處的索引，從指定的索引開始反向搜索。
//        String s4 = new String("ning");
//        int s3 = s1.lastIndexOf(s4, 2);
//        System.out.println(s3);    //-1
        
//        //返回此字符串的長度。
//        int s3 = s1.length();
//        System.out.println(s3);    //7
        
//        //告知此字符串是否匹配給定的正則表達式。
//        boolean s3 = s1.matches("suo(.*)");
//        System.out.println(s3);    //true

        //測試兩個字符串區域是否相等。
        //ignoreCase -- 若是爲 true，則比較字符時忽略大小寫。
        //toffset -- 此字符串中子區域的起始偏移量。
        //other -- 字符串參數。
        //toffset -- 字符串參數中子區域的起始偏移量。
        //len -- 要比較的字符數。
//        boolean s3 = s1.regionMatches(3, s2, 6, 4);
//        System.out.println(s3);    //false
//        boolean s3 = s1.regionMatches(true, 3, s2, 6, 4);
//        System.out.println(s3);    //false
        
//        //返回一個新的字符串，它是經過用 newChar 替換此字符串中出現的全部 oldChar 獲得的。
//        String s3 = s1.replace(' ', 'm');
//        System.out.println(s3);    //suoning
        
//        //返回一個新的字符串，它是經過用 newChar 替換此字符串中出現的全部 oldChar 獲得的。
//        String s3 = s1.replace(' ', 'm');
//        System.out.println(s3);    //suoning
        
//        // 使用給定的 replacement 替換此字符串全部匹配給定的正則表達式的子字符串。
//        String s3 = s1.replaceAll(".*", "m");
//        System.out.println(s3);    //mm
        
//        //使用給定的 replacement 替換此字符串匹配給定的正則表達式的第一個子字符串。
//        String s3 = s1.replaceFirst("n", "m");
//        System.out.println(s3);    //suoming
        
//        //根據給定正則表達式的匹配拆分此字符串。
//        String s5 = new String("suo ning");
//        String[] s3 = s5.split(" ", 0);
//        for (String retval: s3){
//            System.out.println(retval); //suo、ning
//        }
        
//        // 測試此字符串是否以指定的前綴開始。
//        boolean b1 = s1.startsWith(s2);
//        System.out.println(b1);    //false
//        //測試此字符串從指定索引開始的子字符串是否以指定前綴開始。
//        boolean b1 = s1.startsWith(s2, 3);
//        System.out.println(b1);    //false
        
//        //返回一個新的字符序列，它是此序列的一個子序列。
//        String s3 = s1.substring(2, 6);
//        System.out.println(s3);    //onin

//        //返回一個新的字符序列，它是此序列的一個子序列。
//        CharSequence s3 = s1.subSequence(2, 6);
//        System.out.println(s3);    //onin
        
//        //返回一個新的字符序列，它是此序列的一個子字符串。
//        String s3 = s1.substring(2, 6);
//        System.out.println(s3);    //onin
//        String s3 = s1.substring(2);
//        System.out.println(s3);    //oning
        
//        //將此字符串轉換爲一個新的字符數組。
//        System.out.println(s1.toCharArray());    //suoning
        
//        //使用默認語言環境的規則將此 String 中的全部字符都轉換爲小寫。
//        String s3 = s1.toLowerCase();
//        System.out.println(s3);    //suoning
        
//        // 返回此對象自己（它已是一個字符串！
//        String s3 = s1.toString();
//        System.out.println(s3);    //suoning
        
//        // 使用默認語言環境的規則將此 String 中的全部字符都轉換爲大寫。
//        String s3 = s1.toUpperCase();
//        System.out.println(s3);    //SUONING
        
//        // 返回字符串的副本，忽略前導空白和尾部空白。
//        String s3 = s1.trim();
//        System.out.println(s3);    //suoning
        
//        // 返回給定data type類型x參數的字符串表示形式。
//        String s3 = String.valueOf(s1);
//        System.out.println(s3);    //suoning
    }
}

String practice

11、StringBuffer & StringBuilder 類

當對字符串進行修改的時候，須要使用 StringBuffer 和 StringBuilder 類。

和 String 類不一樣的是，StringBuffer 和 StringBuilder 類的對象可以被屢次的修改，而且不產生新的未使用對象。

StringBuilder 類在 Java 5 中被提出，它和 StringBuffer 之間的最大不一樣在於 StringBuilder 的方法不是線程安全的（不能同步訪問）。

因爲 StringBuilder 相較於 StringBuffer 有速度優點，因此多數狀況下建議使用 StringBuilder 類。然而在應用程序要求線程安全的狀況下，則必須使用 StringBuffer 類。

序號	方法描述
1	public StringBuffer append(String s) 將指定的字符串追加到此字符序列
2	public StringBuffer reverse() 將此字符序列用其反轉形式取代
3	public delete(int start, int end) 移除此序列的子字符串中的字符
4	public insert(int offset, int i) 將 `int` 參數的字符串表示形式插入此序列中
5	replace(int start, int end, String str) 使用給定 `String` 中的字符替換此序列的子字符串中的字符
6	int capacity() 返回當前容量。
7	char charAt(int index) 返回此序列中指定索引處的 `char` 值。
8	void ensureCapacity(int minimumCapacity) 確保容量至少等於指定的最小值。
9	void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 將字符今後序列複製到目標字符數組 `dst`。
10	int indexOf(String str) 返回第一次出現的指定子字符串在該字符串中的索引。
11	int indexOf(String str, int fromIndex) 從指定的索引處開始，返回第一次出現的指定子字符串在該字符串中的索引。
12	int lastIndexOf(String str) 返回最右邊出現的指定子字符串在此字符串中的索引。
13	int lastIndexOf(String str, int fromIndex) 返回最後一次出現的指定子字符串在此字符串中的索引。
14	int length() 返回長度（字符數）。
15	void setCharAt(int index, char ch) 將給定索引處的字符設置爲 `ch`。
16	void setLength(int newLength) 設置字符序列的長度。
17	CharSequence subSequence(int start, int end) 返回一個新的字符序列，該字符序列是此序列的子序列。
18	String substring(int start) 返回一個新的 `String`，它包含此字符序列當前所包含的字符子序列。
19	String substring(int start, int end) 返回一個新的 `String`，它包含此序列當前所包含的字符子序列。
20	String toString() 返回此序列中數據的字符串表示形式。

public class StringBufferBuilders {
    public static void main(String[] args){
        StringBuffer s1 = new StringBuffer("suoning");
        
//        //將指定的字符串追加到此字符序列。
//        String s2 = "nick";
//        StringBuffer s3 = s1.append(s2);
//        System.out.println(s3);    //suoningnick
        
//        //將此字符序列用其反轉形式取代。
//        StringBuffer s3 = s1.reverse();
//        System.out.println(s3);    //gninous
        
//        //移除此序列的子字符串中的字符。
//        StringBuffer s3 = s1.delete(0, 3);
//        System.out.println(s3);    //ning
        
//        //將 int 參數的字符串表示形式插入此序列中。
//        StringBuffer s3 = s1.insert(3, 99);
//        System.out.println(s3);    //suo99ning
        
//        //使用給定 String 中的字符替換此序列的子字符串中的字符。
//        StringBuffer s3 = s1.replace(0, 3, "nick");
//        System.out.println(s3);    //nickning
        
        
//        //返回當前容量。
//        int s3 = s1.capacity();
//        System.out.println(s3);    //23
        
//        //返回此序列中指定索引處的 char 值。
//        char s3 = s1.charAt(3);
//        System.out.println(s3);    //n
        
//        //確保容量至少等於指定的最小值。
//        s1.ensureCapacity(1);
//        System.out.println(s1.capacity());    //23
        
//        //將字符今後序列複製到目標字符數組 dst。
//        char[] s2 = new char[4];
//        s1.getChars(3,7,s2,0);
//        System.out.println(s2);    //ning
        
//        //返回第一次出現的指定子字符串在該字符串中的索引。
//        String s2 = "nick";
//        int s3 = s1.indexOf(s2);
//        System.out.println(s3);    //-1
//        //從指定的索引處開始，返回第一次出現的指定子字符串在該字符串中的索引。
//        String s2 = "nick";
//        int s3 = s1.indexOf(s2, 2);
//        System.out.println(s3);    //-1
        
//        //返回最右邊出現的指定子字符串在此字符串中的索引。
//        String s2 = "nick";
//        int s3 = s1.lastIndexOf(s2);
//        System.out.println(s3);    //-1
//        //返回最後一次出現的指定子字符串在此字符串中的索引。
//        String s2 = "nick";
//        int s3 = s1.lastIndexOf(s2, 3);
//        System.out.println(s3);    //-1
        
//        // 返回長度（字符數）。
//        int s3 = s1.length();
//        System.out.println(s3);    //7
        
//        //將給定索引處的字符設置爲 ch。
//        s1.setCharAt(3, 'm');
//        System.out.println(s1);    //suoming
        
//        //設置字符序列的長度
//        s1.setLength(9);
//        System.out.println(s1.length());    //9
        
//        //返回一個新的字符序列，該字符序列是此序列的子序列。
//        CharSequence s3 = s1.subSequence(3, 7);
//        System.out.println(s3);    //ning
        
//        //返回一個新的 String，它包含此字符序列當前所包含的字符子序列。
//        String s3 = s1.substring(3);
//        System.out.println(s3);    //ning
//        //返回一個新的 String，它包含此序列當前所包含的字符子序列。
//        String s3 = s1.substring(3,7);
//        System.out.println(s3);    //ning
        
//        //返回此序列中數據的字符串表示形式
//        String s3 = s1.toString();
//        System.out.println(s3);    //suoning
        
    }
}

StringBuffer & StringBuilder practice

12、數組

Java 語言中提供的數組是用來存儲固定大小的同類型元素。

// 申明及建立數組
int a1[] = new int[6];    //不推薦寫法,來源於C/C++
int[] a2 = new int[6];
int[] a3 = {1, 2, 3, 4, 5, 6};

數組的元素是經過索引訪問的。數組索引從 0 開始，因此索引值從 0 到 a2.length-1。

//多維數組
String s[][] = new String[5][9];
s[0][0] = new String("nick");
s[0][1] = new String("good");
s[1][0] = new String("jenny");
s[1][1] = new String("yep");
s[1][2] = new String("!");

public class TestArray {
   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};
 
      // 打印全部數組元素
      for (int i = 0; i < myList.length; i++) {
         System.out.println(myList[i] + " ");
      }
      // 計算全部元素的總和
      double total = 0;
      for (int i = 0; i < myList.length; i++) {
         total += myList[i];
      }
      System.out.println("Total is " + total);
      // 查找最大元素
      double max = myList[0];
      for (int i = 1; i < myList.length; i++) {
         if (myList[i] > max) max = myList[i];
      }
      System.out.println("Max is " + max);
   }
}

數組 practice

java.util.Arrays 類能方便地操做數組，它提供的全部方法都是靜態的。

序號	方法和說明
1	public static int binarySearch(Object[] a, Object key) 用二分查找算法在給定數組中搜索給定值的對象(Byte,Int,double等)。數組在調用前必須排序好的。若是查找值包含在數組中，則返回搜索鍵的索引；不然返回 (-(插入點) - 1)。
2	public static boolean equals(long[] a, long[] a2) 若是兩個指定的 long 型數組彼此相等，則返回 true。若是兩個數組包含相同數量的元素，而且兩個數組中的全部相應元素對都是相等的，則認爲這兩個數組是相等的。換句話說，若是兩個數組以相同順序包含相同的元素，則兩個數組是相等的。一樣的方法適用於全部的其餘基本數據類型（Byte，short，Int等）。
3	public static void fill(int[] a, int val) 將指定的 int 值分配給指定 int 型數組指定範圍中的每一個元素。一樣的方法適用於全部的其餘基本數據類型（Byte，short，Int等）。
4	public static void sort(Object[] a) 對指定對象數組根據其元素的天然順序進行升序排列。一樣的方法適用於全部的其餘基本數據類型（Byte，short，Int等）。

import java.util.Arrays;


public class MyArrayOfs {
    public static void main(String[] args){
        int a1[] = new int[6];
        int[] a2 = new int[6];
        int[] a3 = {1, 2, 3, 4, 5, 6};
        int[] a5 = {1, 2, 3, 9, 8, 8};
        int[] a6 = {1, 2, 3, 4, 5, 6};
        
        
//        //    public static boolean equals(long[] a, long[] a2)
//        //若是兩個指定的 long 型數組彼此相等，則返回 true。若是兩個數組包含相同數量的元素，而且兩個數組中的全部相應元素對都是相等的，則認爲這兩個數組是相等的。換句話說，若是兩個數組以相同順序包含相同的元素，則兩個數組是相等的。一樣的方法適用於全部的其餘基本數據類型（Byte，short，Int等）。
//        boolean b1 = Arrays.equals(a3, a5);
//        System.out.println(b1);    //false
//        boolean b2 = Arrays.equals(a3, a6);
//        System.out.println(b2);    //true
        
        
//        //public static void fill(int[] a, int val)
//        //填充值
//        //將指定的 int 值分配給指定 int 型數組指定範圍中的每一個元素。一樣的方法適用於全部的其餘基本數據類型（Byte，short，Int等）。
//        Arrays.fill(a2, 9);
//        System.out.println(a2[5]);    //9
        
        
//        //public static void sort(Object[] a)
//        //對指定對象數組根據其元素的天然順序進行升序排列。一樣的方法適用於全部的其餘基本數據類型（Byte，short，Int等）。
//        Arrays.sort(a5);
//        for(int i: a5) {
//             System.out.println(i);    //一、二、三、八、八、9
//          }
        
        
//        //public static int binarySearch(Object[] a, Object key)
//        //用二分查找算法在給定數組中搜索給定值的對象(Byte,Int,double等)。數組在調用前必須排序好的。若是查找值包含在數組中，則返回搜索鍵的索引；不然返回 (-(插入點) - 1)。
//        int index1 = Arrays.binarySearch(a5, 9);
//        System.out.println(index1);  //-7
//        Arrays.sort(a5);
//        int index2 = Arrays.binarySearch(a5, 8);
//        System.out.println(index2);  //4
//        int index3 = Arrays.binarySearch(a5, 9);
//        System.out.println(index3);  //5
    }
}

數組 practice

十3、Date 日期時間

java.util 包提供了 Date 類來封裝當前的日期和時間。

# 實例化 Date 對象
import java.util.Date;

Date d1 = new Date();
long t1 = 1514736000000L;
Date d2 = new Date(t1);
System.out.println(d1);  //Mon Dec 05 23:59:59 CST 2016
System.out.println(d2);  //Mon Jan 01 00:00:00 CST 2018

Date 對象的方法：

序號	方法和描述
1	boolean after(Date date) 若當調用此方法的Date對象在指定日期以後返回true,不然返回false。
2	boolean before(Date date) 若當調用此方法的Date對象在指定日期以前返回true,不然返回false。
3	Object clone( ) 返回此對象的副本。
4	int compareTo(Date date) 比較當調用此方法的Date對象和指定日期。二者相等時候返回0。調用對象在指定日期以前則返回負數。調用對象在指定日期以後則返回正數。
5	int compareTo(Object obj) 若obj是Date類型則操做等同於compareTo(Date) 。不然它拋出ClassCastException。
6	boolean equals(Object date) 當調用此方法的Date對象和指定日期相等時候返回true,不然返回false。
7	long getTime( ) 返回自 1970 年 1 月 1 日 00:00:00 GMT 以來此 Date 對象表示的毫秒數。
8	int hashCode( ) 返回此對象的哈希碼值。
9	void setTime(long time) 用自1970年1月1日00:00:00 GMT之後time毫秒數設置時間和日期。
10	String toString( ) 轉換Date對象爲String表示形式，並返回該字符串。

import java.util.Date;


public class DateTimes {
    public static void main(String[] args){
        Date d1 = new Date();
        long t1 = 1514736000000L;
        Date d2 = new Date(t1);
        System.out.println(d1);  //Mon Dec 05 23:59:59 CST 2016
        System.out.println(d2);  //Mon Jan 01 00:00:00 CST 2018
        
        
//        //    boolean after(Date date)
//        //若當調用此方法的Date對象在指定日期以前\後返回true,不然返回false。
//        boolean b1 = d2.after(d1);
//        System.out.println(b1);  //true
        
        
//        //    int compareTo(Date date)
//        //比較當調用此方法的Date對象和指定日期。二者相等時候返回0。調用對象在指定日期以前則返回負數。調用對象在指定日期以後則返回正數
//        int b1 = d2.compareTo(d1);
//        System.out.println(b1);  //1
        
        
//        //    int compareTo(Object obj)
//        //若obj是Date類型則操做等同於compareTo(Date) 。不然它拋出ClassCastException。
//        int b1 = d2.compareTo(d1);
//        System.out.println(b1);  //1
        
        
//        //boolean equals(Object date)
//        //當調用此方法的Date對象和指定日期相等時候返回true,不然返回false
//        boolean b1 = d2.equals(d1);
//        System.out.println(b1);  //false
        
        
//        //    long getTime( )
//        //返回自 1970 年 1 月 1 日 00:00:00 GMT 以來此 Date 對象表示的毫秒數。
//        long l1 = d2.getTime();
//        System.out.println(l1);  //1514736000000
        
        
//        //int hashCode( )
//        //返回此對象的哈希碼值。
//        long l1 = d2.hashCode();
//        System.out.println(l1);  //-1387455136
        
        
//        //void setTime(long time)
//        //用自1970年1月1日00:00:00 GMT之後time毫秒數設置時間和日期。
//        d1.setTime(t1);
//        System.out.println(d1);  //Mon Jan 01 00:00:00 CST 2018
        
        
//        //String toString( )
//        //轉換Date對象爲String表示形式，並返回該字符串。
//        d2.toString();
//        System.out.println(d2);  //Mon Jan 01 00:00:00 CST 2018
    }
}

Date practice

import java.util.Date;
  
public class DateDemo {
   public static void main(String args[]) {
       // 初始化 Date 對象
       Date date = new Date();
        
       // 使用 toString() 函數顯示日期時間
       System.out.println(date.toString());
   }
}

獲取當前日期時間

使用DateFormat 格式化日期

日期和時間轉換字符

字符	描述	例子
c	完整的日期和時間	Mon May 04 09:51:52 CDT 2009
F	ISO 8601 格式日期	2004-02-09
D	U.S. 格式日期 (月/日/年)	02/09/2004
T	24小時時間	18:05:19
r	12小時時間	06:05:19 pm
R	24小時時間，不包含秒	18:05
Y	4位年份(包含前導0)	2004
y	年份後2位(包含前導0)	04
C	年份前2位(包含前導0)	20
B	月份全稱	February
b	月份簡稱	Feb
m	2位月份(包含前導0)	02
d	2位日子(包含前導0)	03
e	2位日子(不包含前導0)	9
A	星期全稱	Monday
a	星期簡稱	Mon
j	3位年份(包含前導0)	069
H	2位小時(包含前導0), 00 到 23	18
k	2位小時(不包含前導0), 0 到 23	18
I	2位小時(包含前導0), 01 到 12	06
l	2位小時(不包含前導0), 1 到 12	6
M	2位分鐘(包含前導0)	05
S	2位秒數(包含前導0)	19
L	3位毫秒(包含前導0)	047
N	9位納秒(包含前導0)	047000000
P	大寫上下午標誌	PM
p	小寫上下午標誌	pm
z	從GMT的RFC 822數字偏移	-0800
Z	時區	PST
s	自 1970-01-01 00:00:00 GMT的秒數	1078884319
Q	自 1970-01-01 00:00:00 GMT的毫妙	1078884319047

//使用兩個字母格式，它以t開頭而且如下面表格中的一個字母結尾。

import java.util.Date;
  public class DateTimes {
  public static void main(String args[]) {
      //初始化 Date 對象
      Date date = new Date();
      //使用toString()顯示日期和時間
      String str = String.format("Current Date/Time : %tc", date );
      System.out.println(str);    //Current Date/Time : Sat Jan 1 00:00:00 MST 2018
      System.out.printf("%1$s %2$tB %2$td, %2$tY", "Due date:", date); //Jan date: January 01, 2018
      System.out.printf("%s %tB %<te, %<tY", "Due date:", date); //Jan date: January 01, 2018
  }
}

//解析字符串爲時間

import java.util.*;
import java.text.*;

public class DateTimes {
    public static void main(String args[]) {
        SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd");
        String input = args.length == 0 ? "2018-01-01" : args[0];
        System.out.print(input + " Parses as ");
        Date t;
        try {
          t = ft.parse(input);
          System.out.println(t);
          } catch (ParseException e) {
          System.out.println("Unparseable using " + ft);
          //2018-01-01 Parses as Mon Jan 01 00:00:00 CST 2018
        }
    }
}

解析字符串爲時間

//Java 休眠(sleep)

import java.util.*;

public class DateTimes {
    public static void main(String args[]) {
        try {
            System.out.println(new Date( ) + "\n");
            Thread.sleep(1000*3); // 休眠3秒
            System.out.println(new Date( ) + "\n");
        } catch (Exception e) {
            System.out.println("Got an exception!");
        }
    }
}

Java 休眠(sleep)

//檢測時間間隔（以毫秒爲單位）

import java.util.*;

public class DateTimes {

   public static void main(String args[]) {
      try {
         long start = System.currentTimeMillis( );
         System.out.println(new Date( ) + "\n");
         Thread.sleep(5*20*5);
         System.out.println(new Date( ) + "\n");
         long end = System.currentTimeMillis( );
         long diff = end - start;
         System.out.println("Difference is : " + diff);    //Difference is : 520
      } catch (Exception e) {
         System.out.println("Got an exception!");
      }
   }
}