【Java學習系列】第3課--Java 高級教程

import java.util.Vector;
import java.util.Enumeration;

public class EnumerationTester {

   public static void main(String args[]) {
      Enumeration days;
      Vector dayNames = new Vector();
      dayNames.add("Sunday");
      dayNames.add("Monday");
      dayNames.add("Tuesday");
      dayNames.add("Wednesday");
      dayNames.add("Thursday");
      dayNames.add("Friday");
      dayNames.add("Saturday");
      days = dayNames.elements();
      while (days.hasMoreElements()){
         System.out.println(days.nextElement()); 
      }
   }
}

EnumerationTester.java

　　運行結果：

Sunday
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday

運行結果

　　3）位集合（BitSet）

　　　　a)【定義】

　　　　　　位集合類實現了一組可以單獨設置和清除的位或標志。該類在處理一組布爾值的時候非常有用，你只需要給每個值賦值一"位"，然后對位進行適當的設置或清除，就可以對布爾值進行操作了。

　　　　b)【代碼舉例】

import java.util.BitSet;

public class BitSetDemo {

  public static void main(String args[]) {
     BitSet bits1 = new BitSet(16);
     BitSet bits2 = new BitSet(16);
      
     // set some bits
     for(int i=0; i<16; i++) {
        if((i%2) == 0) bits1.set(i);
        if((i%5) != 0) bits2.set(i);
     }
     System.out.println("Initial pattern in bits1: ");
     System.out.println(bits1);
     System.out.println("\nInitial pattern in bits2: ");
     System.out.println(bits2);

     // AND bits
     bits2.and(bits1);
     System.out.println("\nbits2 AND bits1: ");
     System.out.println(bits2);

     // OR bits
     bits2.or(bits1);
     System.out.println("\nbits2 OR bits1: ");
     System.out.println(bits2);

     // XOR bits
     bits2.xor(bits1);
     System.out.println("\nbits2 XOR bits1: ");
     System.out.println(bits2);
  }
}

BitSetDemo.java

　　運行結果：

Initial pattern in bits1:
{0, 2, 4, 6, 8, 10, 12, 14}

Initial pattern in bits2:
{1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 14}

bits2 AND bits1:
{2, 4, 6, 8, 12, 14}

bits2 OR bits1:
{0, 2, 4, 6, 8, 10, 12, 14}

bits2 XOR bits1:
{}

運行結果

　4）向量(Vector )

　　a)【定義】

　　　　向量（Vector）類和傳統數組非常相似，但是Vector的大小能根據需要動態的變化。

　　　　和數組一樣，Vector對象的元素也能通過索引訪問。

　　　　使用Vector類最主要的好處就是在創建對象的時候不必給對象指定大小，它的大小會根據需要動態的變化。

　　b)【代碼實例】

import java.util.*;

public class VectorDemo {

   public static void main(String args[]) {
      // initial size is 3, increment is 2
      Vector v = new Vector(3, 2);
      System.out.println("Initial size: " + v.size());
      System.out.println("Initial capacity: " +
      v.capacity());
      v.addElement(new Integer(1));
      v.addElement(new Integer(2));
      v.addElement(new Integer(3));
      v.addElement(new Integer(4));
      System.out.println("Capacity after four additions: " +
          v.capacity());

      v.addElement(new Double(5.45));
      System.out.println("Current capacity: " +
      v.capacity());
      v.addElement(new Double(6.08));
      v.addElement(new Integer(7));
      System.out.println("Current capacity: " +
      v.capacity());
      v.addElement(new Float(9.4));
      v.addElement(new Integer(10));
      System.out.println("Current capacity: " +
      v.capacity());
      v.addElement(new Integer(11));
      v.addElement(new Integer(12));
      System.out.println("First element: " +
         (Integer)v.firstElement());
      System.out.println("Last element: " +
         (Integer)v.lastElement());
      if(v.contains(new Integer(3)))
         System.out.println("Vector contains 3.");
      // enumerate the elements in the vector.
      Enumeration vEnum = v.elements();
      System.out.println("\nElements in vector:");
      while(vEnum.hasMoreElements())
         System.out.print(vEnum.nextElement() + " ");
      System.out.println();
   }
}

VectorDemo.java

　　　　運行結果：

Initial size: 0
Initial capacity: 3
Capacity after four additions: 5
Current capacity: 5
Current capacity: 7
Current capacity: 9
First element: 1
Last element: 12
Vector contains 3.

Elements in vector:
1 2 3 4 5.45 6.08 7 9.4 10 11 12

運行結果

5）棧（Stack）

　　a)【定義】

　　　　棧（Stack）實現了一個后進先出（LIFO）的數據結構。

　　　　你可以把棧理解為對象的垂直分布的棧，當你添加一個新元素時，就將新元素放在其他元素的頂部。

　　　　當你從棧中取元素的時候，就從棧頂取一個元素。換句話說，最后進棧的元素最先被取出。

　　b)【代碼實例】

import java.util.*;

public class StackDemo {

   static void showpush(Stack st, int a) {
      st.push(new Integer(a));
      System.out.println("push(" + a + ")");
      System.out.println("stack: " + st);
   }

   static void showpop(Stack st) {
      System.out.print("pop -> ");
      Integer a = (Integer) st.pop();
      System.out.println(a);
      System.out.println("stack: " + st);
   }

   public static void main(String args[]) {
      Stack st = new Stack();
      System.out.println("stack: " + st);
      showpush(st, 42);
      showpush(st, 66);
      showpush(st, 99);
      showpop(st);
      showpop(st);
      showpop(st);
      try {
         showpop(st);
      } catch (EmptyStackException e) {
         System.out.println("empty stack");
      }
   }
}

StackDemo.java

　　　　運行結果：

stack: [ ]
push(42)
stack: [42]
push(66)
stack: [42, 66]
push(99)
stack: [42, 66, 99]
pop -> 99
stack: [42, 66]
pop -> 66
stack: [42]
pop -> 42
stack: [ ]
pop -> empty stack

運行結果

6）字典（Dictionary）

　　a)【定義】

　　　　字典（Dictionary）類是一個抽象類，它定義了鍵映射到值的數據結構。

　　　　當你想要通過特定的鍵而不是整數索引來訪問數據的時候，這時候應該使用Dictionary。

　　　　由於Dictionary類是抽象類，所以它只提供了鍵映射到值的數據結構，而沒有提供特定的實現。

7）哈希表（Hashtable）

　　a)【定義】　　

　　　　Hashtable類提供了一種在用戶定義鍵結構的基礎上來組織數據的手段。

　　　　例如，在地址列表的哈希表中，你可以根據郵政編碼作為鍵來存儲和排序數據，而不是通過人名。

　　b)【代碼實現】

import java.util.*;

public class HashTableDemo {

   public static void main(String args[]) {
      // Create a hash map
      Hashtable balance = new Hashtable();
      Enumeration names;
      String str;
      double bal;

      balance.put("Zara", new Double(3434.34));
      balance.put("Mahnaz", new Double(123.22));
      balance.put("Ayan", new Double(1378.00));
      balance.put("Daisy", new Double(99.22));
      balance.put("Qadir", new Double(-19.08));

      // Show all balances in hash table.
      names = balance.keys();
      while(names.hasMoreElements()) {
         str = (String) names.nextElement();
         System.out.println(str + ": " +
         balance.get(str));
      }
      System.out.println();
      // Deposit 1,000 into Zara's account
      bal = ((Double)balance.get("Zara")).doubleValue();
      balance.put("Zara", new Double(bal+1000));
      System.out.println("Zara's new balance: " +
      balance.get("Zara"));
   }
}

HashTableDemo.java

　　運行結果如下：

Qadir: -19.08
Zara: 3434.34
Mahnaz: 123.22
Daisy: 99.22
Ayan: 1378.0

Zara's new balance: 4434.34

運行結果

8）哈希表（Hashtable）

　　a)【定義】

　　　　Properties 繼承於 Hashtable.Properties 類表示了一個持久的屬性集.屬性列表中每個鍵及其對應值都是一個字符串。

　　　　Properties 類被許多Java類使用。例如，在獲取環境變量時它就作為System.getProperties()方法的返回值。

　　b)【代碼實現】

import java.util.*;

public class PropDemo {

   public static void main(String args[]) {
      Properties capitals = new Properties();
      Set states;
      String str;
      
      capitals.put("Illinois", "Springfield");
      capitals.put("Missouri", "Jefferson City");
      capitals.put("Washington", "Olympia");
      capitals.put("California", "Sacramento");
      capitals.put("Indiana", "Indianapolis");

      // Show all states and capitals in hashtable.
      states = capitals.keySet(); // get set-view of keys
      Iterator itr = states.iterator();
      while(itr.hasNext()) {
         str = (String) itr.next();
         System.out.println("The capital of " +
            str + " is " + capitals.getProperty(str) + ".");
      }
      System.out.println();

      // look for state not in list -- specify default
      str = capitals.getProperty("Florida", "Not Found");
      System.out.println("The capital of Florida is "
          + str + ".");
   }
}

PropDemo.java

　　運行結果如下：

The capital of Missouri is Jefferson City.
The capital of Illinois is Springfield.
The capital of Indiana is Indianapolis.
The capital of California is Sacramento.
The capital of Washington is Olympia.

The capital of Florida is Not Found.

運行結果

2. Java集合框架

　　1）概述

　　集合框架是一個用來代表和操縱集合的統一架構。所有的集合框架都包含如下內容：

接口：是代表集合的抽象數據類型。接口允許集合獨立操縱其代表的細節。在面向對象的語言，接口通常形成一個層次。
實現（類）：是集合接口的具體實現。從本質上講，它們是可重復使用的數據結構。
算法：是實現集合接口的對象里的方法執行的一些有用的計算，例如：搜索和排序。這些算法被稱為多態，那是因為相同的方法可以在相似的接口上有着不同的實現。

　　除了集合，該框架也定義了幾個Map接口和類。Map里存儲的是鍵/值對。盡管Map不是collections，但是它們完全整合在集合中。

　　2）Java集合框架體系圖

Java集合框架體系圖

　　　3）集合接口及實現類

　　　　　　a)【接口】

　　　　　　　　集合接口有 Collection 接口， List 接口， Set， SortedSet， Map， Map.Entry， SortedMap， Enumeration 8種

　　　　　　b)【實現類(集合類)】

　　　　　　　　實現類有 AbstractCollection， ArrayList， HashSet， HashMap 等15中集合類

　　　4）迭代器遍歷集合

　　　　a)【概述】

　　　　　　通常情況下，你會希望遍歷一個集合中的元素。例如，顯示集合中的每個元素。

　　　　　　一般遍歷數組都是采用for循環或者增強for，這兩個方法也可以用在集合框架，但是還有一種方法是采用迭代器遍歷集合框架，它是一個對象，實現了Iterator 接口或ListIterator接口。

　　　　　　迭代器，使你能夠通過循環來得到或刪除集合的元素。ListIterator 繼承了Iterator，以允許雙向遍歷列表和修改元素。

　　　　b)【代碼示例】

public class Test{
 public static void main(String[] args) {
     List<String> list=new ArrayList<String>();
     list.add("Hello");
     list.add("World");
     list.add("HAHAHAHA");
     //第一種遍歷方法使用foreach遍歷List
     for (String str : list) {            //也可以改寫for(int i=0;i<list.size();i++)這種形式
        System.out.println(str);
     }
 
     //第二種遍歷，把鏈表變為數組相關的內容進行遍歷
     String[] strArray=new String[list.size()];
     list.toArray(strArray);
     for(int i=0;i<strArray.length;i++) //這里也可以改寫為  foreach(String str:strArray)這種形式
     {
        System.out.println(strArray[i]);
     }
     
    //第三種遍歷 使用迭代器進行相關遍歷
     
     Iterator<String> ite=list.iterator();
     while(ite.hasNext())//判斷下一個元素之后有值
     {
         System.out.println(ite.next());
     }
 }
}

遍歷 ArrayList

public class Test{
     public static void main(String[] args) {
      Map<String, String> map = new HashMap<String, String>();
      map.put("1", "value1");
      map.put("2", "value2");
      map.put("3", "value3");
      
      //第一種：普遍使用，二次取值
      System.out.println("通過Map.keySet遍歷key和value：");
      for (String key : map.keySet()) {
       System.out.println("key= "+ key + " and value= " + map.get(key));
      }
      
      //第二種
      System.out.println("通過Map.entrySet使用iterator遍歷key和value：");
      Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
      while (it.hasNext()) {
       Map.Entry<String, String> entry = it.next();
       System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
      }
      
      //第三種：推薦，尤其是容量大時
      System.out.println("通過Map.entrySet遍歷key和value");
      for (Map.Entry<String, String> entry : map.entrySet()) {
       System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
      }
    
      //第四種
      System.out.println("通過Map.values()遍歷所有的value，但不能遍歷key");
      for (String v : map.values()) {
       System.out.println("value= " + v);
      }
     }
}

遍歷 Map

　3. Java泛型

　　1）【概述】

　　　　Java 泛型（generics）是 JDK 5 中引入的一個新特性, 泛型提供了編譯時類型安全檢測機制，該機制允許程序員在編譯時檢測到非法的類型。泛型的本質是參數化類型，也就是說所操作的數據類型被指定為一個參數

　　　　可以參考：Java總結篇系列：Java泛型

　　2）【泛型方法】

　　　　你可以寫一個泛型方法，該方法在調用時可以接收不同類型的參數。根據傳遞給泛型方法的參數類型，編譯器適當地處理每一個方法調用。

　　　　下面是定義泛型方法的規則：

- 所有泛型方法聲明都有一個類型參數聲明部分（由尖括號分隔），該類型參數聲明部分在方法返回類型之前（在下面例子中的<E>）。
- 每一個類型參數聲明部分包含一個或多個類型參數，參數間用逗號隔開。一個泛型參數，也被稱為一個類型變量，是用於指定一個泛型類型名稱的標識符。
- 類型參數能被用來聲明返回值類型，並且能作為泛型方法得到的實際參數類型的占位符。
- 泛型方法體的聲明和其他方法一樣。注意類型參數只能代表引用型類型，不能是原始類型（像int,double,char的等）。

　　　　-- 代碼示例

public class GenericMethodTest
{
   // 泛型方法 printArray                         
   public static < E > void printArray( E[] inputArray )
   {
      // 輸出數組元素            
         for ( E element : inputArray ){        
            System.out.printf( "%s ", element );
         }
         System.out.println();
    }
 
    public static void main( String args[] )
    {
        // 創建不同類型數組： Integer, Double 和 Character
        Integer[] intArray = { 1, 2, 3, 4, 5 };
        Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
        Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };
 
        System.out.println( "整型數組元素為:" );
        printArray( intArray  ); // 傳遞一個整型數組
 
        System.out.println( "\n雙精度型數組元素為:" );
        printArray( doubleArray ); // 傳遞一個雙精度型數組
 
        System.out.println( "\n字符型數組元素為:" );
        printArray( charArray ); // 傳遞一個字符型數組
    } 
}

GenericMethodTest.java

　　　　編譯運行結果如下：

整型數組元素為:
1 2 3 4 5 

雙精度型數組元素為:
1.1 2.2 3.3 4.4 

字符型數組元素為:
H E L L O

編譯運行結果

　　3）【泛型類】

　　　　-- 代碼示例：

public class Box<T> {
   
  private T t;
 
  public void add(T t) {
    this.t = t;
  }
 
  public T get() {
    return t;
  }
 
  public static void main(String[] args) {
    Box<Integer> integerBox = new Box<Integer>();
    Box<String> stringBox = new Box<String>();
 
    integerBox.add(new Integer(10));
    stringBox.add(new String("菜鳥教程"));
 
    System.out.printf("整型值為 :%d\n\n", integerBox.get());
    System.out.printf("字符串為 :%s\n", stringBox.get());
  }
}

Box.java

編譯運行結果如下：

整型值為 :10

字符串為 :菜鳥教程

編譯運行結果

4. Java 序列化

　　1）【概述】

　　　　-- 【序列化和反序列化】Java 提供了一種對象序列化的機制，該機制中，一個對象可以被表示為一個字節序列，該字節序列包括該對象的數據、有關對象的類型的信息和存儲在對象中數據的類型。

　　　　將序列化對象寫入文件之后，可以從文件中讀取出來，並且對它進行反序列化，也就是說，對象的類型信息、對象的數據，還有對象中的數據類型可以用來在內存中新建對象。

　　　　-- 【序列化條件】請注意，一個類的對象要想序列化成功，必須滿足兩個條件：

　　　　　　該類必須實現 java.io.Serializable 對象。

　　　　　　該類的所有屬性必須是可序列化的。如果有一個屬性不是可序列化的，則該屬性必須注明是短暫的。

　　　　　　如果你想知道一個 Java 標准類是否是可序列化的，請查看該類的文檔。檢驗一個類的實例是否能序列化十分簡單，只需要查看該類有沒有實現 java.io.Serializable接口。

　　2）【代碼示例】

public class Employee implements java.io.Serializable
{
   public String name;
   public String address;
   public transient int SSN;
   public int number;
   public void mailCheck()
   {
      System.out.println("Mailing a check to " + name
                           + " " + address);
   }
}

Employee.java

import java.io.*;
 
public class SerializeDemo
{
   public static void main(String [] args)
   {
      Employee e = new Employee();
      e.name = "Reyan Ali";
      e.address = "Phokka Kuan, Ambehta Peer";
      e.SSN = 11122333;
      e.number = 101;
      try
      {
         FileOutputStream fileOut =
         new FileOutputStream("/tmp/employee.ser");
         ObjectOutputStream out = new ObjectOutputStream(fileOut);
         out.writeObject(e);
         out.close();
         fileOut.close();
         System.out.printf("Serialized data is saved in /tmp/employee.ser");
      }catch(IOException i)
      {
          i.printStackTrace();
      }
   }
}

序列化對象-SerializeDemo.java

import java.io.*;
 
public class DeserializeDemo
{
   public static void main(String [] args)
   {
      Employee e = null;
      try
      {
         FileInputStream fileIn = new FileInputStream("/tmp/employee.ser");
         ObjectInputStream in = new ObjectInputStream(fileIn);
         e = (Employee) in.readObject();
         in.close();
         fileIn.close();
      }catch(IOException i)
      {
         i.printStackTrace();
         return;
      }catch(ClassNotFoundException c)
      {
         System.out.println("Employee class not found");
         c.printStackTrace();
         return;
      }
      System.out.println("Deserialized Employee...");
      System.out.println("Name: " + e.name);
      System.out.println("Address: " + e.address);
      System.out.println("SSN: " + e.SSN);
      System.out.println("Number: " + e.number);
    }
}

反序列化對象--DeserializeDemo.java

Deserialized Employee...
Name: Reyan Ali
Address:Phokka Kuan, Ambehta Peer
SSN: 0
Number:101

編譯運行結果

5. Java網絡編程

　　1）【概述】

　　　　網絡編程是指編寫運行在多個設備（計算機）的程序，這些設備都通過網絡連接起來。

　　　　java.net 包中 J2SE 的 API 包含有類和接口，它們提供低層次的通信細節。你可以直接使用這些類和接口，來專注於解決問題，而不用關注通信細節。

　　　　java.net 包中提供了兩種常見的網絡協議的支持：

- 　　TCP：TCP 是傳輸控制協議的縮寫，它保障了兩個應用程序之間的可靠通信。通常用於互聯網協議，被稱 TCP / IP。
- 　　UDP：UDP 是用戶數據報協議的縮寫，一個無連接的協議。提供了應用程序之間要發送的數據的數據包。

　　2）【Socket 編程】

套接字使用TCP提供了兩台計算機之間的通信機制。客戶端程序創建一個套接字，並嘗試連接服務器的套接字。

當連接建立時，服務器會創建一個 Socket 對象。客戶端和服務器現在可以通過對 Socket 對象的寫入和讀取來進行進行通信。

java.net.Socket 類代表一個套接字，並且 java.net.ServerSocket 類為服務器程序提供了一種來監聽客戶端，並與他們建立連接的機制。

以下步驟在兩台計算機之間使用套接字建立TCP連接時會出現：

- - 服務器實例化一個 ServerSocket 對象，表示通過服務器上的端口通信。
  - 服務器調用 ServerSocket 類的 accept() 方法，該方法將一直等待，直到客戶端連接到服務器上給定的端口。
  - 服務器正在等待時，一個客戶端實例化一個 Socket 對象，指定服務器名稱和端口號來請求連接。
  - Socket 類的構造函數試圖將客戶端連接到指定的服務器和端口號。如果通信被建立，則在客戶端創建一個 Socket 對象能夠與服務器進行通信。
  - 在服務器端，accept() 方法返回服務器上一個新的 socket 引用，該 socket 連接到客戶端的 socket。

連接建立后，通過使用 I/O 流在進行通信，每一個socket都有一個輸出流和一個輸入流，客戶端的輸出流連接到服務器端的輸入流，而客戶端的輸入流連接到服務器端的輸出流。

TCP 是一個雙向的通信協議，因此數據可以通過兩個數據流在同一時間發送.以下是一些類提供的一套完整的有用的方法來實現 socket。

--【兩個類】

ServerSocket 類的方法：

　　服務器應用程序通過使用 java.net.ServerSocket 類以獲取一個端口,並且偵聽客戶端請求。它有4個構造方法

Socket 類的方法：

　　java.net.Socket 類代表客戶端和服務器都用來互相溝通的套接字。客戶端要獲取一個 Socket 對象通過實例化，而服務器獲得一個 Socket 對象則通過 accept() 方法的返回值。有5個構造方法

3）【代碼示例】

　　a)【Socket 客戶端實例】

　　　　如下的 GreetingClient 是一個客戶端程序，該程序通過 socket 連接到服務器並發送一個請求，然后等待一個響應。

// 文件名 GreetingClient.java
 
import java.net.*;
import java.io.*;
 
public class GreetingClient
{
   public static void main(String [] args)
   {
      String serverName = args[0];
      int port = Integer.parseInt(args[1]);
      try
      {
         System.out.println("Connecting to " + serverName
                             + " on port " + port);
         Socket client = new Socket(serverName, port);
         System.out.println("Just connected to "
                      + client.getRemoteSocketAddress());
         OutputStream outToServer = client.getOutputStream();
         DataOutputStream out =
                       new DataOutputStream(outToServer);
 
         out.writeUTF("Hello from "
                      + client.getLocalSocketAddress());
         InputStream inFromServer = client.getInputStream();
         DataInputStream in =
                        new DataInputStream(inFromServer);
         System.out.println("Server says " + in.readUTF());
         client.close();
      }catch(IOException e)
      {
         e.printStackTrace();
      }
   }
}

GreetingClient.java

// 文件名 GreetingServer.java
 
import java.net.*;
import java.io.*;
 
public class GreetingServer extends Thread
{
   private ServerSocket serverSocket;
   
   public GreetingServer(int port) throws IOException
   {
      serverSocket = new ServerSocket(port);
      serverSocket.setSoTimeout(10000);
   }
 
   public void run()
   {
      while(true)
      {
         try
         {
            System.out.println("Waiting for client on port " +
            serverSocket.getLocalPort() + "...");
            Socket server = serverSocket.accept();
            System.out.println("Just connected to "
                  + server.getRemoteSocketAddress());
            DataInputStream in =
                  new DataInputStream(server.getInputStream());
            System.out.println(in.readUTF());
            DataOutputStream out =
                 new DataOutputStream(server.getOutputStream());
            out.writeUTF("Thank you for connecting to "
              + server.getLocalSocketAddress() + "\nGoodbye!");
            server.close();
         }catch(SocketTimeoutException s)
         {
            System.out.println("Socket timed out!");
            break;
         }catch(IOException e)
         {
            e.printStackTrace();
            break;
         }
      }
   }
   public static void main(String [] args)
   {
      int port = Integer.parseInt(args[0]);
      try
      {
         Thread t = new GreetingServer(port);
         t.start();
      }catch(IOException e)
      {
         e.printStackTrace();
      }
   }
}

GreetingServer.java

　　　　c)【編譯及運行】

　　　　編譯以上兩個 java 文件代碼，並執行以下命令來啟動服務，使用端口號為 6066：

$ java GreetingServer 6066
Waiting for client on port 6066...

　　　　新開一個命令窗口，執行以上命令來開啟客戶端：

$ java GreetingClient localhost 6066
Connecting to localhost on port 6066
Just connected to localhost/127.0.0.1:6066
Server says Thank you for connecting to /127.0.0.1:6066
Goodbye!

6. Java發送Email

　　1）【概述】

　　　使用Java應用程序發送 E-mail 十分簡單，但是首先你應該在你的機器上安裝 JavaMail API 和Java Activation Framework (JAF)

- 您可以從 Java 網站下載最新版本的 JavaMail，打開網頁右側有個 Downloads 鏈接，點擊它下載。
- 您可以從 Java 網站下載最新版本的 JAF（版本 1.1.1）。

　　你也可以使用本站提供的下載鏈接：

- - JavaMail mail.jar 1.4.5
  - 　　JAF（版本 1.1.1） activation.jar

　　下載並解壓縮這些文件，在新創建的頂層目錄中，您會發現這兩個應用程序的一些 jar 文件。您需要把 mail.jar 和 activation.jar 文件添加到您的 CLASSPATH 中。

　　(java 命令行引用jar包的方法的整理)

　　如果你使用第三方郵件服務器如QQ的SMTP服務器，可查看文章底部用戶認證完整的實例。

　　2）【代碼示例】

　　　　發送帶有附件的郵件

// 文件名 SendFileEmail.java
 
import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;
 
public class SendFileEmail
{
   public static void main(String [] args)
   {
     
      // 收件人電子郵箱
      String to = "abcd@gmail.com";
 
      // 發件人電子郵箱
      String from = "web@gmail.com";
 
      // 指定發送郵件的主機為 localhost
      String host = "localhost";
 
      // 獲取系統屬性
      Properties properties = System.getProperties();
 
      // 設置郵件服務器
      properties.setProperty("mail.smtp.host", host);
 
      // 獲取默認的 Session 對象。
      Session session = Session.getDefaultInstance(properties);
 
      try{
         // 創建默認的 MimeMessage 對象。
         MimeMessage message = new MimeMessage(session);
 
         // Set From: 頭部頭字段
         message.setFrom(new InternetAddress(from));
 
         // Set To: 頭部頭字段
         message.addRecipient(Message.RecipientType.TO,
                                  new InternetAddress(to));
 
         // Set Subject: 頭字段
         message.setSubject("This is the Subject Line!");
 
         // 創建消息部分
         BodyPart messageBodyPart = new MimeBodyPart();
 
         // 消息
         messageBodyPart.setText("This is message body");
        
         // 創建多重消息
         Multipart multipart = new MimeMultipart();
 
         // 設置文本消息部分
         multipart.addBodyPart(messageBodyPart);
 
         // 附件部分
         messageBodyPart = new MimeBodyPart();
         String filename = "file.txt";
         DataSource source = new FileDataSource(filename);
         messageBodyPart.setDataHandler(new DataHandler(source));
         messageBodyPart.setFileName(filename);
         multipart.addBodyPart(messageBodyPart);
 
         // 發送完整消息
         message.setContent(multipart );
 
         //   發送消息
         Transport.send(message);
         System.out.println("Sent message successfully....");
      }catch (MessagingException mex) {
         mex.printStackTrace();
      }
   }
}

SendFileEmail.java

7. Java多線程編程

　　　　1）【概述】

　　　　　　Java 給多線程編程提供了內置的支持。一個多線程程序包含兩個或多個能並發運行的部分。程序的每一部分都稱作一個線程，並且每個線程定義了一個獨立的執行路徑。

　　　　　　多線程是多任務的一種特別的形式，但多線程使用了更小的資源開銷。

　　　　　　這里定義和線程相關的另一個術語 - 進程：一個進程包括由操作系統分配的內存空間，包含一個或多個線程。一個線程不能獨立的存在，它必須是進程的一部分。一個進程一直運行，　　　　　

　　　　　　直到所有的非守候線程都結束運行后才能結束。

　　　　　　多線程能滿足程序員編寫高效率的程序來達到充分利用 CPU 的目的。

　　　　2）【代碼示例】　　　　　

　　　　Java 提供了三種創建線程的方法：

- 通過實現 Runable 接口；
- 通過繼承 Thread類本身；
- 通過 Callable 和 Future 創建線程。

　　　　方法1：通過實現 Runnable 接口來創建線程

class RunnableDemo implements Runnable {
   private Thread t;
   private String threadName;
   
   RunnableDemo( String name) {
      threadName = name;
      System.out.println("Creating " +  threadName );
   }
   
   public void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // 讓線程睡眠一會
            Thread.sleep(50);
         }
      }catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }
   
   public void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}
 
public class TestThread {
 
   public static void main(String args[]) {
      RunnableDemo R1 = new RunnableDemo( "Thread-1");
      R1.start();
      
      RunnableDemo R2 = new RunnableDemo( "Thread-2");
      R2.start();
   }   
}

RunnableDemo.java

　　　　運行結果如下：

Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.

方法1運行結果

　　　　方法2：通過實現 Runnable 接口來創建線程

class RunnableDemo implements Runnable {
   private Thread t;
   private String threadName;
   
   RunnableDemo( String name) {
      threadName = name;
      System.out.println("Creating " +  threadName );
   }
   
   public void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // 讓線程睡眠一會
            Thread.sleep(50);
         }
      }catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }
   
   public void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}
 
public class TestThread {
 
   public static void main(String args[]) {
      RunnableDemo R1 = new RunnableDemo( "Thread-1");
      R1.start();
      
      RunnableDemo R2 = new RunnableDemo( "Thread-2");
      R2.start();
   }   
}

RunnableDemo.java

　　　　運行結果如下：

Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.

方法運行結果

　　　　方法3：通過 Callable 和 Future 創建線程

public class CallableThreadTest implements Callable<Integer> {
    public static void main(String[] args)  
    {  
        CallableThreadTest ctt = new CallableThreadTest();  
        FutureTask<Integer> ft = new FutureTask<>(ctt);  
        for(int i = 0;i < 100;i++)  
        {  
            System.out.println(Thread.currentThread().getName()+" 的循環變量i的值"+i);  
            if(i==20)  
            {  
                new Thread(ft,"有返回值的線程").start();  
            }  
        }  
        try  
        {  
            System.out.println("子線程的返回值："+ft.get());  
        } catch (InterruptedException e)  
        {  
            e.printStackTrace();  
        } catch (ExecutionException e)  
        {  
            e.printStackTrace();  
        }  
  
    }
    @Override  
    public Integer call() throws Exception  
    {  
        int i = 0;  
        for(;i<100;i++)  
        {  
            System.out.println(Thread.currentThread().getName()+" "+i);  
        }  
        return i;  
    }  
}

CallableThreadTest.java

8. Java Applet基礎

　　1）【概述】

　　　　1.1）基礎　　　　

　　　　Applet 是一種 Java 程序。它一般運行在支持 Java 的 Web 瀏覽器內。因為它有完整的 Java API支持,所以Applet 是一個全功能的 Java 應用程序。

如下所示是獨立的 Java 應用程序和 applet 程序之間重要的不同：

Java 中 Applet 類繼承了 java.applet.Applet 類。
Applet 類沒有定義 main()，所以一個 Applet 程序不會調用 main() 方法。
Applet 被設計為嵌入在一個 HTML 頁面。
當用戶瀏覽包含 Applet 的 HTML 頁面，Applet 的代碼就被下載到用戶的機器上。
要查看一個 Applet 需要 JVM。 JVM 可以是 Web 瀏覽器的一個插件，或一個獨立的運行時環境。
用戶機器上的 JVM 創建一個 Applet 類的實例，並調用 Applet 生命周期過程中的各種方法。
Applet 有 Web 瀏覽器強制執行的嚴格的安全規則，Applet 的安全機制被稱為沙箱安全。
Applet 需要的其他類可以用 Java 歸檔（JAR）文件的形式下載下來。

　　2）【代碼示例】

　　　　　　 2.1)【java源文件】HelloWorldApplet.java

import java.applet.*;
import java.awt.*;
 
public class HelloWorldApplet extends Applet
{
   public void paint (Graphics g)
   {
      g.drawString ("Hello World", 25, 50);
   }
}

HelloWorldApplet.java

　　　　　　2.2)【html調用applet】

<html>
<title>The Hello, World Applet</title>
<hr>
<applet code="HelloWorldApplet.class" width="320" height="120">
If your browser was Java-enabled, a "Hello, World"
message would appear here.
</applet>
<hr>
</html>

testApplet.html

　　　　　　2.3)【運行方式】　　　

　　　　　　　　2.3.1)命令行運行applet: https://zhidao.baidu.com/question/136902514.html

　　　　　　 appletviewer testApplet.html

　　　　　　　　2.3.2)下載瀏覽器支持的java : https://www.java.com/zh_CN/download/manual.jsp#mac

　　　　　　　　2.3.3) java被阻止時： https://java.com/zh_CN/download/help/jcp_security.xml

　　　　　　 — mac上java的控制面板的位置： https://java.com/zh_CN/download/help/mac_controlpanel.xml

　9. Java MySQ連接

　　1）【概述】

　　　　Java 連接 MySQL 需要驅動包，最新版下載地址為：http://dev.mysql.com/downloads/connector/j/，解壓后得到jar庫文件，然后在對應的項目中導入該庫文件。

　　　　你可以下載本站提供的 jar 包：mysql-connector-java-5.1.39-bin.jar

　　2）【代碼示例】

package com.runoob.test;
 
import java.sql.*;
 
public class MySQLDemo {
 
    // JDBC 驅動名及數據庫 URL
    static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";  
    static final String DB_URL = "jdbc:mysql://localhost:3306/RUNOOB";
 
    // 數據庫的用戶名與密碼，需要根據自己的設置
    static final String USER = "root";
    static final String PASS = "123456";
 
    public static void main(String[] args) {
        Connection conn = null;
        Statement stmt = null;
        try{
            // 注冊 JDBC 驅動
            Class.forName("com.mysql.jdbc.Driver");
        
            // 打開鏈接
            System.out.println("連接數據庫...");
            conn = DriverManager.getConnection(DB_URL,USER,PASS);
        
            // 執行查詢
            System.out.println(" 實例化Statement對...");
            stmt = conn.createStatement();
            String sql;
            sql = "SELECT id, name, url FROM websites";
            ResultSet rs = stmt.executeQuery(sql);
        
            // 展開結果集數據庫
            while(rs.next()){
                // 通過字段檢索
                int id  = rs.getInt("id");
                String name = rs.getString("name");
                String url = rs.getString("url");
    
                // 輸出數據
                System.out.print("ID: " + id);
                System.out.print(", 站點名稱: " + name);
                System.out.print(", 站點 URL: " + url);
                System.out.print("\n");
            }
            // 完成后關閉
            rs.close();
            stmt.close();
            conn.close();
        }catch(SQLException se){
            // 處理 JDBC 錯誤
            se.printStackTrace();
        }catch(Exception e){
            // 處理 Class.forName 錯誤
            e.printStackTrace();
        }finally{
            // 關閉資源
            try{
                if(stmt!=null) stmt.close();
            }catch(SQLException se2){
            }// 什么都不做
            try{
                if(conn!=null) conn.close();
            }catch(SQLException se){
                se.printStackTrace();
            }
        }
        System.out.println("Goodbye!");
    }
}

MySQLDemo.java

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 Java高級教程 Java高級教程02 Java 高級編程學習路線 java框架學習系列 Java NIO系列教程（七） FileChannel Java NIO系列教程（一） Java NIO 概述我對java這門課的認識 Java NIO學習系列一：Buffer Java NIO學習系列二：Channel Java NIO學習系列三：Selector