BlogJava-灵魂-放水-文章分类-综合技术http://www.blogjava.net/zqli/category/7607.html为学日益，为道日损。zh-cnTue, 27 Feb 2007 10:27:42 GMTTue, 27 Feb 2007 10:27:42 GMT60[收藏]CSDN - 文档中心 -各种排序算法java实现 http://www.blogjava.net/zqli/articles/51148.html放水老倌放水老倌Wed, 07 Jun 2006 08:06:00 GMThttp://www.blogjava.net/zqli/articles/51148.htmlhttp://www.blogjava.net/zqli/comments/51148.htmlhttp://www.blogjava.net/zqli/articles/51148.html#Feedback0http://www.blogjava.net/zqli/comments/commentRss/51148.htmlhttp://www.blogjava.net/zqli/services/trackbacks/51148.htmlpackage org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;
/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class InsertSort implements SortUtil.Sort{

    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        int temp;
        for(int i=1;i<data.length;i++){
            for(int j=i;(j>0)&&(data[j]<data[j-1]);j--){
                SortUtil.swap(data,j,j-1);
            }
        }       
    }

}
冒泡排序:

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class BubbleSort implements SortUtil.Sort{

    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        int temp;
        for(int i=0;i<data.length;i++){
            for(int j=data.length-1;j>i;j--){
                if(data[j]<data[j-1]){
                    SortUtil.swap(data,j,j-1);
                }
            }
        }
    }

}

选择排序:

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class SelectionSort implements SortUtil.Sort {

    /*
     * (non-Javadoc)
     *
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        int temp;
        for (int i = 0; i < data.length; i++) {
            int lowIndex = i;
            for (int j = data.length - 1; j > i; j--) {
                if (data[j] < data[lowIndex]) {
                    lowIndex = j;
                }
            }
            SortUtil.swap(data,i,lowIndex);
        }
    }

}

Shell排序:

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class ShellSort implements SortUtil.Sort{

    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        for(int i=data.length/2;i>2;i/=2){
            for(int j=0;j<i;j++){
                insertSort(data,j,i);
            }
        }
        insertSort(data,0,1);
    }

    /**
     * @param data
     * @param j
     * @param i
     */
    private void insertSort(int[] data, int start, int inc) {
        int temp;
        for(int i=start+inc;i<data.length;i+=inc){
            for(int j=i;(j>=inc)&&(data[j]<data[j-inc]);j-=inc){
                SortUtil.swap(data,j,j-inc);
            }
        }
    }

}

快速排序:

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class QuickSort implements SortUtil.Sort{

    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        quickSort(data,0,data.length-1);       
    }
    private void quickSort(int[] data,int i,int j){
        int pivotIndex=(i+j)/2;
        //swap
        SortUtil.swap(data,pivotIndex,j);
       
        int k=partition(data,i-1,j,data[j]);
        SortUtil.swap(data,k,j);
        if((k-i)>1) quickSort(data,i,k-1);
        if((j-k)>1) quickSort(data,k+1,j);
       
    }
    /**
     * @param data
     * @param i
     * @param j
     * @return
     */
    private int partition(int[] data, int l, int r,int pivot) {
        do{
           while(data[++l]<pivot);
           while((r!=0)&&data[--r]>pivot);
           SortUtil.swap(data,l,r);
        }
        while(l<r);
        SortUtil.swap(data,l,r);       
        return l;
    }

}
改进后的快速排序:

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class ImprovedQuickSort implements SortUtil.Sort {

    private static int MAX_STACK_SIZE=4096;
    private static int THRESHOLD=10;
    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        int[] stack=new int[MAX_STACK_SIZE];
       
        int top=-1;
        int pivot;
        int pivotIndex,l,r;
       
        stack[++top]=0;
        stack[++top]=data.length-1;
       
        while(top>0){
            int j=stack[top--];
            int i=stack[top--];
           
            pivotIndex=(i+j)/2;
            pivot=data[pivotIndex];
           
            SortUtil.swap(data,pivotIndex,j);
           
            //partition
            l=i-1;
            r=j;
            do{
                while(data[++l]<pivot);
                while((r!=0)&&(data[--r]>pivot));
                SortUtil.swap(data,l,r);
            }
            while(l<r);
            SortUtil.swap(data,l,r);
            SortUtil.swap(data,l,j);
           
            if((l-i)>THRESHOLD){
                stack[++top]=i;
                stack[++top]=l-1;
            }
            if((j-l)>THRESHOLD){
                stack[++top]=l+1;
                stack[++top]=j;
            }
           
        }
        //new InsertSort().sort(data);
        insertSort(data);
    }
    /**
     * @param data
     */
    private void insertSort(int[] data) {
        int temp;
        for(int i=1;i<data.length;i++){
            for(int j=i;(j>0)&&(data[j]<data[j-1]);j--){
                SortUtil.swap(data,j,j-1);
            }
        }      
    }

}

归并排序:

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class MergeSort implements SortUtil.Sort{

    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        int[] temp=new int[data.length];
        mergeSort(data,temp,0,data.length-1);
    }
   
    private void mergeSort(int[] data,int[] temp,int l,int r){
        int mid=(l+r)/2;
        if(l==r) return ;
        mergeSort(data,temp,l,mid);
        mergeSort(data,temp,mid+1,r);
        for(int i=l;i<=r;i++){
            temp[i]=data[i];
        }
        int i1=l;
        int i2=mid+1;
        for(int cur=l;cur<=r;cur++){
            if(i1==mid+1)
                data[cur]=temp[i2++];
            else if(i2>r)
                data[cur]=temp[i1++];
            else if(temp[i1]<temp[i2])
                data[cur]=temp[i1++];
            else
                data[cur]=temp[i2++];           
        }
    }

}

改进后的归并排序:

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class ImprovedMergeSort implements SortUtil.Sort {

    private static final int THRESHOLD = 10;

    /*
     * (non-Javadoc)
     *
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        int[] temp=new int[data.length];
        mergeSort(data,temp,0,data.length-1);
    }

    private void mergeSort(int[] data, int[] temp, int l, int r) {
        int i, j, k;
        int mid = (l + r) / 2;
        if (l == r)
            return;
        if ((mid - l) >= THRESHOLD)
            mergeSort(data, temp, l, mid);
        else
            insertSort(data, l, mid - l + 1);
        if ((r - mid) > THRESHOLD)
            mergeSort(data, temp, mid + 1, r);
        else
            insertSort(data, mid + 1, r - mid);

        for (i = l; i <= mid; i++) {
            temp[i] = data[i];
        }
        for (j = 1; j <= r - mid; j++) {
            temp[r - j + 1] = data[j + mid];
        }
        int a = temp[l];
        int b = temp[r];
        for (i = l, j = r, k = l; k <= r; k++) {
            if (a < b) {
                data[k] = temp[i++];
                a = temp[i];
            } else {
                data[k] = temp[j--];
                b = temp[j];
            }
        }
    }

    /**
     * @param data
     * @param l
     * @param i
     */
    private void insertSort(int[] data, int start, int len) {
        for(int i=start+1;i<start+len;i++){
            for(int j=i;(j>start) && data[j]<data[j-1];j--){
                SortUtil.swap(data,j,j-1);
            }
        }
    }

}
堆排序:

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class HeapSort implements SortUtil.Sort{

    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        MaxHeap h=new MaxHeap();
        h.init(data);
        for(int i=0;i<data.length;i++)
            h.remove();
        System.arraycopy(h.queue,1,data,0,data.length);
    }


     private static class MaxHeap{
        
       
        void init(int[] data){
            this.queue=new int[data.length+1];
            for(int i=0;i<data.length;i++){
                queue[++size]=data[i];
                fixUp(size);
            }
        }
        
        private int size=0;

        private int[] queue;
               
        public int get() {
            return queue[1];
        }

        public void remove() {
            SortUtil.swap(queue,1,size--);
            fixDown(1);
        }
        //fixdown
        private void fixDown(int k) {
            int j;
            while ((j = k << 1) <= size) {
                if (j < size && queue[j]<queue[j+1])
                    j++;
                if (queue[k]>queue[j]) //不用交换
                    break;
                SortUtil.swap(queue,j,k);
                k = j;
            }
        }
        private void fixUp(int k) {
            while (k > 1) {
                int j = k >> 1;
                if (queue[j]>queue[k])
                    break;
                SortUtil.swap(queue,j,k);
                k = j;
            }
        }

    }

}

 

SortUtil:

package org.rut.util.algorithm;

import org.rut.util.algorithm.support.BubbleSort;
import org.rut.util.algorithm.support.HeapSort;
import org.rut.util.algorithm.support.ImprovedMergeSort;
import org.rut.util.algorithm.support.ImprovedQuickSort;
import org.rut.util.algorithm.support.InsertSort;
import org.rut.util.algorithm.support.MergeSort;
import org.rut.util.algorithm.support.QuickSort;
import org.rut.util.algorithm.support.SelectionSort;
import org.rut.util.algorithm.support.ShellSort;

/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class SortUtil {
    public final static int INSERT = 1;

    public final static int BUBBLE = 2;

    public final static int SELECTION = 3;

    public final static int SHELL = 4;

    public final static int QUICK = 5;

    public final static int IMPROVED_QUICK = 6;

    public final static int MERGE = 7;

    public final static int IMPROVED_MERGE = 8;

    public final static int HEAP = 9;

    public static void sort(int[] data) {
        sort(data, IMPROVED_QUICK);
    }
    private static String[] name={
            "insert","bubble","selection","shell","quick","improved_quick","merge","improved_merge","heap"
    };
   
    private static Sort[] impl=new Sort[]{
            new InsertSort(),
            new BubbleSort(),
            new SelectionSort(),
            new ShellSort(),
            new QuickSort(),
            new ImprovedQuickSort(),
            new MergeSort(),
            new ImprovedMergeSort(),
            new HeapSort()
    };

    public static String toString(int algorithm){
        return name[algorithm-1];
    }
   
    public static void sort(int[] data, int algorithm) {
        impl[algorithm-1].sort(data);
    }

    public static interface Sort {
        public void sort(int[] data);
    }

    public static void swap(int[] data, int i, int j) {
        int temp = data[i];
        data[i] = data[j];
        data[j] = temp;
    }
}



放水老倌 2006-06-07 16:06 发表评论
]]>下拉式列表框http://www.blogjava.net/zqli/articles/47598.html放水老倌放水老倌Tue, 23 May 2006 02:48:00 GMThttp://www.blogjava.net/zqli/articles/47598.htmlhttp://www.blogjava.net/zqli/comments/47598.htmlhttp://www.blogjava.net/zqli/articles/47598.html#Feedback0http://www.blogjava.net/zqli/comments/commentRss/47598.htmlhttp://www.blogjava.net/zqli/services/trackbacks/47598.html建立下拉式列表框

用来代替复选框和单选按钮的另一个方法是建立下拉式列表框来显示一个选择菜单。下拉式列表框一次只能显示一个选择，要查看别的可能的选项，你可以点击框右边的箭头。使用下拉式列表框的一个好处是它和单选按钮和复选框相比，占用网页上较少的空间。

你可以使用<SELECT>和<OPTION>标识符来建立一个下拉式列表框，象下面的例子：

<HTML>

<HEAD>

<TITLE> Drop-Down List Box </TITLE>

</HEAD>

<BODY >

<FORM ACTION＝“somedirectory/mypage.asp” METHOD=“POST”>

<BR> Please indicate your sex:

<BR> <SELECT NAME=“sex”>

<OPTION VALUE=“Is Male”>Male

<OPTION VALUE=“Is Female”>Female

</SELECT>

<INPUT TYPE=SUBMIT VALUE=“Submit Me!”>

</FORM>

</BODY>

</HTML>

在此例中，<SELECT>的NAME属性为你的下拉式列表框提供了一个名字，每一个<OPTION>标识符提供了一个可能的选项。<OPTION>的VALUE属性指定了当选择了此项并按下Submit按钮后应该被提交的值。最后，在<OPTION>标识符后出现的文字决定了这一项在下拉式列表框中怎样显示出来。

此例中的列表框与一组单选按钮的功能一样，你一次只能选择一项。例如，如果你从列表框中选择了Female一项，当按下Submit按钮时，发送的值将是Is Female。这个值将与列表框名sex相关联，你永远也不会一次选择多项。

缺省状态下，跟在第一个<OPTION>标识符后的文字将会成为下拉式列表框的初始值而显示，你可以使用<OPTION>的SELECT属性来改变这一缺省值。在下例中，当列表框出现时，Female被选择了，虽然在选项列表中Male排在Female的前面。

<HTML>

<HEAD>

<TITLE> Drop-Down List Box </TITLE>

</HEAD>

<BODY >

<FORM ACTION＝“somedirectory/mypage.asp” METHOD=“POST”>

<BR> Please indicate your sex:

<BR> <SELECT NAME=“sex”>

<OPTION VALUE=“Is Male”>Male

<OPTION VALUE=“Is Female” SELECTED>Female

</SELECT>

<BR> <INPUT TYPE=SUBMIT VALUE=“Submit Me!”>

</FORM>

</BODY>

</HTML>

指定一个不同的缺省值在某种情况下是很有用的，那就是当你有一个字母顺序的列表，但你想选择列表中的某一个作为它的缺省值。例如，假设你有一个许多图象的列表，但你想让缺省的图象是中国，在这种情况下，你可以使用SELECT属性来指定P.R.China为缺省值，即使这个国家的名字排列在整个字母表的后头。

放水老倌 2006-05-23 10:48 发表评论
]]>一、JSP页面显示乱码二、表单提交中文时出现乱码三、数据库连[转]http://www.blogjava.net/zqli/articles/46343.html放水老倌放水老倌Tue, 16 May 2006 02:35:00 GMThttp://www.blogjava.net/zqli/articles/46343.htmlhttp://www.blogjava.net/zqli/comments/46343.htmlhttp://www.blogjava.net/zqli/articles/46343.html#Feedback0http://www.blogjava.net/zqli/comments/commentRss/46343.htmlhttp://www.blogjava.net/zqli/services/trackbacks/46343.html一、JSP页面显示乱码二、表单提交中文时出现乱码三、数据库连
大家在JSP的开发过程中，经常出现中文乱码的问题，可能一至困扰着您，我现在把我在JSP开发中遇到的中文乱码的问题及解决办法写出来供大家参考。

一、JSP页面显示乱码
下面的显示页面(display.jsp)就出现乱码：
<html>
<head>
<title>JSP的中文处理</title>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
</head>

<body>
<%
out.print("JSP的中文处理");
%>
</body>
</html>
对不同的WEB服务器和不同的JDK版本，处理结果就不一样。原因：服务器使用的编码方式不同和浏览器对不同的字符显示结果不同而导致的。解决办法：在JSP页面中指定编码方式(gb2312),即在页面的第一行加上：<%@ page contentType="text/html; charset=gb2312"%>，就可以消除乱码了。完整页面如下：
<%@ page contentType="text/html; charset=gb2312"%>
<html>
<head>
<title>JSP的中文处理</title>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
</head>

<body>
<%
out.print("JSP的中文处理");
%>
</body>
</html>

二、表单提交中文时出现乱码
下面是一个提交页面(submit.jsp)，代码如下：
<html>
<head>
<title>JSP的中文处理</title>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
</head>

<body>
<form name="form1" method="post" action="process.jsp">
<div align="center">
<input type="text" name="name">
<input type="submit" name="Submit" value="Submit">
</div>
</form>
</body>
</html>
下面是处理页面(process.jsp)代码：
<%@ page contentType="text/html; charset=gb2312"%>
<html>
<head>
<title>JSP的中文处理</title>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
</head>

<body>
<%=request.getParameter("name")%>
</body>
</html>
如果submit.jsp提交英文字符能正确显示，如果提交中文时就会出现乱码。原因：浏览器默认使用UTF-8编码方式来发送请求，而UTF-8和GB2312编码方式表示字符时不一样，这样就出现了不能识别字符。解决办法:通过request.seCharacterEncoding("gb2312")对请求进行统一编码，就实现了中文的正常显示。修改后的process.jsp代码如下：
<%@ page contentType="text/html; charset=gb2312"%>
<%
request.seCharacterEncoding("gb2312");
%>
<html>
<head>
<title>JSP的中文处理</title>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
</head>

<body>
<%=request.getParameter("name")%>
</body>
</html>

三、数据库连接出现乱码
只要涉及中文的地方全部是乱码，解决办法：在数据库的数据库URL中加上useUnicode=true&characterEncoding=GBK就OK了。

四、数据库的显示乱码
在mysql4.1.0中,varchar类型，text类型就会出现中文乱码，对于varchar类型把它设为binary属性就可以解决中文问题，对于text类型就要用一个编码转换类来处理，实现如下：
public class Convert {
/** 把ISO-8859-1码转换成GB2312
*/
public static String ISOtoGB(String iso){
String gb;
try{
if(iso.equals("") || iso == null){
return "";
}
else{
iso = iso.trim();
gb = new String(iso.getBytes("ISO-8859-1"),"GB2312");
return gb;
}
}
catch(Exception e){
System.err.print("编码转换错误："+e.getMessage());
return "";
}
}
}
把它编译成class，就可以调用Convert类的静态方法ISOtoGB()来转换编码。


如果你还有什么不懂之处：我给大家推荐一个好的JSP-JAVA网站：

http://www.phy.hbnu.edu.cn/dsp/

Linux和Java是互联网的宠儿,更是互联网时代的两头雄师, Linux的网络安全性和开放源代码,Java的平台独立性和安全易用性，正好符合Internet平台的要求，Linux和Java真是天生一对鸳鸯。双狮资源网给你提供了最好的Linux和Java学习资源， 欢迎大家多多访问并宣传：
http://www.phy.hbnu.edu.cn/dsp/

放水老倌 2006-05-16 10:35 发表评论
]]>ＣＳＳhttp://www.blogjava.net/zqli/articles/34337.html放水老倌放水老倌Wed, 08 Mar 2006 12:11:00 GMThttp://www.blogjava.net/zqli/articles/34337.htmlhttp://www.blogjava.net/zqli/comments/34337.htmlhttp://www.blogjava.net/zqli/articles/34337.html#Feedback1http://www.blogjava.net/zqli/comments/commentRss/34337.htmlhttp://www.blogjava.net/zqli/services/trackbacks/34337.html
样式是从一个元素的现有的样式规则中选择出来的，有时候会碰到一个元素有多个可选的样式的情况，因此需要规定一种机制解决这种冲突。假设一个元素有如下的可选样式：
1、继承的样式
2、本元素的通用样式
3、通过类名选择的样式
4、通过ID选择的样式

则该元素的样式表使用次序是4、3、2、1

放水老倌 2006-03-08 20:11 发表评论
]]>ＸＭＬhttp://www.blogjava.net/zqli/articles/33894.html放水老倌放水老倌Mon, 06 Mar 2006 09:39:00 GMThttp://www.blogjava.net/zqli/articles/33894.htmlhttp://www.blogjava.net/zqli/comments/33894.htmlhttp://www.blogjava.net/zqli/articles/33894.html#Feedback6http://www.blogjava.net/zqli/comments/commentRss/33894.htmlhttp://www.blogjava.net/zqli/services/trackbacks/33894.html<! ENTITY  COPY99  "COPYRIGHT1999&ERH;">
     ERH实体作为COPY99实体的一部分存在，而COPY99实体本身最终又成为文档内容的一部分。
2、通用实体成为文档的一部分，而非DTD的组成成分。通用实体引用不能插入那些仅为DTD而非文档内容的文本。然而在DTD中的实体引用通常是有用的，因此，XML提供了参数实体引用的手段。
<!ENTITY   %REH    "EACELY">
<!ENTITY   COPY99  "COPYRIGHT1999%ERH;">

放水老倌 2006-03-06 17:39 发表评论
]]>CRC[转]http://www.blogjava.net/zqli/articles/33579.html放水老倌放水老倌Sat, 04 Mar 2006 02:48:00 GMThttp://www.blogjava.net/zqli/articles/33579.htmlhttp://www.blogjava.net/zqli/comments/33579.htmlhttp://www.blogjava.net/zqli/articles/33579.html#Feedback0http://www.blogjava.net/zqli/comments/commentRss/33579.htmlhttp://www.blogjava.net/zqli/services/trackbacks/33579.html的快速设计方法。经过破门在公司项目的实践，感觉到设计过程的确简单易行，所以根据
Ward Cunningham 的一篇讲稿整理出一份简单介绍，贴出来与大家共享。

翻译的PowerPoint讲稿可以在此下载：
firstCRC
ftp://www.clinux.org/pub/brokendoor/xp/firstCRC-cn.zip

1。面向对象编程的四个阶段
- 标识对象
- 设计草案
- 构造层次
- 实现方法
其实现难度是按照由下到上的顺序递增的

2.标识对象简介
- 按照合作代理（对象）的行为进行模块估计
- 定义特定对象的类
- 在类的基础上分配责任（符合需求）

3.一个设计方法
- 根据经验和智慧做出决定
- 用结构化的设计文档记录决定
- 充分彻底的测试设计
- 在实现的过程中维护和遵循设计

4.设计表述(CRC)
- 列举所有的新类
- 定义类成员担负的责任
- 通过分配的责任来描述合作关系

5.CRC卡片介绍(使用实例 DrawingEditor)
第一步：从已知的开始
- 一个图由多个图片构成
- 图片分成很多种类
第二步：推测支持者
- 一个线可能连接到其他图片
- 一个“智能”点完成这个工作
第三步：进行情景测试
- 图片移动的时候依赖于定位器
- 通过定位器改变顺序
第四步：尝试进行分组
- 一个处理类似一个工具
- 处理器是唯一的
第五步：重新分配责任
- 选择保持在视图类中
- 选择不会和图一起保存

第六步：为了清晰化而重写
- 图片排序非常重要

__________________
门之不存，道乃得之！
下马饮君酒，问君何所之。
君言不得意，归卧南山陲。
但去莫复问，白云无尽时。
————
* http://www.softme.org
* http://www.wfchina.org
* http://gro.clinux.org/projects/webpm/


放水老倌 2006-03-04 10:48 发表评论
]]>ＲＦＩＤhttp://www.blogjava.net/zqli/articles/33216.html放水老倌放水老倌Thu, 02 Mar 2006 06:38:00 GMThttp://www.blogjava.net/zqli/articles/33216.htmlhttp://www.blogjava.net/zqli/comments/33216.htmlhttp://www.blogjava.net/zqli/articles/33216.html#Feedback4http://www.blogjava.net/zqli/comments/commentRss/33216.htmlhttp://www.blogjava.net/zqli/services/trackbacks/33216.html射频技术和条形码有什么不同？
主要的区别如下：
有无写入信息或更新内存的能力。条形码的内存不能更改。射频标签不像条形码，它特有的辨识器不能被复制。标签的作用不仅仅局限于视野之内，因为信息是由无线电波传输，而条形码必须在视野之内。

电子产品代码并不仅仅是一个无线电波条形码，它包含著一系列的数据和信息，象产地，日期代码和其他关键的供应信息，这些信息储存在一个小的硅片中，利用标签，解读器和计算机的联网，生产者和零售商就可以随时了解精确的产品和库存信息。


放水老倌 2006-03-02 14:38 发表评论
]]>Struts->JSFhttp://www.blogjava.net/zqli/articles/31740.html放水老倌放水老倌Tue, 21 Feb 2006 01:21:00 GMThttp://www.blogjava.net/zqli/articles/31740.htmlhttp://www.blogjava.net/zqli/comments/31740.htmlhttp://www.blogjava.net/zqli/articles/31740.html#Feedback0http://www.blogjava.net/zqli/comments/commentRss/31740.htmlhttp://www.blogjava.net/zqli/services/trackbacks/31740.html

放水老倌 2006-02-21 09:21 发表评论
]]>