【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) ;    // 输出路径
            }
        }
    }
};