Java 運算符

計算機的最基本用途之一就是執行數學運算，做爲一門計算機語言，Java也提供了一套豐富的運算符來操縱變量。咱們能夠把運算符分紅如下幾組：java

算術運算符
關係運算符
位運算符
邏輯運算符
賦值運算符
其餘運算符

Java 加強 for 循環

Java5 引入了一種主要用於數組的加強型 for 循環。程序員

Java 加強 for 循環語法格式以下:編程

public class Test {
   public static void main(String args[]){
      int [] numbers = {10, 20, 30, 40, 50};
 
      for(int x : numbers ){
         System.out.print( x );
         System.out.print(",");
      }
      System.out.print("\n");
      String [] names ={"James", "Larry", "Tom", "Lacy"};
      for( String name : names ) {
         System.out.print( name );
         System.out.print(",");
      }
   }
}

Java switch case 語句

switch case 語句判斷一個變量與一系列值中某個值是否相等，每一個值稱爲一個分支。windows

switch case 語句有以下規則：數組

switch 語句中的變量類型能夠是： byte、short、int 或者 char。從 Java SE 7 開始，switch 支持字符串 String 類型了，同時 case 標籤必須爲字符串常量或字面量。緩存
switch 語句能夠擁有多個 case 語句。每一個 case 後面跟一個要比較的值和冒號。安全
case 語句中的值的數據類型必須與變量的數據類型相同，並且只能是常量或者字面常量。網絡
當變量的值與 case 語句的值相等時，那麼 case 語句以後的語句開始執行，直到 break 語句出現纔會跳出 switch 語句。數據結構
當遇到 break 語句時，switch 語句終止。程序跳轉到 switch 語句後面的語句執行。case 語句沒必要需要包含 break 語句。若是沒有 break 語句出現，程序會繼續執行下一條 case 語句，直到出現 break 語句。app
switch 語句能夠包含一個 default 分支，該分支通常是 switch 語句的最後一個分支（能夠在任何位置，但建議在最後一個）。default 在沒有 case 語句的值和變量值相等的時候執行。default 分支不須要 break 語句。
若是 case 語句塊中沒有 break 語句時，匹配成功後，從當前 case 開始，後續全部 case 的值都會輸出。若是後續的 case 語句塊有 break 語句則會跳出判斷。

public class Test {
   public static void main(String args[]){
      //char grade = args[0].charAt(0);
      char grade = 'C';
 
      switch(grade)
      {
         case 'A' :
            System.out.println("優秀"); 
            break;
         case 'B' :
         case 'C' :
            System.out.println("良好");
            break;
         case 'D' :
            System.out.println("及格");
            break;
         case 'F' :
            System.out.println("你須要再努力努力");
            break;
         default :
            System.out.println("未知等級");
      }
      System.out.println("你的等級是 " + grade);
   }
}

Java StringBuffer 和 StringBuilder 類

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

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

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

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

Java 數組

數組對於每一門編程語言來講都是重要的數據結構之一，固然不一樣語言對數組的實現及處理也不盡相同。

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

你能夠聲明一個數組變量，如 numbers[100] 來代替直接聲明 100 個獨立變量 number0，number1，....，number99。

本教程將爲你們介紹 Java 數組的聲明、建立和初始化，並給出其對應的代碼。

For-Each 循環

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

語法格式以下：

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);
      }
   }
}

多維數組的動態初始化（以二維數組爲例）

二維數組 a 能夠當作一個兩行三列的數組。

2. 從最高維開始，分別爲每一維分配空間，例如：

String s[][] = new String[2][];
s[0] = new String[2];
s[1] = new String[3];
s[0][0] = new String("Good");
s[0][1] = new String("Luck");
s[1][0] = new String("to");
s[1][1] = new String("you");
s[1][2] = new String("!");

解析：

s[0]=new String[2] 和 s[1]=new String[3] 是爲最高維分配引用空間，也就是爲最高維限制其能保存數據的最長的長度，而後再爲其每一個數組元素單獨分配空間 s0=new String("Good") 等操做。

解析字符串爲時間

SimpleDateFormat 類有一些附加的方法，特別是parse()，它試圖按照給定的SimpleDateFormat 對象的格式化存儲來解析字符串。例如：

import java.util.*;
import java.text.*;
  
public class DateDemo {
 
   public static void main(String args[]) {
      SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd"); 
 
      String input = args.length == 0 ? "1818-11-11" : 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); 
      }
   }
}

結果:

$ java DateDemo
1818-11-11 Parses as Wed Nov 11 00:00:00 GMT 1818
$ java DateDemo 2007-12-01
2007-12-01 Parses as Sat Dec 01 00:00:00 GMT 2007

Calendar類

咱們如今已經可以格式化並建立一個日期對象了，可是咱們如何才能設置和獲取日期數據的特定部分呢，好比說小時，日，或者分鐘? 咱們又如何在日期的這些部分加上或者減去值呢? 答案是使用Calendar 類。

Calendar類的功能要比Date類強大不少，並且在實現方式上也比Date類要複雜一些。

Calendar類是一個抽象類，在實際使用時實現特定的子類的對象，建立對象的過程對程序員來講是透明的，只須要使用getInstance方法建立便可。

建立一個指定日期的Calendar對象

使用Calendar類表明特定的時間，須要首先建立一個Calendar的對象，而後再設定該對象中的年月日參數來完成。

//建立一個表明2009年6月12日的Calendar對象
Calendar c1 = Calendar.getInstance();
c1.set(2009, 6 - 1, 12);

方法的重載

上面使用的max方法僅僅適用於int型數據。但若是你想獲得兩個浮點類型數據的最大值呢？

解決方法是建立另外一個有相同名字但參數不一樣的方法，以下面代碼所示：

public static double max(double num1, double num2) {
  if (num1 > num2)
    return num1;
  else
    return num2;
}

若是你調用max方法時傳遞的是int型參數，則 int型參數的max方法就會被調用；

若是傳遞的是double型參數，則double類型的max方法體會被調用，這叫作方法重載；

就是說一個類的兩個方法擁有相同的名字，可是有不一樣的參數列表。

Java編譯器根據方法簽名判斷哪一個方法應該被調用。

方法重載可讓程序更清晰易讀。執行密切相關任務的方法應該使用相同的名字。

重載的方法必須擁有不一樣的參數列表。你不能僅僅依據修飾符或者返回類型的不一樣來重載方法。

構造方法

當一個對象被建立時候，構造方法用來初始化該對象。構造方法和它所在類的名字相同，但構造方法沒有返回值。

一般會使用構造方法給一個類的實例變量賦初值，或者執行其它必要的步驟來建立一個完整的對象。

無論你是否自定義構造方法，全部的類都有構造方法，由於Java自動提供了一個默認構造方法，默認構造方法的訪問修改符和類的訪問修改符相同(類爲 public，構造函數也爲 public；類改成 private，構造函數也改成 private)。

一旦你定義了本身的構造方法，默認構造方法就會失效。

可變參數

JDK 1.5 開始，Java支持傳遞同類型的可變參數給一個方法。

方法的可變參數的聲明以下所示

在方法聲明中，在指定參數類型後加一個省略號(...) 。

一個方法中只能指定一個可變參數，它必須是方法的最後一個參數。任何普通的參數必須在它以前聲明。

public class VarargsDemo {
    public static void main(String args[]) {
        // 調用可變參數的方法
        printMax(34, 3, 3, 2, 56.5);
        printMax(new double[]{1, 2, 3});
    }
 
    public static void printMax( double... numbers) {
        if (numbers.length == 0) {
            System.out.println("No argument passed");
            return;
        }
 
        double result = numbers[0];
 
        for (int i = 1; i <  numbers.length; i++){
            if (numbers[i] >  result) {
                result = numbers[i];
            }
        }
        System.out.println("The max value is " + result);
    }
}

finalize() 方法

Java 容許定義這樣的方法，它在對象被垃圾收集器析構(回收)以前調用，這個方法叫作 finalize( )，它用來清除回收對象。

例如，你可使用 finalize() 來確保一個對象打開的文件被關閉了。

在 finalize() 方法裏，你必須指定在對象銷燬時候要執行的操做。

public class FinalizationDemo {  
  public static void main(String[] args) {  
    Cake c1 = new Cake(1);  
    Cake c2 = new Cake(2);  
    Cake c3 = new Cake(3);  
      
    c2 = c3 = null;  
    System.gc(); //調用Java垃圾收集器
  }  
}  
 
class Cake extends Object {  
  private int id;  
  public Cake(int id) {  
    this.id = id;  
    System.out.println("Cake Object " + id + "is created");  
  }  
    
  protected void finalize() throws java.lang.Throwable {  
    super.finalize();  
    System.out.println("Cake Object " + id + "is disposed");  
  }  
}

Java 流(Stream)、文件(File)和IO

Java.io 包幾乎包含了全部操做輸入、輸出須要的類。全部這些流類表明了輸入源和輸出目標。

Java.io 包中的流支持不少種格式，好比：基本類型、對象、本地化字符集等等。

一個流能夠理解爲一個數據的序列。輸入流表示從一個源讀取數據，輸出流表示向一個目標寫數據。

Java 爲 I/O 提供了強大的而靈活的支持，使其更普遍地應用到文件傳輸和網絡編程中。

但本節講述最基本的和流與 I/O 相關的功能。咱們將經過一個個例子來學習這些功能。

讀取控制檯輸入

Java 的控制檯輸入由 System.in 完成。

爲了得到一個綁定到控制檯的字符流，你能夠把 System.in 包裝在一個 BufferedReader 對象中來建立一個字符流。

下面是建立 BufferedReader 的基本語法：

BufferedReader br = new BufferedReader(new 
                      InputStreamReader(System.in));

從控制檯讀取多字符輸入

從 BufferedReader 對象讀取一個字符要使用 read() 方法，它的語法以下：vint read( ) throws IOException

每次調用 read() 方法，它從輸入流讀取一個字符並把該字符做爲整數值返回。當流結束的時候返回 -1。該方法拋出 IOException。

下面的程序示範了用 read() 方法從控制檯不斷讀取字符直到用戶輸入 "q"。

//使用 BufferedReader 在控制檯讀取字符
 
import java.io.*;
 
public class BRRead {
    public static void main(String args[]) throws IOException {
        char c;
        // 使用 System.in 建立 BufferedReader
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("輸入字符, 按下 'q' 鍵退出。");
        // 讀取字符
        do {
            c = (char) br.read();
            System.out.println(c);
        } while (c != 'q');
    }
}

Java 流(Stream)、文件(File)和IO

Java.io 包幾乎包含了全部操做輸入、輸出須要的類。全部這些流類表明了輸入源和輸出目標。

Java.io 包中的流支持不少種格式，好比：基本類型、對象、本地化字符集等等。

一個流能夠理解爲一個數據的序列。輸入流表示從一個源讀取數據，輸出流表示向一個目標寫數據。

Java 爲 I/O 提供了強大的而靈活的支持，使其更普遍地應用到文件傳輸和網絡編程中。

但本節講述最基本的和流與 I/O 相關的功能。咱們將經過一個個例子來學習這些功能。

讀取控制檯輸入

Java 的控制檯輸入由 System.in 完成。

爲了得到一個綁定到控制檯的字符流，你能夠把 System.in 包裝在一個 BufferedReader 對象中來建立一個字符流。

從 BufferedReader 對象讀取一個字符要使用 read() 方法，

import java.io.*;
 
public class BRRead {
    public static void main(String args[]) throws IOException {
        char c;
        // 使用 System.in 建立 BufferedReader
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("輸入字符, 按下 'q' 鍵退出。");
        // 讀取字符
        do {
            c = (char) br.read();
            System.out.println(c);
        } while (c != 'q');
    }
}

從控制檯讀取字符串

從標準輸入讀取一個字符串須要使用 BufferedReader 的 readLine() 方法。

import java.io.*;
 
public class BRReadLines {
    public static void main(String args[]) throws IOException {
        // 使用 System.in 建立 BufferedReader
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String str;
        System.out.println("Enter lines of text.");
        System.out.println("Enter 'end' to quit.");
        do {
            str = br.readLine();
            System.out.println(str);
        } while (!str.equals("end"));
    }
}

FileInputStream

該流用於從文件讀取數據，它的對象能夠用關鍵字 new 來建立。

有多種構造方法可用來建立對象。

可使用字符串類型的文件名來建立一個輸入流對象來讀取文件：

InputStream f = new FileInputStream("C:/java/hello");

也可使用一個文件對象來建立一個輸入流對象來讀取文件。咱們首先得使用 File() 方法來建立一個文件對象：

File f = new File("C:/java/hello");

InputStream out = new FileInputStream(f);

FileOutputStream

該類用來建立一個文件並向文件中寫數據。

若是該流在打開文件進行輸出前，目標文件不存在，那麼該流會建立該文件。

有兩個構造方法能夠用來建立 FileOutputStream 對象。

使用字符串類型的文件名來建立一個輸出流對象：

OutputStream f = new FileOutputStream("C:/java/hello")；

也可使用一個文件對象來建立一個輸出流來寫文件。咱們首先得使用File()方法來建立一個文件對象：

File f = new File("C:/java/hello");

OutputStream f = new FileOutputStream(f);

import java.io.*;
 
public class fileStreamTest {
    public static void main(String args[]) {
        try {
            byte bWrite[] = { 11, 21, 3, 40, 5 };
            OutputStream os = new FileOutputStream("test.txt");
            for (int x = 0; x < bWrite.length; x++) {
                os.write(bWrite[x]); // writes the bytes
            }
            os.close();
 
            InputStream is = new FileInputStream("test.txt");
            int size = is.available();
 
            for (int i = 0; i < size; i++) {
                System.out.print((char) is.read() + "  ");
            }
            is.close();
        } catch (IOException e) {
            System.out.print("Exception");
        }
    }
}

上面的程序首先建立文件test.txt，並把給定的數字以二進制形式寫進該文件，同時輸出到控制檯上。

以上代碼因爲是二進制寫入，可能存在亂碼，你可使用如下代碼實例來解決亂碼問題：

import java.io.*;
 
public class fileStreamTest2 {
    public static void main(String[] args) throws IOException {
 
        File f = new File("a.txt");
        FileOutputStream fop = new FileOutputStream(f);
        // 構建FileOutputStream對象,文件不存在會自動新建
 
        OutputStreamWriter writer = new OutputStreamWriter(fop, "UTF-8");
        // 構建OutputStreamWriter對象,參數能夠指定編碼,默認爲操做系統默認編碼,windows上是gbk
 
        writer.append("中文輸入");
        // 寫入到緩衝區
 
        writer.append("\r\n");
        // 換行
 
        writer.append("English");
        // 刷新緩存衝,寫入到文件,若是下面已經沒有寫入的內容了,直接close也會寫入
 
        writer.close();
        // 關閉寫入流,同時會把緩衝區內容寫入文件,因此上面的註釋掉
 
        fop.close();
        // 關閉輸出流,釋放系統資源
 
        FileInputStream fip = new FileInputStream(f);
        // 構建FileInputStream對象
 
        InputStreamReader reader = new InputStreamReader(fip, "UTF-8");
        // 構建InputStreamReader對象,編碼與寫入相同
 
        StringBuffer sb = new StringBuffer();
        while (reader.ready()) {
            sb.append((char) reader.read());
            // 轉成char加到StringBuffer對象中
        }
        System.out.println(sb.toString());
        reader.close();
        // 關閉讀取流
 
        fip.close();
        // 關閉輸入流,釋放系統資源
 
    }
}

Java中的目錄

建立目錄：

File類中有兩個方法能夠用來建立文件夾：

mkdir( )方法建立一個文件夾，成功則返回true，失敗則返回false。失敗代表File對象指定的路徑已經存在，或者因爲整個路徑還不存在，該文件夾不能被建立。
mkdirs()方法建立一個文件夾和它的全部父文件夾。

import java.io.File;
 
public class CreateDir {
    public static void main(String args[]) {
        String dirname = "/tmp/user/java/bin";
        File d = new File(dirname);
        // 如今建立目錄
        d.mkdirs();
    }
}

編譯並執行上面代碼來建立目錄 "/tmp/user/java/bin"。

注意： Java 在 UNIX 和 Windows 自動按約定分辨文件路徑分隔符。若是你在 Windows 版本的 Java 中使用分隔符 (/) ，路徑依然可以被正確解析。

讀取目錄

一個目錄其實就是一個 File 對象，它包含其餘文件和文件夾。

若是建立一個 File 對象而且它是一個目錄，那麼調用 isDirectory() 方法會返回 true。

能夠經過調用該對象上的 list() 方法，來提取它包含的文件和文件夾的列表。

下面展現的例子說明如何使用 list() 方法來檢查一個文件夾中包含的內容：

import java.io.File;
 
public class DirList {
    public static void main(String args[]) {
        String dirname = "/tmp";
        File f1 = new File(dirname);
        if (f1.isDirectory()) {
            System.out.println("目錄 " + dirname);
            String s[] = f1.list();
            for (int i = 0; i < s.length; i++) {
                File f = new File(dirname + "/" + s[i]);
                if (f.isDirectory()) {
                    System.out.println(s[i] + " 是一個目錄");
                } else {
                    System.out.println(s[i] + " 是一個文件");
                }
            }
        } else {
            System.out.println(dirname + " 不是一個目錄");
        }
    }
}

刪除目錄或文件

刪除文件可使用 java.io.File.delete() 方法。

如下代碼會刪除目錄 /tmp/java/，須要注意的是當刪除某一目錄時，必須保證該目錄下沒有其餘文件才能正確刪除，不然將刪除失敗。

測試目錄結構：

import java.io.File;
 
public class DeleteFileDemo {
    public static void main(String args[]) {
        // 這裏修改成本身的測試目錄
        File folder = new File("/tmp/java/");
        deleteFolder(folder);
    }
 
    // 刪除文件及目錄
    public static void deleteFolder(File folder) {
        File[] files = folder.listFiles();
        if (files != null) {
            for (File f : files) {
                if (f.isDirectory()) {
                    deleteFolder(f);
                } else {
                    f.delete();
                }
            }
        }
        folder.delete();
    }
}

Java Scanner 類

java.util.Scanner 是 Java5 的新特徵，咱們能夠經過 Scanner 類來獲取用戶的輸入。

下面是建立 Scanner 對象的基本語法：Scanner s = new Scanner(System.in);

接下來咱們演示一個最簡單的數據輸入，並經過 Scanner 類的 next() 與 nextLine() 方法獲取輸入的字符串，在讀取前咱們通常須要使用 hasNext 與 hasNextLine 判斷是否還有輸入的數據：

其中：hasNext（）方法包含判斷和輸入兩個操做步驟

import java.util.Scanner; 
 
public class ScannerDemo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        // 從鍵盤接收數據
 
        // next方式接收字符串
        System.out.println("next方式接收：");
        // 判斷是否還有輸入
        if (scan.hasNext()) {
            String str1 = scan.next();
            System.out.println("輸入的數據爲：" + str1);
        }
        scan.close();
    }
}

結果：

$ javac ScannerDemo.java $ java ScannerDemo next方式接收： runoob com 輸入的數據爲：runoob

使用 nextLine 方法：

import java.util.Scanner;
 
public class ScannerDemo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        // 從鍵盤接收數據
 
        // nextLine方式接收字符串
        System.out.println("nextLine方式接收：");
        // 判斷是否還有輸入
        if (scan.hasNextLine()) {
            String str2 = scan.nextLine();
            System.out.println("輸入的數據爲：" + str2);
        }
        scan.close();
    }
}


結果：

$ javac ScannerDemo.java $ java ScannerDemo nextLine方式接收： runoob com 輸入的數據爲：runoob com

next() 與 nextLine() 區別

next():

一、必定要讀取到有效字符後才能夠結束輸入。
二、對輸入有效字符以前遇到的空白，next() 方法會自動將其去掉。
三、只有輸入有效字符後纔將其後面輸入的空白做爲分隔符或者結束符。
next() 不能獲得帶有空格的字符串。

nextLine()：

一、以Enter爲結束符,也就是說 nextLine()方法返回的是輸入回車以前的全部字符。
二、能夠得到空白。

若是要輸入 int 或 float 類型的數據，在 Scanner 類中也有支持，可是在輸入以前最好先使用 hasNextXxx() 方法進行驗證，再使用 nextXxx() 來讀取：

import java.util.Scanner;
 
public class ScannerDemo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        // 從鍵盤接收數據
        int i = 0;
        float f = 0.0f;
        System.out.print("輸入整數：");
        if (scan.hasNextInt()) {
            // 判斷輸入的是不是整數
            i = scan.nextInt();
            // 接收整數
            System.out.println("整數數據：" + i);
        } else {
            // 輸入錯誤的信息
            System.out.println("輸入的不是整數！");
        }
        System.out.print("輸入小數：");
        if (scan.hasNextFloat()) {
            // 判斷輸入的是不是小數
            f = scan.nextFloat();
            // 接收小數
            System.out.println("小數數據：" + f);
        } else {
            // 輸入錯誤的信息
            System.out.println("輸入的不是小數！");
        }
        scan.close();
    }
}

結果：

$ javac ScannerDemo.java $ java ScannerDemo 輸入整數：12 整數數據：12 輸入小數：1.2 小數數據：1.2

java-運算符，IO輸入輸出，文件操做

Java 運算符

Java 加強 for 循環

Java switch case 語句

Java StringBuffer 和 StringBuilder 類

Java 數組

For-Each 循環

多維數組的動態初始化（以二維數組爲例）

解析字符串爲時間

Calendar類

建立一個指定日期的Calendar對象

方法的重載

構造方法

可變參數

finalize() 方法

Java 流(Stream)、文件(File)和IO

讀取控制檯輸入

從控制檯讀取多字符輸入

Java 流(Stream)、文件(File)和IO

讀取控制檯輸入

從控制檯讀取字符串

FileInputStream

FileOutputStream

Java中的目錄

建立目錄：

讀取目錄

刪除目錄或文件

Java Scanner 類

使用 nextLine 方法：

next() 與 nextLine() 區別