【Java】經典示例程式碼

成鵬致遠 | lcw.cnblogs.com | 2014-02-08

 單例設計模式

class Singleton{
    private static Singleton instance = new Singleton() ;    // 在內部產生本類的例項化物件
    public static Singleton getInstance(){        // 通過靜態方法取得instance物件
        return instance ;
    }
    private Singleton(){        // 將構造方法進行了封裝，私有化    
    }
    public void print(){
        System.out.println("Hello World!!!") ;
    }
};
public class SingletonDemo05{
    public static void main(String args[]){
        Singleton s1 = null ;    // 宣告物件
        Singleton s2 = null ;    // 宣告物件
        Singleton s3 = null ;    // 宣告物件
        s1 = Singleton.getInstance() ;    // 取得例項化物件
        s2 = Singleton.getInstance() ;    // 取得例項化物件
        s3 = Singleton.getInstance() ;    // 取得例項化物件
        s1.print() ;        // 呼叫方法
        s2.print() ;        // 呼叫方法
        s3.print() ;        // 呼叫方法
    }
};

 代理設計模式

interface Network{
    public void browse() ;    // 瀏覽
}
class Real implements Network{
    public void browse(){
        System.out.println("上網瀏覽資訊") ;
    }
};
class Proxy implements Network{
    private Network network ;    // 代理物件
    public Proxy(Network network){
        this.network = network ;
    }
    public void check(){
        System.out.println("檢查使用者是否合法。") ;
    }
    public void browse(){
        this.check() ;
        this.network.browse() ;    // 呼叫真實的主題操作
    }
};
public class ProxyDemo{
    public static void main(String args[]){
        Network net = null ;
        net  = new Proxy(new Real()) ;//  指定代理操作
        net.browse() ;    // 客戶只關心上網瀏覽一個操作
    }
};

 動態代理設計模式（反射實現）

import java.lang.reflect.InvocationHandler ;
import java.lang.reflect.Proxy ;
import java.lang.reflect.Method ;
interface Subject{
    public String say(String name,int age) ;    // 定義抽象方法say
}
class RealSubject implements Subject{    // 實現介面
    public String say(String name,int age){
        return "姓名：" + name + "，年齡：" + age ;
    }
};
class MyInvocationHandler implements InvocationHandler{
    private Object obj ;
    public Object bind(Object obj){
        this.obj = obj ;    // 真實主題類
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),this) ;
    }
    public Object invoke(Object proxy,Method method,Object[] args) throws Throwable{
        Object temp = method.invoke(this.obj,args) ;    // 呼叫方法
        return temp ;
    }
};
public class DynaProxyDemo{
    public static void main(String args[]){
        Subject sub = (Subject)new MyInvocationHandler().bind(new RealSubject()) ;
        String info = sub.say("成鵬致遠",2) ;
        System.out.println(info) ;
    }
};

工廠設計模式

interface Fruit{    // 定義一個水果介面
    public void eat() ;    // 吃水果
}
class Apple implements Fruit{
    public void eat(){
        System.out.println("** 吃蘋果。") ;
    }
};
class Orange implements Fruit{
    public void eat(){
        System.out.println("** 吃橘子。") ;
    }
};
class Factory{    // 定義工廠類
    public static Fruit getInstance(String className){
        Fruit f = null ;
        if("apple".equals(className)){    // 判斷是否要的是蘋果的子類
            f = new Apple() ;
        }
        if("orange".equals(className)){    // 判斷是否要的是橘子的子類
            f = new Orange() ;
        }
        return f ;
    }
};
public class InterfaceCaseDemo05{
    public static void main(String args[]){
        Fruit f = Factory.getInstance(args[0]) ;    // 例項化介面
        if(f!=null){    // 判斷是否取得例項
            f.eat() ;
        }
    }
};

 

高階工廠設計模式（反射實現）

import java.util.Properties ;
import java.io.File ;
import java.io.FileOutputStream ;
import java.io.FileInputStream ;
interface Fruit{
    public void eat() ;    // 吃水果
}
class Apple implements Fruit{
    public void eat(){            // 覆寫eat()方法
        System.out.println("** 吃蘋果");
    }
};
class Orange implements Fruit{
    public void eat(){
        System.out.println("** 吃橘子") ;
    }
};
class Init{
    public static Properties getPro(){
        Properties pro = new Properties() ;
        File f = new File("d:\\fruit.properties") ;    // 找到屬性檔案
        try{
            if(f.exists()){    // 檔案存在
                pro.load(new FileInputStream(f)) ;    // 讀取屬性
            }else{
                pro.setProperty("apple","org.lcw.factorydemo.Apple") ;
                pro.setProperty("orange","org.lcw.factorydemo.Orange") ;
                pro.store(new FileOutputStream(f),"FRUIT CLASS") ;
            }
        }catch(Exception e){}
        return pro ;
    }
};
class Factory{
    public static Fruit getInstance(String className){
        Fruit fruit = null ;
        try{
            fruit = (Fruit)Class.forName(className).newInstance() ;
        }catch(Exception e){
            e.printStackTrace() ;
        }
        return fruit ;
    }
};
public class FactoryDemo{
    public static void main(String args[]){
        Properties pro = Init.getPro() ;
        Fruit f = Factory.getInstance(pro.getProperty("apple")) ;
        if(f!=null){
            f.eat() ;
        }
    }
};

介面卡設計模式

interface Window{        // 定義Window介面，表示視窗操作
    public void open() ;    // 開啟
    public void close() ;    // 關閉
    public void activated() ;    // 視窗活動
    public void iconified() ;    // 視窗最小化
    public void deiconified();// 視窗恢復大小
}
abstract class WindowAdapter implements Window{
    public void open(){} ;    // 開啟
    public void close(){} ;    // 關閉
    public void activated(){} ;    // 視窗活動
    public void iconified(){} ;    // 視窗最小化
    public void deiconified(){};// 視窗恢復大小
};
class WindowImpl extends WindowAdapter{
    public void open(){
        System.out.println("視窗開啟。") ;
    }
    public void close(){
        System.out.println("視窗關閉。") ;
    }
};
public class AdapterDemo{
    public static void main(String args[]){
        Window win = new WindowImpl() ;
        win.open() ;
        win.close() ;
    }
};

觀察者設計模式

import java.util.* ;
class House extends Observable{    // 表示房子可以被觀察
    private float price ;// 價錢
    public House(float price){
        this.price = price ;
    }
    public float getPrice(){
        return this.price ;
    }
    public void setPrice(float price){
        // 每一次修改的時候都應該引起觀察者的注意
        super.setChanged() ;    // 設定變化點
        super.notifyObservers(price) ;// 價格被改變
        this.price = price ;
    }
    public String toString(){
        return "房子價格為：" + this.price ;
    }
}; 
class HousePriceObserver implements Observer{
    private String name ;
    public HousePriceObserver(String name){    // 設定每一個購房者的名字
        this.name = name ;
    }
    public void update(Observable o,Object arg){
        if(arg instanceof Float){
            System.out.print(this.name + "觀察到價格更改為：") ;
            System.out.println(((Float)arg).floatValue()) ;
        }
    }
};
public class ObserDemo01{
    public static void main(String args[]){
        House h = new House(1000000) ;
        HousePriceObserver hpo1 = new HousePriceObserver("購房者A") ;
        HousePriceObserver hpo2 = new HousePriceObserver("購房者B") ;
        HousePriceObserver hpo3 = new HousePriceObserver("購房者C") ;
        h.addObserver(hpo1) ;
        h.addObserver(hpo2) ;
        h.addObserver(hpo3) ;
        System.out.println(h) ;    // 輸出房子價格
        h.setPrice(666666) ;    // 修改房子價格
        System.out.println(h) ;    // 輸出房子價格
    }
};

反射獲取類中方法

import java.lang.reflect.Method ;    // 匯入構造方法的包
import java.lang.reflect.Modifier ;    // 匯入構造方法的包
public class TestJava{
    public static void main(String args[]){
        Class<?> c1 = null ;        // 宣告Class物件
        try{
            c1 = Class.forName("java.lang.Math") ;    // 例項化物件
        }catch(ClassNotFoundException e){
            e.printStackTrace() ;
        }
        Method m[] = c1.getMethods() ;    // 取得全部方法
        for(int i=0;i<m.length;i++){
            Class<?> r = m[i].getReturnType() ;    // 得到返回值型別
            Class<?> p[] = m[i].getParameterTypes() ;    // 取得全部引數的型別
            int xx = m[i].getModifiers() ;    // 得到修飾符
            System.out.print(Modifier.toString(xx) + " ") ;    // 輸出修飾符
            System.out.print(r + " ") ;
            System.out.print(m[i].getName()) ;
            System.out.print("(") ;
            for(int j=0;j<p.length;j++){
                System.out.print(p[j].getName() + " " + "arg" + j) ;
                if(j<p.length-1){
                    System.out.print(",") ;
                }
            }
            Class<?> ex[] = m[i].getExceptionTypes() ;    // 取出異常
            if(ex.length>0){
                System.out.print(") throws ") ;
            }else{
                System.out.print(")") ;
            }
            for(int j=0;j<ex.length;j++){
                System.out.print(ex[j].getName()) ;
                if(j<p.length-1){
                    System.out.print(",") ;
                }
            }
            System.out.println() ;
        }
    }
};

反射獲取類中屬性

import java.lang.reflect.Field ;    // 匯入構造方法的包
import java.lang.reflect.Modifier ;    // 匯入構造方法的包
public class TestJava{
    public static void main(String args[]){
        Class<?> c1 = null ;        // 宣告Class物件
        try{
            c1 = Class.forName("java.lang.Math") ;    // 例項化物件
        }catch(ClassNotFoundException e){
            e.printStackTrace() ;
        }
        {    // 本類屬性
            Field f[] = c1.getDeclaredFields() ;    // 取得本類中的屬性
            for(int i=0;i<f.length;i++){
                Class<?> r = f[i].getType() ;    // 得到屬性型別
                int mo = f[i].getModifiers() ;    // 得到修飾符的數字
                String priv = Modifier.toString(mo) ; // 還原修飾符
                System.out.print("本類屬性：") ;
                System.out.print(priv + " ") ;    
                System.out.print(r.getName() + " ") ;    // 得到屬性型別
                System.out.print(f[i].getName()) ;    // 輸出屬性名稱
                System.out.println(" ;") ;
            }
        }
        {    // 公共屬性
            Field f[] = c1.getFields() ;    // 取得本類中的公共屬性
            for(int i=0;i<f.length;i++){
                Class<?> r = f[i].getType() ;    // 得到屬性型別
                int mo = f[i].getModifiers() ;    // 得到修飾符的數字
                String priv = Modifier.toString(mo) ; // 還原修飾符
                System.out.print("公共屬性：") ;
                System.out.print(priv + " ") ;    
                System.out.print(r.getName() + " ") ;    // 得到屬性型別
                System.out.print(f[i].getName()) ;    // 輸出屬性名稱
                System.out.println(" ;") ;
            }
        }
    }
};

反射修改類中屬性

import java.lang.reflect.Field ;
public class InvokeFieldDemo{
    public static void main(String args[]) throws Exception{
        Class<?> c1 = null ;
        Object obj = null ;
        c1 = Class.forName("org.lcw.invoke.Person") ;    // 例項化Class物件
        obj = c1.newInstance() ;
        Field nameField = null ;
        Field ageField = null ;
        nameField = c1.getDeclaredField("name") ;    // 取得name屬性
        ageField = c1.getDeclaredField("age") ;    // 取得name屬性
        nameField.setAccessible(true) ;    // 此屬性對外部可見
        ageField.setAccessible(true) ;    // 此屬性對外部可見
        nameField.set(obj,"成鵬致遠") ;    // 設定name屬性內容
        ageField.set(obj,2) ;            // 設定age屬性內容
        System.out.println("姓名：" + nameField.get(obj)) ;
        System.out.println("年齡：" + ageField.get(obj)) ;
    }
};

/*
package org.lcw.invoke ;
public class Person
    private String name ;
    private int age ;
    public Person(){    // 無參構造
    }
    public Person(String name,int age){
        this(name) ;
        this.age = age ;
    }
    public void setName(String name){
        this.name = name ;
    }
    public void setAge(int age){
        this.age = age ;
    }
    public String getName(){
        return this.name ;
    }
    public int getAge(){
        return this.age ;
    }
};
*/

反射Setter修改類中屬性

import java.lang.reflect.Method ;
public class InvokeSetGet{
    public static void main(String args[]){
        Class<?> c1 = null ;
        Object obj = null ;
        try{
            c1 = Class.forName("org.lcw.invoke.Person") ;    // 例項化Class物件
        }catch(Exception e){}
        try{
            obj = c1.newInstance() ;
        }catch(Exception e){}
        setter(obj,"name","成鵬致遠",String.class) ;    // 呼叫setter方法
        setter(obj,"age",2,int.class) ;    // 呼叫setter方法
        System.out.print("姓名：") ;
        getter(obj,"name") ;
        System.out.print("年齡：") ;
        getter(obj,"age");
    }
    /**
        Object obj：要操作的物件
        String att：要操作的屬性
        Object value：要設定的屬性內容
        Class<?> type：要設定的屬性型別
    */
    public static void setter(Object obj,String att,Object value,Class<?> type){
        try{
            Method met = obj.getClass().getMethod("set"+initStr(att),type) ;    // 得到setter方法
            met.invoke(obj,value) ;    // 設定setter的內容
        }catch(Exception e){
            e.printStackTrace() ;
        }
    }
    public static void getter(Object obj,String att){
        try{
            Method met = obj.getClass().getMethod("get"+initStr(att)) ;    // 得到setter方法
            System.out.println(met.invoke(obj)) ;    // 呼叫getter取得內容
        }catch(Exception e){
            e.printStackTrace() ;
        }
    }
    public static String initStr(String old){    // 將單詞的首字母大寫
        String str = old.substring(0,1).toUpperCase() + old.substring(1) ;
        return str ;
    }
};

/*
package org.lcw.invoke ;
public class Person
    private String name ;
    private int age ;
    public Person(){    // 無參構造
    }
    public Person(String name,int age){
        this(name) ;
        this.age = age ;
    }
    public void setName(String name){
        this.name = name ;
    }
    public void setAge(int age){
        this.age = age ;
    }
    public String getName(){
        return this.name ;
    }
    public int getAge(){
        return this.age ;
    }
};
*/

經典二叉樹排序演算法

class BinaryTree
{
    class Node
    { // 宣告一個節點類
        private Comparable data; // 儲存具體的內容
        private Node left; // 儲存左子樹
        private Node right; // 儲存右子樹

        public Node(Comparable data)
        {
            this.data = data;
        }

        public void addNode(Node newNode)
        {
            // 確定是放在左子樹還是右子樹
            if (newNode.data.compareTo(this.data) < 0)
            { // 內容小，放在左子樹
                if (this.left == null)
                {
                    this.left = newNode; // 直接將新的節點設定成左子樹
                }
                else
                {
                    this.left.addNode(newNode); // 繼續向下判斷
                }
            }
            if (newNode.data.compareTo(this.data) >= 0)
            { // 放在右子樹
                if (this.right == null)
                {
                    this.right = newNode; // 沒有右子樹則將此節點設定成右子樹
                }
                else
                {
                    this.right.addNode(newNode); // 繼續向下判斷
                }
            }
        }

        public void printNode()
        { // 輸出的時候採用中序遍歷
            if (this.left != null)
            {
                this.left.printNode(); // 輸出左子樹
            }
            System.out.print(this.data + "\t");
            if (this.right != null)
            {
                this.right.printNode();
            }
        }
    };

    private Node root; // 根元素

    public void add(Comparable data)
    { // 加入元素
        Node newNode = new Node(data); // 定義新的節點
        if (root == null)
        { // 沒有根節點
            root = newNode; // 第一個元素作為根節點
        }
        else
        {
            root.addNode(newNode); // 確定是放在左子樹還是放在右子樹
        }
    }

    public void print()
    {
        this.root.printNode(); // 通過根節點輸出
    }
};

public class ComparableDemo03
{
    public static void main(String args[])
    {
        BinaryTree bt = new BinaryTree();
        bt.add(8);
        bt.add(3);
        bt.add(3);
        bt.add(10);
        bt.add(9);
        bt.add(1);
        bt.add(5);
        bt.add(5);
        System.out.println("排序之後的結果：");
        bt.print();
    }
};

經典連結串列操作演算法

class Link{        // 連結串列的完成類
    class Node{    // 儲存每一個節點，此處為了方便直接定義成內部類
        private String data ;    // 儲存節點的內容
        private Node next ;        // 儲存下一個節點
        public Node(String data){
            this.data = data ;        // 通過構造方法設定節點內容
        }
        public void add(Node newNode){        // 將節點加入到合適的位置
            if(this.next==null){            // 如果下一個節點為空，則把新節點設定在next的位置上
                this.next = newNode ;
            }else{        // 如果不為空，則需要向下繼續找next
                this.next.add(newNode) ;
            }
        }
        public void print(){
            System.out.print(this.data + "\t") ;    // 輸出節點內容
            if(this.next!=null){        // 還有下一個元素，需要繼續輸出
                this.next.print() ;    // 下一個節點繼續呼叫print
            }
        }
        public boolean search(String data){    // 內部搜尋的方法
            if(data.equals(this.data)){        // 判斷輸入的資料是否和當前節點的資料一致
                return true ;
            }else{    // 向下繼續判斷
                if(this.next!=null){    // 下一個節點如果存在，則繼續查詢
                    return this.next.search(data) ;    // 返回下一個的查詢結果
                }else{
                    return false ;        // 如果所有的節點都查詢完之後，沒有內容相等，則返回false
                }
            }
        }
        public void delete(Node previous,String data){
            if(data.equals(this.data)){    // 找到了匹配的節點
                previous.next = this.next ;    // 空出當前的節點
            }else{
                if(this.next!=null){    // 還是存在下一個節點
                    this.next.delete(this,data) ;    // 繼續查詢
                }
            }
        }
    };
    private Node root ;        // 連結串列中必然存在一個根節點
    public void addNode(String data){    // 增加節點
        Node newNode = new Node(data) ;    // 定義新的節點
        if(this.root==null){            // 沒有根節點
            this.root = newNode ;    // 將第一個節點設定成根節點
        }else{        // 不是根節點，放到最後一個節點之後
            this.root.add(newNode) ;    // 通過Node自動安排此節點放的位置
        }
    }
    public void printNode(){        // 輸出全部的連結串列內容
        if(this.root!=null){        // 如果根元素不為空
            this.root.print() ;    // 呼叫Node類中的輸出操作
        }
    }
    public boolean contains(String name){    // 判斷元素是否存在
        return this.root.search(name) ;    // 呼叫Node類中的查詢方法
    }
    public void deleteNode(String data){        // 刪除節點
        if(this.contains(data)){    // 判斷節點是否存在
            // 一定要判斷此元素現在是不是根元素相等的
            if(this.root.data.equals(data)){    // 內容是根節點
                this.root = this.root.next ;    // 修改根節點，將第一個節點設定成根節點
            }else{
                this.root.next.delete(root,data) ;    // 把下一個節點的前節點和資料一起傳入進去
            }
        }
    }
};
public class LinkDemo02{
    public static void main(String args[]){
        Link l = new Link() ;
        l.addNode("A") ;        // 增加節點
        l.addNode("B") ;        // 增加節點
        l.addNode("C") ;        // 增加節點
        l.addNode("D") ;        // 增加節點
        l.addNode("E") ;        // 增加節點
        System.out.println("======= 刪除之前 ========") ;
        l.printNode() ;
        // System.out.println(l.contains("X")) ;
        l.deleteNode("C") ;        // 刪除節點
        l.deleteNode("D") ;        // 刪除節點
        l.deleteNode("A") ;        // 刪除節點
        System.out.println("\n====== 刪除之後 =========") ;
        l.printNode() ;
        System.out.println("\n查詢節點：" + l.contains("B")) ;
    }
};

經典生產者與消費者演算法（多執行緒同步互斥）

class Info
{ // 定義資訊類
    private String name = "成鵬致遠"; // 定義name屬性
    private String content = "學生"; // 定義content屬性
    private boolean flag = false; // 設定標誌位

    public synchronized void set(String name, String content)
    {
        if (!flag)
        {
            try
            {
                super.wait();
            } catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
        this.setName(name); // 設定名稱
        try
        {
            Thread.sleep(300);
        } catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        this.setContent(content); // 設定內容
        flag = false; // 改變標誌位，表示可以取走
        super.notify();
    }

    public synchronized void get()
    {
        if (flag)
        {
            try
            {
                super.wait();
            } catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
        try
        {
            Thread.sleep(300);
        } catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        System.out.println(this.getName() + " --> " + this.getContent());
        flag = true; // 改變標誌位，表示可以生產
        super.notify();
    }

    public void setName(String name)
    {
        this.name = name;
    }

    public void setContent(String content)
    {
        this.content = content;
    }

    public String getName()
    {
        return this.name;
    }

    public String getContent()
    {
        return this.content;
    }
};

class Producer implements Runnable
{ // 通過Runnable實現多執行緒
    private Info info = null; // 儲存Info引用

    public Producer(Info info)
    {
        this.info = info;
    }

    public void run()
    {
        boolean flag = false; // 定義標記位
        for (int i = 0; i < 50; i++)
        {
            if (flag)
            {
                this.info.set("個人部落格", "http://lcw.cnblogs.com"); // 設定名稱
                flag = false;
            }
            else
            {
                this.info.set("個人網站", "http://infodown.tap.cn"); // 設定名稱
                flag = true;
            }
        }
    }
};

class Consumer implements Runnable
{
    private Info info = null;

    public Consumer(Info info)
    {
        this.info = info;
    }

    public void run()
    {
        for (int i = 0; i < 50; i++)
        {
            this.info.get();
        }
    }
};

public class Test_Format
{
    public static void main(String args[])
    {
        Info info = new Info(); // 例項化Info物件
        Producer pro = new Producer(info); // 生產者
        Consumer con = new Consumer(info); // 消費者
        new Thread(pro).start();
        new Thread(con).start();
    }
};

String對正規表示式的支援

import java.util.regex.Pattern ;
import java.util.regex.Matcher ;
public class RegexDemo06{
    public static void main(String args[]){
        String str1 = "A1B22C333D4444E55555F".replaceAll("\\d+","_") ;
        boolean temp = "1983-07-27".matches("\\d{4}-\\d{2}-\\d{2}") ;
        String s[] = "A1B22C333D4444E55555F".split("\\d+") ;
        System.out.println("字串替換操作：" + str1) ;
        System.out.println("字串驗證：" + temp) ;
        System.out.print("字串的拆分：") ;
        for(int x=0;x<s.length;x++){
            System.out.print(s[x] + "\t") ;
        }
    }
};

程式碼塊說明

class Demo{
    {    // 直接在類中編寫程式碼塊，稱為構造塊
        System.out.println("1、構造塊。") ;
    }
    static{    // 使用static，稱為靜態程式碼塊
        System.out.println("0、靜態程式碼塊") ;
    }
    public Demo(){    // 定義構造方法
        System.out.println("2、構造方法。") ;
    }
};
public class CodeDemo03{
    static{        // 在主方法所在的類中定義靜態塊
        System.out.println("在主方法所在類中定義的程式碼塊") ;
    }
    public static void main(String args[]){
        new Demo() ;        // 例項化物件
        new Demo() ;        // 例項化物件
        new Demo() ;        // 例項化物件
    }
};

取得當前時間最簡便演算法

import java.util.*; // 匯入需要的工具包
import java.text.*; // 匯入SimpleDateFormat所在的包

class DateTime
{ // 以後直接通過此類就可以取得日期時間
    private SimpleDateFormat sdf = null; // 宣告SimpleDateFormat物件

    public String getDate()
    { // 得到的是一個日期：格式為：yyyy-MM-dd HH:mm:ss.SSS
        this.sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
        return this.sdf.format(new Date());// 將當前日期進行格式化操作
    }

    public String getDateComplete()
    { // 得到的是一個日期：格式為：yyyy年MM月dd日 HH時mm分ss秒SSS毫秒
        this.sdf = new SimpleDateFormat("yyyy年MM月dd日HH時mm分ss秒SSS毫秒");
        return this.sdf.format(new Date());// 將當前日期進行格式化操作
    }

    public String getTimeStamp()
    { // 得到的是一個時間戳
        this.sdf = new SimpleDateFormat("yyyyMMddHHmmssSSS");
        return this.sdf.format(new Date());// 將當前日期進行格式化操作
    }
};

public class DateDemo07
{
    public static void main(String args[])
    {
        DateTime dt = new DateTime();
        System.out.println("系統日期：" + dt.getDate());
        System.out.println("中文日期：" + dt.getDateComplete());
        System.out.println("時間戳：" + dt.getTimeStamp());
    }
};

位元組流檔案拷貝演算法

import java.io.* ;
public class Copy{
    public static void main(String args[]){
        if(args.length!=2){        // 判斷是否是兩個引數
            System.out.println("輸入的引數不正確。") ;
            System.out.println("例：java Copy 原始檔路徑 目標檔案路徑") ;
            System.exit(1) ;    // 系統退出
        }
        File f1 = new File(args[0]) ;    // 原始檔的File物件
        File f2 = new File(args[1]) ;    // 目標檔案的File物件
        if(!f1.exists()){
            System.out.println("原始檔不存在！") ;
            System.exit(1) ;
        }
        InputStream input = null ;        // 準備好輸入流物件，讀取原始檔
        OutputStream out = null ;        // 準備好輸出流物件，寫入目標檔案
        try{
            input = new FileInputStream(f1) ;
        }catch(FileNotFoundException e){
            e.printStackTrace() ;
        }
        try{
            out = new FileOutputStream(f2) ;
        }catch(FileNotFoundException e){
            e.printStackTrace() ;
        }
        if(input!=null && out!=null){    // 判斷輸入或輸出是否準備好
            int temp = 0 ;    
            try{
                while((temp=input.read())!=-1){    // 開始拷貝
                    out.write(temp) ;    // 邊讀邊寫
                }
                System.out.println("拷貝完成！") ;
            }catch(IOException e){
                e.printStackTrace() ;
                System.out.println("拷貝失敗！") ;
            }
            try{
                input.close() ;        // 關閉
                out.close() ;        // 關閉
            }catch(IOException e){
                e.printStackTrace() ;
            }
        }
    }    
}

選單選擇類設計方法

public class Menu{
    public Menu(){
        while(true){
            this.show() ;        // 無限制呼叫選單的顯示
        }
    }
    public void show(){
        System.out.println("===== Xxx系統 =====") ;
        System.out.println("    [1]、增加資料") ;
        System.out.println("    [2]、刪除資料") ;
        System.out.println("    [3]、修改資料") ;
        System.out.println("    [4]、檢視資料") ;
        System.out.println("    [0]、系統退出\n") ;
        InputData input = new InputData() ;
        int i = input.getInt("請選擇：","請輸入正確的選項！") ;
        switch(i){
            case 1:{
                Operate.add() ;        // 呼叫增加操作
                break ;
            }
            case 2:{
                Operate.delete() ;    // 呼叫刪除操作
                break ;
            }
            case 3:{
                Operate.update() ;    // 呼叫更新操作
                break ;
            }
            case 4:{
                Operate.find() ;        // 呼叫檢視操作
                break ;
            }
            case 0:{
                System.exit(1) ;        // 系統退出
                break ;
            }
            default:{
                System.out.println("請選擇正確的操作！") ;
            }
        }
    }
};

列出指定目錄所有檔案方法

import java.io.File ;
import java.io.IOException ;
public class FileDemo11{
    public static void main(String args[]){
        File my = new File("d:" + File.separator) ;    // 操作路徑
        print(my) ;
    }
    public static void print(File file){    // 遞迴呼叫
        if(file!=null){    // 判斷物件是否為空
            if(file.isDirectory()){    // 如果是目錄
                File f[] = file.listFiles() ;    // 列出全部的檔案
                if(f!=null){    // 判斷此目錄能否列出
                    for(int i=0;i<f.length;i++){
                        print(f[i]) ;    // 因為給的路徑有可能是目錄，所以，繼續判斷
                    }
                }
            }else{
                System.out.println(file) ;    // 輸出路徑
            }
        }
    }
};