注：本文为原创文章，转载时请注明转载地址。

     前几天整理自己的程序的时候，发现了一个还未完成的连连看程序，该游戏是去年这个时候左右写的，后来工作一忙就把它给忘了。以前比较喜欢玩游戏，慢慢的玩烦了就想自己写些东西，由于我的工作主要是基于J2EE的开发，所以平时也只能利用业余的空闲时间写些小游戏。

      这几天利用晚上的时间进行了一些完善，由于时间的关系游戏只设置了3关分别是：不移动、下移和左移，有兴趣的朋友可以很容易根据自己的需要再增加，包括每关的图片都可以很容易的自定义，直接将自己的图片拷贝到指定的文件夹下即可。下面是游戏的抓图和简单的操作视频：

以下是简单的操作视频，上传到6room后都给压缩的看不清了，希望javaeye的网站能支持上传一些简单的操作视频，现在很多国外的网站都支持。

代码下载[注：本程序属个人原创作品，在进行传播时请保留代码中的版权信息]

[连连看源码下载]

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师

• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 北京: 千橡集团暨校内网诚聘软件研发工程师

注：本文为原创文章，转载时请注明转载地址。

所谓系统级热键就是指一组快捷键，不论当前系统焦点在哪个程序中，只要按下该键，程序就能够捕捉该事件并进行相关处理。该功能在应用程序中是非常有用的，比如系统自带的
“win+L”自动锁屏，QQ中默认的“ctrl+alt+Z”自动打开当前的消息窗口等等。

Java中的事件监听机制虽然功能强大，但是当系统焦点脱离该程序时也无能为力。要实现该功能必须调用系统的钩子函数，因此在java中也必须通过jni调用来实现，但是对于不熟悉系统函数或者其他编成语言的朋友来说却是个难题。

以前实现类似的功能都是自己通过c调用系统的钩子函数然后再通过jni调用，自己写的东西只要能满足简单的需求即可，因此功能和程序结构也比较简单。后来在国外的一个网站上发现了一个组件“jintellitype”帮我们封装了绝大部分的功能，而且结构上也采用java中的事件监听机制，我们只要在程序中通过注册即可实现，下面是一个简单的例子：

import com.melloware.jintellitype.HotkeyListener;
import com.melloware.jintellitype.JIntellitype;

public class HotKey implements HotkeyListener {
    static final int KEY_1 = 88;
    static final int KEY_2 = 89;
    static final int KEY_3 = 90;

    /**
     * 该方法负责监听注册的系统热键事件
     *
     * @param key:触发的热键标识
     */
    public void onHotKey(int key) {
        switch (key) {
            case KEY_1:
                System.out.println("ctrl+alt+I 按下.........");
                break;
            case KEY_2:
                System.out.println("ctrl+alt+O 按下.........");
                break;
            case KEY_3:
                System.out.println("系统退出..........");
                destroy();
        }

    }


    /**
     * 解除注册并退出
     */
    void destroy() {
        JIntellitype.getInstance().unregisterHotKey(KEY_1);
        JIntellitype.getInstance().unregisterHotKey(KEY_2);
        JIntellitype.getInstance().unregisterHotKey(KEY_3);
        System.exit(0);
    }

    /**
     * 初始化热键并注册监听事件
     */
    void initHotkey() {
        //参数KEY_1表示改组热键组合的标识，第二个参数表示组合键，如果没有则为0，该热键对应ctrl+alt+I
        JIntellitype.getInstance().registerHotKey(KEY_1, JIntellitype.MOD_CONTROL + JIntellitype.MOD_ALT,
                (int) 'I');
        JIntellitype.getInstance().registerHotKey(KEY_2, JIntellitype.MOD_CONTROL + JIntellitype.MOD_ALT,
                (int) 'O');
        JIntellitype.getInstance().registerHotKey(KEY_3, JIntellitype.MOD_CONTROL + JIntellitype.MOD_ALT,
                (int) 'X');

        JIntellitype.getInstance().addHotKeyListener(this);
    }

    public static void main(String[] args) {
        HotKey key = new HotKey();
        key.initHotkey();

        //下面模拟长时间执行的任务
        while (true) {
            try {
                Thread.sleep(10000);
            } catch (Exception ex) {
                break;
            }
        }
    }
}

相关附件：解压后将dll文件放入system32目录下或者系统path环境变量中。

jintellitype

• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

注：本文为原创文章，转载时请注明转载地址。

在上篇文章中介绍了通过串口向LED液晶显示屏发送数据的方式，同样，通过串口也可以让你的程序来捕捉外部设备（开关类设备）触发的事件或者从外部设备读取数据（传感器等）。 下面介绍一个通过脚踏开关来控制应用程序操作的例子。

脚踏开关—分为两种：一种就是日常生活中最普通的电路开关，通过电路的闭合来控制 电路的接通；另一种就是在开关中加入一个上位机，其他的都一样。

功能：当脚踏开关踩下（电路接通）时，触发你的程序中的一个动作，比如启动/停止一项任务。

接线图：
将开关的两根线分别接在串口的输入、输出（2、3号）引脚，如图：


根据脚踏开关的两种类型采用不同的方式

1.带上位机的
该方式比较简单，当开关的闭合触发事件时上位机会通过串口向pc发送数据，在程序中采用串口的事件监听模型即可进行事件的捕捉，主要代码如下：

try { 
serialPort.addEventListener(new SerialPortEventListener() { 
public void serialEvent(SerialPortEvent serialPortEvent) { 
//在此进行事件捕捉处理 
} 
}); 
} catch (TooManyListenersException e) { 
serialPort.close(); 
throw new SerialConnectionException("too many listeners added"); 
} 

 



2.普通的开关
此种方式由于没有上位机主动向pc发送数据，所以不能再采用上述方式来进行捕获事件，解决的方式是：让一个单独的线程每隔一定的时间向串口发送数据，然后让另一个线程不停的在串口接收数据，如果能够接受到数据说明开关闭合，否则说明开关断开。

相关程序代码：

public class Demo {
    static SwitchControl control;
    private InputStream in;
    private OutputStream os;
    private SerialPort serialPort;
    boolean inited = false;
    boolean stoped = false;
    long beg = System.currentTimeMillis();

    public boolean init() {
        if (inited) {
            return true;
        }
        try {
            CommPortIdentifier portId = CommPortIdentifier.getPortIdentifier("COM1");
            serialPort = (SerialPort) portId.open("SerialBean", 4000);
            serialPort.setSerialPortParams(9600,
                    SerialPort.DATABITS_8,
                    SerialPort.STOPBITS_1,
                    SerialPort.PARITY_NONE);
            serialPort.setDTR(true);
            in = serialPort.getInputStream();
            os = serialPort.getOutputStream();
            inited = true;
           
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }


        return true;
    }


    public void writePort(int s) {
        try {
            os.write(s);
            os.flush();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    public void start() {
        Thread send = new Thread(new SendData());
        Thread recive = new Thread(new ReceiveData());
        send.start();
        recive.start();
    }


    public void close() {
        stoped = true;
        try {
            Thread.sleep(20);
            if (in != null) {
                in.close();
            }

            if (os != null) {
                os.close();
            }
            if (serialPort != null)
                serialPort.close();


        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    class ReceiveData implements Runnable {

        public void run() {
            while (true) {
                if (stoped) {
                    break;
                }
                byte[] b = new byte[10];
                try {
                    if (in.read(b) == 0) {
                        continue;
                    }
                    long end = System.currentTimeMillis();
                    //处去噪声影响，通过连续两次接受到数据的时间差来判断是一次长时间的踩踏还是连续2次或者多次踩踏
                    if (end - beg > 20) {
                        Thread tt = new Thread(new Task());
                        tt.start();
                    }
                    Thread.sleep(10);
                    beg = System.currentTimeMillis();
                } catch (Exception e) {
                    break;
                }

            }
        }
    }

    class SendData implements Runnable {
        public void run() {
            while (true) {
                if (stoped) {
                    break;
                }
                writePort(0);
                try {
                    Thread.sleep(5);
                } catch (Exception e) {
                    e.printStackTrace();
                    break;
                }
            }
        }
    }

    class Task implements Runnable {

        public void run() {
            // 相关任务
            System.out.println("捕捉到事件.............");
        }
    }

    public static void main(String[] args) {
        Demo demo = new Demo();
        if (!demo.init()) {
            System.err.println("初始化串口失败！");
            return;
        }

        demo.start();
    }
}

• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛

注：本文为原创文章，转载时请注明转载地址。

在很多应用程序中都需要用到pc机与外部设备如：嵌入式系统、传感器、开关设备等进行数据通讯。其中，最常用的接口就是RS-232串口和并口。SUN的CommAPI分别提供了对常用的RS232串行端口和IEEE1284并行端口通讯的支持。

至于java串口通讯的配置以及通讯模式在sun的demo以及网上都有很多具体的实例。

下面是我在开发一个叫号功能模块时通过串口通信来控制LED显示的实例，由于第一次进行相关的开发，看似一个非常简单的功能在实际开发中却遇到了一些问题，希望本人的解决方式能够对大家有所帮助，也希望大家能够提出更好的解决方式。

先看一下LED显示屏厂商提供的通讯协议：

---遥控单双色、单双行、混合屏 一、 每一次对任一特定地址发送信息由内码帧(7f/7e)，数码帧 (6f/6e)，定时帧(5f)，时间帧(4f)中的一种或多种构成，结束 时发送一结束帧。 二、帧结构：每帧由84字节构成。 1、 内码帧：一幕由一起始帧和零或多个中间帧组成，一次 发送可有多幕。 1） 起始帧：地址（1字节）＋帧控制7F（1字节） ＋幕号（1字节）+COMMAND（8字节） +内码/ASCII（73字节） 2） 中间帧：地址（1字节）＋帧控制7E（1字节）＋ 幕号（1字节）+COMMAND（8字节）+内码/ASCII （73字节） 3）COMMAND： 前4字节未定义，后4字节依次为动画（0～4）， 移入及移出（各16种），速度（0～255），追加 （D3连续、D2停止、D0闪烁、D4时间、D6暂停、 D7动画） 4）内码/ASCII结构： a、 内码4字节，依次为控制字节（D7宽体/正常体、 D4绿色、D5红色、D3粗体、D2细体反白、D1 粗体反白、D0细体），内码高位，内码低位，未用 b、ASCII 2字节，依次为控制字节（D7宽体/正常体、 D5绿色、D4红色、D3粗体、D2细体反白、D1粗体 反白、D0细体），ASCII码 2、数码帧：由一起始帧和零或多中间帧组成。 1） 起始帧：地址（1字节）＋帧控制6F（1字节）＋ 数据（82字节） 2） 间帧：地址（1字节）＋帧控制6E（1字节）＋ 数据（82字节） 3、定时帧：由一帧组成。 起始帧：地址（1字节）＋帧控制5F（1字节）＋ 数据（48字节）+无效数据 包括8个定时器，每个6字节，结构如下： 开/关（0为OFF、1为ON），日期（0～6为 sunday～satday、7为每一天），小时（0～23）， 分钟（0～59），起始幕，结束幕。 4、时间帧：由一帧组成。 地址（1字节）＋帧控制4F（1字节）＋年高二位 （1字节）+年低二位（1字节）+月（1字节）+日 （1字节） +时（1字节）+分（1字节）+星期（1字节） +无效数据 日期都用十进制表示，星期部分0为星期日。 4、结束帧：由一帧组成。 地址（1字节）＋帧控制7D（1字节）＋无效数据（82 字节） 3）移入，移出模式：各16种模式，可任意组合。 三、 移入模式： 移出模式： 模式0：移入← 移出← 模式1：移入→ 移出→ 模式2：移入↑ 移出↑ 模式3：移入↓ 移出↓ 模式4：跳入← 跳出← 模式5：展开→ 展开→ 模式6：展开← 展开← 模式7：展开↑ 展开↑ 模式8：展开↓ 展开↓ 模式9：展开←→ 展开←→ 模式10：展开→← 展开→← 模式11：展开↑↓ 展开↑↓ 模式12：展开↓↑ 展开↓↑ 模式13：即入 即出 模式14：预备 预备 模式15：随机(已设为循环)随机(已设为循环) 四、通讯卡接口： 1）初始化通讯卡： a、将0xFF写入地址211H b、从211H读入一字节，判断D3是否为‘1’，如为 ‘0’则重复此步骤 c、将0x00写入地址211H d、从211H读入一字节，判断D3是为‘0’，如为 ‘1’则重复此步骤 e、初始化完成 2）写入数据地址：210H 3）读状态地址：211H 状态标志：D0写允许，高电平有效 注:未使用字节必须置为0X00. 232口: 8位数据位, 1位停止位, 无效验位, 波特率为9600. * 每帧84字节, 每幕发一个7F帧, 超过18个字的条屏, 每幕需加发一个7E帧, 所有幕发完后,发7D帧(结束帧)

串口通讯涉及到的部分主要代码：

import java.io.*;
import javax.comm.*;

public class SerialBean {
    static SerialBean bean;
    String PortName;
    CommPortIdentifier portId;
    SerialPort serialPort;
    OutputStream out;
    InputStream in;


    public String getPortName() {
        return PortName;
    }

    public void setPortName(String portName) {
        PortName = portName;
    }

    private SerialBean(int PortID) {
        PortName = "COM" + PortID;

    }

    public static SerialBean getInstance() {
        if (bean == null) {
            if (!portInit(1))
                return null;
        }
        return bean;
    }

    public static boolean portInit(int port) {
        if (bean != null) {
            bean.ClosePort();
        }
        bean = new SerialBean(port);
        return bean.initialize();

    }


    public boolean initialize() {
        try {
            portId = CommPortIdentifier.getPortIdentifier(PortName);
            try {
                serialPort = (SerialPort)
                        portId.open("SerialBean", 3000);

            } catch (PortInUseException e) {
                e.printStackTrace();
                return false;
            }
            try {
                in = serialPort.getInputStream();
                out = serialPort.getOutputStream();
            } catch (IOException e) {
                return false;
            }
            try {
                serialPort.setSerialPortParams(9600,
                        SerialPort.DATABITS_8,

                        SerialPort.STOPBITS_1,
                        SerialPort.PARITY_NONE);
            } catch (UnsupportedCommOperationException e) {
                e.printStackTrace();
                return false;
            }
        } catch (NoSuchPortException e) {
            e.printStackTrace();
            return false;
        }

        return true;
    }


    public void writePort(byte[] bytes) {
        for(byte b:bytes){
            writePort(b);
        }

    }

    public void writePort(byte b) {
        try {
            out.write(b);
            out.flush();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void ClosePort() {
        if (out != null) {
            try {
                out.close();
                in.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        serialPort.close();
    }
}

 向LED发送数据代码，以下测试代码将大部分涉及到通讯协议中的模式以及指令都写死在程序中，有必要可以进行重构

 static int number = 0;
    static byte target = 0x00;
    static byte font = (byte) 0;     //默认字体
    static int LED_LENGTH = 16;      //默认LED显示字体数目（汉字）
    static byte MODULE=0x00;         //默认模式
    static byte[] beg = new byte[]{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
    byte[] end = new byte[]{0x7D,
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            0x00, 0x00
    };

    public void display(String meg) {
        SerialBean sb = SerialBean.getInstance();
        int bytes = LED_LENGTH * 4;
        writeNext(sb);
       //汉字在LED中显示所占的宽度是字母或者数字的2倍，以下进行区分
        for (int i = 0; i < meg.length(); i++) {
            String s = meg.substring(i, i + 1);
            byte[] b = s.getBytes();
            if (b.length == 2) {
                if (bytes < 4) {
                    for (int n = 0; n < bytes + 73 - LED_LENGTH * 4; n++) {
                        sb.writePort(0x00);
                    }
                    bytes = LED_LENGTH * 4;
                    writeNext(sb);
                }
                sb.writePort(font);
                sb.writePort(s.getBytes());
                sb.writePort(0x00);
                bytes -= 4;
            } else if (b.length == 1) {
                if (bytes < 2) {
                    for (int n = 0; n < bytes + 73 - LED_LENGTH * 4; n++) {
                        sb.writePort(0x00);
                    }
                    bytes = LED_LENGTH * 4;
                    writeNext(sb);
                }

                sb.writePort(font);
                sb.writePort(meg.charAt(i));
                bytes -= 2;

            }
        }
        for (int n = 0; n < bytes + 73 - LED_LENGTH * 4; n++) {
            sb.writePort(0x00);
        }
        sb.writePort(target);
        sb.writePort(end);
        sb.ClosePort();
    }

    private void writeNext(SerialBean sb) {
        sb.writePort(target);
        sb.writePort(0x7F);
        sb.writePort((byte) number++);
        sb.writePort(beg);
        sb.writePort(MODULE);
    }

 以上代码刚开始写完后进行测试认为基本上没有问题，但是一测试却发现LED上没有任何反应，刚开始以为没有将数据发送过去，采用一些串口监测工具却发现数据已经发送成功；在网上也没有查到任何资料，后来折腾了半天突然想到是不是电脑数据发送太快导致LED中处理数据时导致丢失数据帧，于是立马在发送每个字节后加了一个时间延迟，结果立马有反应，后来适当调节延迟时间一切ok。

public void writePort(byte b) {
        try {
            out.write(b);
            out.flush();
            Thread.sleep(10);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

（后来想了一下，LED处理数据时可能采用缓存操作，当pc向其发送信息时首先发送至缓存区域，LED此时读取缓存开始处理数据，但是如果pc发送信息太快以致led还没有处理完数据并且数据的大小超出了LED的缓存区域，那么此时可能就会出现将早先的数据进行覆盖的问题，以上只是猜测，后来程序调试好了也没有再理会）

• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

注：本文为原创文章，转载时请注明转载地址。

最新的jdk-6u10版本已经在进行beta测试，对于swing来说，在此版本中增加了两个重要的功能：透明窗体和不规则窗体。这两个功能使得swing也可以做出vista下的玻璃效果来了，
jdk-6u10还没有正式发布，可以在http://download.java.net/jdk6/binaries/进行下载
透明窗体：

public class TranslucentWindow extends JFrame {
    public TranslucentWindow() {
        super("透明窗体");
        this.setLayout(new FlowLayout());
        this.add(new JButton("按钮"));
        this.add(new JCheckBox("复选按钮"));
        this.add(new JRadioButton("单选按钮"));
        this.add(new JProgressBar(20, 100));
        this.setSize(new Dimension(400, 300));
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }

    public static void main(String[] args) {
        JFrame.setDefaultLookAndFeelDecorated(true);
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                Window w = new TranslucentWindow();
                w.setVisible(true);
                com.sun.awt.AWTUtilities.setWindowOpacity(w, 0.6f);
            }
        });
    }

}

不规则窗体：
 

public class ShapedWindow extends JFrame {
    public ShapedWindow() {
        super("不规则窗体");
        this.setLayout(new FlowLayout());
        this.add(new JButton("按钮"));
        this.add(new JCheckBox("复选按钮"));
        this.add(new JRadioButton("单选按钮"));
        this.add(new JProgressBar(0, 100));

        this.setSize(new Dimension(400, 400));
        this.setLocationRelativeTo(null);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }

    public static void main(String[] args) {
        JFrame.setDefaultLookAndFeelDecorated(true);
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                Window w = new ShapedWindow();
                w.setVisible(true);
                com.sun.awt.AWTUtilities.setWindowShape(w, new Ellipse2D.Double(0, 0, w.getWidth(), w.getHeight()));
                com.sun.awt.AWTUtilities.setWindowOpacity(w, 0.93f);
            }
        });
    }

}

• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 北京: 千橡集团暨校内网诚聘软件研发工程师

注：本文为原创文章，转载时请注明转载地址。

炒股有一段时间了，发现现在的股票行情软件在很多情况下并不是太好用，我炒股的时候喜欢看盘口的实时交易记录，如果同时关注多支股票的话，我用过的行情软件没有找到同时观看多支股票盘口交易数据的功能，另外在工作的时候使用目前的行情软件也不太方便。所以打算自己写个专门的行情软件，但是数据源是个最棘手的问题，经过搜索和不懈的努力，找到了两种方式：

1. 通过webservice调用http://www.webxml.com.cn/zh_cn/web_services.aspx，该网站提供了免费的和收费的服务，但是免费的限制了每天的请求次数，在此不太实用。

2. 调用sina专门的js服务器来解析数据，这种方式我使用了有很长一段时间，速度还是相当不错的，有时候比专门的行情软件的实时数据还快，下面是获取数据的部分代码：

 
      String url = "http://hq.sinajs.cn/list=sh600151,sz000830,s_sh000001,s_sz399001,s_sz399106";
        try {
            URL u = new URL(url);
            byte[] b = new byte[256];
            InputStream in = null;
            ByteArrayOutputStream bo = new ByteArrayOutputStream();
            while (true) {
                try {
                    in = u.openStream();
                    int i;
                    while ((i = in.read(b)) != -1) {
                        bo.write(b, 0, i);
                    }
                    String result = bo.toString();
                    String[] stocks = result.split(";");
                    for (String stock : stocks) {
                        String[] datas = stock.split(",");
                        //根据对照自己对应数据
                    }
                    bo.reset();
                } catch (Exception e) {
                    System.out.println(e.getMessage());
                } finally {
                    if (in != null) {
                        in.close();
                    }
                }
            }
        } catch (Exception ex) {
            System.out.println(ex.getMessage());
        }

list后面的参数为相关的股票代码，可以同时附加多个股票代码，其中上证前面加"sh"，深证前面加"sz",
如果只需获取股票交易的基本数据则在之前加"s_",如下面的
s_sh000001,s_sz399001,s_sz399106分别为：上证指数，深证成指 ，深证综指的基本指标数据
获取到的数据格式如下：
var hq_str_sh600151="航天机电,14.49,14.57,14.37,14.86,14.10,14.37,14.38,13146411,190836199,1900,14.37,10601,14.36,16100,14.35,1700,14.34,6900,14.33,49200,14.38,60400,14.39,25373,14.40,4500,14.41,10650,14.42,2008-03-07,15:05:32";
var hq_str_sz000830="鲁西化工,8.82,8.91,8.53,8.88,8.38,8.52,8.53,24754397,213611631.24,118400,8.52,38400,8.51,368623,8.50,19000,8.49,69300,8.48,170948,8.53,57160,8.55,44729,8.56,27300,8.57,32700,8.58,2008-03-07,15:20:51";
var hq_str_sh000001="上证指数,4315.808,4360.986,4300.515,4341.295,4265.829,0,0,56747402,92203521881,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2008-03-07,15:05:32";
var hq_str_s_sz399001="深证成指,15560.853,-135.272,-0.86,3500683,963757";
var hq_str_s_sz399106="深证综指,1369.839,-18.264,-1.32,4279649095,4557752"; 

获取数据后，自己根据行情软件来对应数据，然后使用swing做个界面，呵呵，这样就大功告成了，个人使用了2个多月了，一般情况下非常好用的。

• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛

注：本文为原创文章，转载时请注明转载地址。

功能：通过查表方式实现阳历和阴历的日期转换   

注：该实现是参照网络上的一个用c实现的方法转换成java的

package net.walsece.date;

import java.text.DateFormat;
import java.text.SimpleDateFormat;

import java.util.Calendar;
import java.util.Date;


public class DateParse {
    private final static int MONTH_DAYS[] = {29, 30};
    private final static int DAYS_MONTH[][] = {
            {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
            {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
    };
    private final static int DATAS[][] = {
            {23, 3, 2, 17, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0},
            {41, 0, 4, 23, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1},
            {30, 7, 5, 28, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1},
            {49, 0, 6, 33, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1},
            {38, 0, 0, 38, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1},
            {26, 6, 2, 44, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0},
            {45, 0, 3, 49, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0},
            {35, 0, 4, 54, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1},
            {24, 4, 5, 59, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1},
            {43, 0, 0, 5, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1},
            {32, 0, 1, 10, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1},
            {21, 2, 2, 15, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1},
            {40, 0, 3, 20, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1},
            {28, 7, 5, 26, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1},
            {47, 0, 6, 31, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1},
            {36, 0, 0, 36, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0},
            {26, 5, 1, 41, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1},
            {44, 0, 3, 47, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1},
            {33, 0, 4, 52, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0},
            {23, 3, 5, 57, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1},
            {42, 0, 6, 2, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1},
            {30, 8, 1, 8, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0},
            {48, 0, 2, 13, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0},
            {38, 0, 3, 18, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1},
            {27, 6, 4, 23, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0},
            {45, 0, 6, 29, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0},
            {35, 0, 0, 34, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1},
            {24, 4, 1, 39, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0},
            {43, 0, 2, 44, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0},
            {32, 0, 4, 50, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1},
            {20, 3, 5, 55, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0},
            {39, 0, 6, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0},
            {29, 7, 0, 5, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1},
            {47, 0, 2, 11, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1},
            {36, 0, 3, 16, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0},
            {26, 5, 4, 21, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1},
            {45, 0, 5, 26, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1},
            {33, 0, 0, 32, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1},
            {22, 4, 1, 37, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1},
            {41, 0, 2, 42, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1},
            {30, 8, 3, 47, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1},
            {48, 0, 5, 53, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1},
            {37, 0, 6, 58, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1},
            {27, 6, 0, 3, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0},
            {46, 0, 1, 8, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0},
            {35, 0, 3, 14, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1},
            {24, 4, 4, 19, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1},
            {43, 0, 5, 24, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1},
            {32, 10, 6, 29, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1},
            {50, 0, 1, 35, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0},
            {39, 0, 2, 40, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1},
            {28, 6, 3, 45, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0},
            {47, 0, 4, 50, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1},
            {36, 0, 6, 56, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0},
            {26, 5, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1},
            {45, 0, 1, 6, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0},
            {34, 0, 2, 11, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0},
            {22, 3, 4, 17, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0},
            {40, 0, 5, 22, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0},
            {30, 8, 6, 27, 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1},
            {49, 0, 0, 32, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 1},
            {37, 0, 2, 38, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1},
            {27, 5, 3, 43, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1},
            {46, 0, 4, 48, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1},
            {35, 0, 5, 53, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1},
            {23, 4, 0, 59, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1},
            {42, 0, 1, 4, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1},
            {31, 0, 2, 9, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0},
            {21, 2, 3, 14, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1},
            {39, 0, 5, 20, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1},
            {28, 7, 6, 25, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1},
            {48, 0, 0, 30, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1},
            {37, 0, 1, 35, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1},
            {25, 5, 3, 41, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1},
            {44, 0, 4, 46, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1},
            {33, 0, 5, 51, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1},
            {22, 4, 6, 56, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0},
            {40, 0, 1, 2, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0},
            {30, 9, 2, 7, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1},
            {49, 0, 3, 12, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1},
            {38, 0, 4, 17, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0},
            {27, 6, 6, 23, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1},
            {46, 0, 0, 28, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0},
            {35, 0, 1, 33, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0},
            {24, 4, 2, 38, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1},
            {42, 0, 4, 44, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1},
            {31, 0, 5, 49, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0},
            {21, 2, 6, 54, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1},
            {40, 0, 0, 59, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1},
            {28, 6, 2, 5, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0},
            {47, 0, 3, 10, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1},
            {36, 0, 4, 15, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1},
            {25, 5, 5, 20, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0},
            {43, 0, 0, 26, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1},
            {32, 0, 1, 31, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0},
            {22, 3, 2, 36, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0}
    };

    /**
     * 根据阴历取得对应的阳历日期（该日期必须在1936—2028年之间）
     *
     * @param date 阴历日期（字符串）
     * @return 返回对应的阳历日期
     * @throws Exception
     */
    public static Date getGregorianCalendar(String date) {
        Calendar c = getCalendar(date);
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH) + 1;
        int day = c.get(Calendar.DAY_OF_MONTH);
        int index = year - 1936;
        int endIndex = month;

        if ((DATAS[index][1] != 0) && (month > DATAS[index][1])) {
            endIndex++;
        }

        int dayNum = 0;

        for (int i = 0; i < (endIndex - 1); i++) {
            dayNum += MONTH_DAYS[DATAS[index][4 + i]];
        }

        dayNum += day;
        dayNum += DATAS[index][0];

        int year_days = 365;

        if (isLeapYear(year)) {
            year_days = 366;
        }

        if (dayNum > year_days) {
            year++;
            dayNum -= year_days;
        }

        month = 1;

        int dayOfMonth[] = DAYS_MONTH[0];

        if (isLeapYear(year)) {
            dayOfMonth = DAYS_MONTH[1];
        }

        int i = 0;

        for (; i < 12; i++) {
            dayNum -= dayOfMonth[i];

            if (dayNum <= 0) {
                break;
            }

            month++;
        }

        day = dayOfMonth[i] + dayNum;

        return getDate(year + "-" + month + "-" + day);
    }

    /**
     * 根据阳历取得对应的阴历日期（该日期必须在1936—2028年之间）
     *
     * @param date 阳历日期（字符串）
     * @return 返回阴历日期
     * @throws Exception
     */
    public static Date getLunarCalendar(String date) {
        Calendar calendar = getCalendar(date);
        int year = calendar.get(Calendar.YEAR);
        int month = 1;
        int day;

        if ((year < 1936) || (year > 2028)) {
            return null;
        }

        int index = year - 1936;
        int l_days = DATAS[index][0];
        int day_year = calendar.get(Calendar.DAY_OF_YEAR);
        int days;

        if (day_year >= l_days) {
            days = day_year - l_days;
        } else {
            index--;
            year--;

            Calendar c = getCalendar(year + "-12-31");
            days = (c.get((Calendar.DAY_OF_YEAR)) + day_year) -
                    DATAS[index][0];
        }

        int i = 0;
        int day_num = 0;

        for (; i < 13; i++) {
            day_num += MONTH_DAYS[DATAS[index][i + 4]];

            if (day_num >= days) {
                break;
            }

            month++;
        }

        day = MONTH_DAYS[DATAS[index][i + 4]] - (day_num - days);

        if ((DATAS[index][1] != 0) && (month > DATAS[index][1])) {
            month--;
        }

        return getDate(year + "-" + month + "-" + day);
    }

    private static Calendar getCalendar(String date) {
        Date dd = getDate(date);
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(dd);

        return calendar;
    }

    private static Date getDate(String date) {
        DateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        Date dd = null;

        try {
            dd = format.parse(date);
        } catch (Exception e) {
            e.printStackTrace();
        }

        return dd;
    }

    private static boolean isLeapYear(int year) {
        if ((year % 400) == 0) {
            return true;
        } else if ((year % 100) == 0) {
            return false;
        } else if ((year % 4) == 0) {
            return true;
        }

        return false;
    }
}

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

注：本文为原创文章，转载时请注明转载地址。

软件名称：游戏外挂（键盘挂）
开发语言：java

该外挂的原理：
游戏外挂主要原理是通过实时的分析游戏画面来获取人物状态及相关怪物的状态，类似于人的视觉系统，然后驱动相关的按键。

主要功能：

采用hsb来进行颜色判断，颜色控制更加精确

自定义按键设置  

自动加红加蓝，可以自己设置相关的阀值（百分比）

用完药后可以设置自动回城

自动捡物品

自定义攻击怪物的招式及时间延迟

自定义周期性的招式及时间周期

可以设置只攻击自己的怪物，不攻击他人的怪物

断线后自动重连

支持全屏模式及窗口模式，每次调节窗口大小及位置或者更改不同分辨率后都可以采用系统自动校验功能进行重新的界面定位，可以边看电影边挂机。

支持自定义功能，以后出现类似操作的游戏可以通过自定义一些颜色的参数即可使用。 

该外挂在2006年底完成，后来诛仙出来后又进行了一些改进，现在已有很长时间没有再玩。

部分截图：

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

注：本文为原创文章，转载时请注明转载地址。

彩超工作站软件主要功能介绍

本系统主要实现以下功能：
1. 病历生成功能
包括病人信息登记、多条件查询、诊断编辑、病历打印等功能。其中诊断编辑可以采用专家知识库的模式进行拷贝编辑修改，病历打印可以提供几种常用病历格式模版选择。检查参数设置。对需要测量的参数进行加入、更改、删除操作。检查与正常报告对照表设置检查部位和知识库中正常报告的对应关系，设置好后，在诊断编辑模块可以快速把需要的知识库信息提到最前面，方便医生操作。查部位顺序设置：设置检查顺序，方便医生操作。
2. 图像采集功能
客户端通过采集卡同步采集并显示超声设备的图像，用户可以采集静态、动态、缓冲静态采集、缓冲动 态采等模式的图像，并可以将图像保存至服务器中，在局域网内实现查看，修改、打印（同病历一起）等功能。
3. 图像采集方式：可以通过鼠标、键盘、脚踏等进行。
4. 影像处理功能：在定标的前提下对当前病人的图像或早期病人的图像调入进行处理。
5. 在编写病例时可以用脚踏或手踏进行图象采集。
6. 软件可以录制医生口述的病例。
7. 排号叫号、LED或等离子电视显示功能
系统可以根据登记的病人登记得先后实现排号（急诊病人优先），主治大夫可以在软件系统中实现叫号。并可以把叫号信息以合适的数据格式发送至条形屏幕显示。
8. 软件加密
系统根据计算机硬件生成注册码方式来进行加密，控制客户端数目及随意复制。
9. 统计主程序
可对诊断医生工作量、检查项目分类、全院各科室申请单、诊断结果、科室工作量、设备工作量、临床医生申请单进行统计、打印；对诊断医生的人次、收入及设备诊断人次、收入及诊断医生工作量等信息以图表的形式进行统计。
10. 其它：医生重新登录、输入测量参数、测量参数设置、有用户与权限设置。


以下是本系统的主要操作界面截图（只涉及到主要的界面）


用户登录界面

病人登记主界面（检查部位选择）

图像采集主界面（实时采集）

病例快速查询界面


专家知识库（病例生成）

知识库编辑




病例打印（采用模板）


病例详细查询

病人叫号


统计界面（图形统计）

统计表格（表格统计）



叫号语音设置界面

• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。