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集合框架体系图

　　　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

码农公寓

相关文章